A shared instance of a `dijit.DialogUnderlay` created and
used by `dijit.Dialog`, though never created until some Dialog
or subclass thereof is shown.
This should be a returned object from dijit.getBookmark()
dijit._Widget or {domNode: DomNode} structure
The button that was just pressed. If focus has disappeared or moved
to this button, returns the previous focus. In this case the bookmark
information is already lost, and null is returned.
iframe in which menu was opened
A handle to restore focus/selection, to be passed to `dijit.focus`
object returned by get(), or a DomNode
Currently only used by editor.
Handle to pass to unregisterIframe()
Handle returned by registerIframe()
Users should call registerIframe() instead of this method.
If specified this is the window associated with the iframe,
i.e. iframe.contentWindow.
If specified, report any focus events inside targetWindow as
an event on effectiveNode, rather than on evt.target.
Handle to pass to unregisterWin()
The node that was touched.
"mouse" if the focus/touch was caused by a mouse down event
array of widget id's, starting from the top (outermost) widget
"mouse" if the focus/touch was caused by a mouse down event
Finds the following descendants of the specified root node:
* the first tab-navigable element in document order
without a tabIndex or with tabIndex="0"
* the last tab-navigable element in document order
without a tabIndex or with tabIndex="0"
* the first element in document order with the lowest
positive tabIndex value
* the last element in document order with the highest
positive tabIndex value
NOTE: node is assumed to be absolutely or relatively positioned.
Try to place node's top right corner at (10,20).
If that makes node go (partially) off screen, then try placing
bottom left corner at (10,20).
placeOnScreen(node, {x: 10, y: 20}, ["TR", "BL"])
Object like {x: 10, y: 20}
Array of Strings representing order to try corners in, like ["TR", "BL"].
Possible values are:
* "BL" - bottom left
* "BR" - bottom right
* "TL" - top left
* "TR" - top right
set padding to put some buffer around the element you want to position.
Array of elements like: {corner: 'TL', pos: {x: 10, y: 20} }
Above example says to put the top-left corner of the node at (10,20)
aroundNodeCorner, nodeCorner, size)
for things like tooltip, they are displayed differently (and have different dimensions)
based on their orientation relative to the parent. This adjusts the popup based on orientation.
It also passes in the available size for the popup, which is useful for tooltips to
tell them that their width is limited to a certain amount. layoutNode() may return a value expressing
how much the popup had to be modified to fit into the available space. This is used to determine
what the best placement is.
Size of aroundNode, ex: {w: 200, h: 50}
Place node such that corner of node touches a corner of
aroundNode, and that node is fully visible.
dijit.placeOnScreenAroundNode(node, aroundNode, {'BL':'TL', 'TR':'BR'});
This will try to position node such that node's top-left corner is at the same position
as the bottom left corner of the aroundNode (ie, put node below
aroundNode, with left edges aligned). If that fails it will try to put
the bottom-right corner of node where the top right corner of aroundNode is
(ie, put node above aroundNode, with right edges aligned)
Ordered list of pairs of corners to try matching up.
Each pair of corners is represented as a key/value in the hash,
where the key corresponds to the aroundNode's corner, and
the value corresponds to the node's corner:
{ aroundNodeCorner1: nodeCorner1, aroundNodeCorner2: nodeCorner2, ...}
The following strings are used to represent the four corners:
* "BL" - bottom left
* "BR" - bottom right
* "TL" - top left
* "TR" - top right
Function(node, aroundNodeCorner, nodeCorner)
For things like tooltip, they are displayed differently (and have different dimensions)
based on their orientation relative to the parent. This adjusts the popup based on orientation.
String[] This variable controls the position of the drop down.
It's an array of strings with the following values:
* before: places drop down to the left of the target node/widget, or to the right in
the case of RTL scripts like Hebrew and Arabic
* after: places drop down to the right of the target node/widget, or to the left in
the case of RTL scripts like Hebrew and Arabic
* above: drop down goes above target node
* below: drop down goes below target node
The list is positions is tried, in order, until a position is found where the drop down fits
within the viewport.
Whether the popup will be displaying in leftToRight mode.
True if elem has the specific role attribute and false if not.
For backwards compatibility if role parameter not provided,
returns true if has a role
The role of elem or an empty string if elem
does not have a role.
Replace existing role attribute with new role.
Checks for an attribute called "aria-"+state.
true if elem has a value for the given state and
false if it does not.
Checks for an attribute called "aria-"+state.
The value of the requested state on elem
or an empty string if elem has no value for state.
Sets an attribute called "aria-"+state.
Sets an attribute called "aria-"+state.
Currently focused item on screen
Previously focused item on screen
List of currently active widgets (focused widget and it's ancestors)
The default animation speed (in ms) to use for all Dijit
transitional animations, unless otherwise specified
on a per-instance basis. Defaults to 200, overrided by
<code>djConfig.defaultDuration</code>
A rollup that includes every dijit. You probably don't need this.
A roll-up for common dijit methods
Home of the official dijit demo code
A simple GUI for choosing a date in the context of a monthly calendar.
This widget can't be used in a form because it doesn't serialize the date to an
`<input>` field. For a form element, use dijit.form.DateTextBox instead.
Note that the parser takes all dates attributes passed in the
[RFC 3339 format](http://www.faqs.org/rfcs/rfc3339.html), e.g. `2005-06-30T08:05:00-07:00`
so that they are serializable and locale-independent.
Set the current date and update the UI. If the date is disabled, the value will
not change, but the display will change to the corresponding month.
Either a Date or the number of seconds since 1970.
"month" or "year"
Number of months or years
If true, will focus() the cell even if calendar itself doesn't have focus
Called from _onKeyPress() to handle keypress on a stand alone Calendar,
and also from `dijit.form._DateTimeTextBox` to pass a keypress event
from the `dijit.form.DateTextBox` to be handled in this widget
False if the key was recognized as a navigation key,
to indicate that the event was handled by Calendar and shouldn't be propogated
Formerly used by `dijit.form._DateTimeTextBox` (and thus `dijit.form.DateTextBox`)
to get notification when the user has clicked a date. Now onExecute() (above) is used.
The currently selected Date, initially set to invalid date to indicate no selection.
TODO: for 2.0 make this a string (ISO format) rather than a Date
JavaScript namespace to find Calendar routines. Uses Gregorian Calendar routines
at dojo.date by default.
How to represent the days of the week in the calendar header. See dojo.date.locale
Order fields are traversed when user hits the tab key
Date object containing the currently focused date, or the date which would be focused
if the calendar itself was focused. Also indicates which year and month to display,
i.e. the current "page" the calendar is on.
List of names of months, possibly w/some undefined entries for Hebrew leap months
(ex: ["January", "February", undefined, "April", ...])
Our checked state
Grid showing various colors, so the user can pick a certain color.
Can be used standalone, or as a popup.
Size of grid, either "7x10" or "3x4".
The template of this widget.
Flag to parser to leave alone the script tags contained inside of me
Flag to parser to not try and parse widgets declared inside of me
Name of class being declared, ex: "acme.myWidget"
List containing the prototype for this widget, and also any mixins,
ex: ["dijit._Widget", "dijit._Container"]
Pops up a modal dialog window, blocking access to the screen
and also graying out the screen Dialog is extended from
ContentPane so it supports all the same parameters (href, etc.)
dojo.Deferred
Deferred object that resolves when the display animation is complete
dojo.Deferred
Deferred object that resolves when the hide animation is complete
True if Dialog is currently displayed on screen.
The time in milliseconds it takes the dialog to fade in and out
A Toggle to modify the default focus behavior of a Dialog, which
is to re-focus the element which had focus before being opened.
False will disable refocusing. Default: true
A Toggle to modify the default focus behavior of a Dialog, which
is to focus on the first dialog element after opening the dialog.
False will disable autofocusing. Default: true
The pointer to the first focusable node in the dialog.
Set by <code>dijit._DialogMixin._getFocusItems</code>.
The pointer to which node has focus prior to our dialog.
Set by <code>dijit._DialogMixin._getFocusItems</code>.
Don't change this parameter from the default value.
This ContentPane parameter doesn't make sense for Dialog, since Dialog
is never a child of a layout container, nor can you specify the size of
Dialog in order to control the size of an inner widget.
Toggles the moveable aspect of the Dialog. If true, Dialog
can be dragged by it's title. If false it will remain centered
in the viewport.
Allows the user to add an aria-describedby attribute onto the dialog. The value should
be the id of the container element of text that describes the dialog purpose (usually
the first text in the dialog).
<div dojoType="dijit.Dialog" aria-describedby="intro" .....>
<div id="intro">Introductory text</div>
<div>rest of dialog contents</div>
</div>
A component used to block input behind a `dijit.Dialog`. Only a single
instance of this widget is created by `dijit.Dialog`, and saved as
a reference to be shared between all Dialogs as `dijit._underlay`
The underlay itself can be styled based on and id:
#myDialog_underlay { background-color:red; }
In the case of `dijit.Dialog`, this id is based on the id of the Dialog,
suffixed with _underlay.
Sets the background to the size of the viewport (rather than the size
of the document) since we need to cover the whole browser window, even
if the document is only a few lines long.
Id of the dialog.... DialogUnderlay's id is based on this id
This class name is used on the DialogUnderlay node, in addition to dijitDialogUnderlay
This widget provides basic WYSIWYG editing features, based on the browser's
underlying rich text editing capability, accompanied by a toolbar (`dijit.Toolbar`).
A plugin model is available to extend the editor's capabilities as well as the
the options available in the toolbar. Content generation may vary across
browsers, and clipboard operations may have different results, to name
a few limitations. Note: this widget should not be used with the HTML
<TEXTAREA> tag -- see dijit._editor.RichText for details.
String, args object or plugin instance
args:
This object will be passed to the plugin constructor
Used when creating an instance from
something already in this.plugins. Ensures that the new
instance is assigned to this.plugins at that index.
A list of plugin names (as strings) or instances (as objects)
for this widget.
When declared in markup, it might look like:
plugins="['bold',{name:'dijit._editor.plugins.FontChoice', command:'fontName', generic:true}]"
A list of extra plugin names which will be appended to plugins array
the following 3 functions are required to make the editor play nice under a layout widget, see #4070
Whether we shall use custom undo/redo support instead of the native
browser support. By default, we now use custom undo. It works better
than native browser support and provides a consistent behavior across
browsers with a minimal performance hit. We already had the hit on
the slowest browser, IE, anyway.
When using customUndo, not every keystroke will be saved as a step.
Instead typing (including delete) will be grouped together: after
a user stops typing for editActionInterval seconds, a step will be
saved; if a user resume typing within editActionInterval seconds,
the timeout will be restarted. By default, editActionInterval is 3
seconds.
This is called on meaningful events in the editor, such as change of selection
or caret position (but not simple typing of alphanumeric keys). It gives the
plugin a chance to update the CSS of its button.
For example, the "bold" plugin will highlight/unhighlight the bold button depending on whether the
characters next to the caret are bold or not.
Only makes sense when `useDefaultCommand` is true, as it calls Editor.queryCommandEnabled(`command`).
Sets named properties on a plugin which may potentially be handled by a
setter in the plugin.
For example, if the plugin has a properties "foo"
and "bar" and a method named "_setFooAttr", calling:
plugin.set("foo", "Howdy!");
would be equivalent to writing:
plugin._setFooAttr("Howdy!");
and:
plugin.set("bar", 3);
would be equivalent to writing:
plugin.bar = 3;
set() may also be called with a hash of name/value pairs, ex:
plugin.set({
foo: "Howdy",
bar: 3
})
This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
The property to set.
The value to set in the property.
Get a named property from a plugin. The property may
potentially be retrieved via a getter method. If no getter is defined, this
just retrieves the object's property.
For example, if the plugin has a properties "foo"
and "bar" and a method named "_getFooAttr", calling:
plugin.get("foo");
would be equivalent to writing:
plugin._getFooAttr();
and:
plugin.get("bar");
would be equivalent to writing:
plugin.bar;
property to get.
Points to the parent editor
The CSS class name for the button node is formed from <code>iconClassPrefix</code> and <code>command</code>
Pointer to <code>dijit.form.Button</code> or other widget (ex: <code>dijit.form.FilteringSelect</code>)
that is added to the toolbar to control this plugin.
If not specified, will be created on initialization according to <code>buttonClass</code>
String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
Passed to editor.execCommand() if <code>useDefaultCommand</code> is true.
If true, this plugin executes by calling Editor.execCommand() with the argument specified in <code>command</code>.
Class
Class of widget (ex: dijit.form.Button or dijit.form.FilteringSelect)
that is added to the toolbar to control this plugin.
This is used to instantiate the button, unless <code>button</code> itself is specified directly.
Flag to indicate if this plugin has been disabled and should do nothing
helps control button state, among other things. Set via the setter api.
Behavior for an existing node (`<p>`, `<div>`, `<span>`, etc.) so that
when you click it, an editor shows up in place of the original
text. Optionally, Save and Cancel button are displayed below the edit widget.
When Save is clicked, the text is pulled from the edit
widget and redisplayed and the edit widget is again hidden.
By default a plain Textarea widget is used as the editor (or for
inline values a TextBox), but you can specify an editor such as
dijit.Editor (for editing HTML) or a Slider (for adjusting a number).
An edit widget must support the following API to be used:
- displayedValue or value as initialization parameter,
and available through set('displayedValue') / set('value')
- void focus()
- DOM-node focusNode = node containing editable text
Focus on the display mode text
Is the node currently in edit mode?
Changing the value automatically saves it; don't have to push save button
(and save button isn't even displayed)
Save button label
Cancel button label
Set this to true if the specified Editor's value should be interpreted as HTML
rather than plain text (ex: <code>dijit.Editor</code>)
Class name (or reference to the Class) for Editor widget
Class name (or reference to the Class) for widget that wraps the editor widget, displaying save/cancel
buttons.
Set of parameters for editor, like {required: true}
If true, clicking the InlineEditBox to edit it will have no effect.
Width of editor. By default it's width=100% (ie, block mode).
The display value of the widget in read-only mode
The text that gets displayed when there is no value (so that the user has a place to click to edit)
For autoSave widgets, if Esc/Enter, call cancel/save.
pointer to menu that displayed me
number of milliseconds before hovering (without clicking) causes the popup to automatically open.
is an Object containing:
* target:
The node that is being clicked
* iframe:
If an <iframe> is being clicked, iframe points to that iframe
* coords:
Put menu at specified x/y position in viewport, or if iframe is
specified, then relative to iframe.
_openMyself() formerly took the event object, and since various code references
evt.target (after connecting to _openMyself()), using an Object for parameters
(so that old code still works).
Label to search for - if not specified, then all placeholders
are returned
An array of placeholders that match the given label
Array of dom node ids of nodes to attach to.
Fill this with nodeIds upon widget creation and it becomes context menu for those nodes.
If true, right clicking anywhere on the window will cause this context menu to open.
If false, must specify targetNodeIds.
If true, menu will open on left click instead of right click, similiar to a file menu.
When this menu closes, re-focus the element which had focus before it was opened.
This is a MenuBar widget, not a (vertical) Menu widget.
Handles normalized getting and setting of attributes on DOM
Nodes. If 2 arguments are passed, and a the second argumnt is a
string, acts as a getter.
If a third argument is passed, or if the second argument is a
map of attributes, acts as a setter.
When passing functions as values, note that they will not be
directly assigned to slots on the node, but rather the default
behavior will be removed and the new behavior will be added
using `dojo.connect()`, meaning that event handler properties
will be normalized and that some caveats with regards to
non-standard behaviors for onsubmit apply. Namely that you
should cancel form submission using `dojo.stopEvent()` on the
passed event object instead of returning a boolean value from
the handler itself.
// get the current value of the "foo" attribute on a node
dojo.attr(dojo.byId("nodeId"), "foo");
// or we can just pass the id:
dojo.attr("nodeId", "foo");
// use attr() to set the tab index
dojo.attr("nodeId", "tabIndex", 3);
Set multiple values at once, including event handlers:
dojo.attr("formId", {
"foo": "bar",
"tabIndex": -1,
"method": "POST",
"onsubmit": function(e){
// stop submitting the form. Note that the IE behavior
// of returning true or false will have no effect here
// since our handler is connect()ed to the built-in
// onsubmit behavior and so we need to use
// dojo.stopEvent() to ensure that the submission
// doesn't proceed.
dojo.stopEvent(e);
// submit the form with Ajax
dojo.xhrPost({ form: "formId" });
}
});
Style is s special case: Only set with an object hash of styles
dojo.attr("someNode",{
id:"bar",
style:{
width:"200px", height:"100px", color:"#000"
}
});
Again, only set style as an object hash of styles:
var obj = { color:"#fff", backgroundColor:"#000" };
dojo.attr("someNode", "style", obj);
// though shorter to use `dojo.style()` in this case:
dojo.style("someNode", obj);
id or reference to the element to get or set the attribute on
the name of the attribute to get or set.
The value to set for the attribute
when used as a getter, the value of the requested attribute
or null if that attribute does not have a specified or
default value;
when used as a setter, the DOM node
id or reference to the element to check
the name of the attribute
true if the requested attribute is specified on the
given element, and false otherwise
Getting the style value uses the computed style for the node, so the value
will be a calculated value, not just the immediate node.style value.
Also when getting values, use specific style names,
like "borderBottomWidth" instead of "border" since compound values like
"border" are not necessarily reflected as expected.
If you want to get node dimensions, use `dojo.marginBox()`,
`dojo.contentBox()` or `dojo.position()`.
Passing only an ID or node returns the computed style object of
the node:
dojo.style("thinger");
Passing a node and a style property returns the current
normalized, computed value for that property:
dojo.style("thinger", "opacity"); // 1 by default
Passing a node, a style property, and a value changes the
current display of the node and returns the new computed value
dojo.style("thinger", "opacity", 0.5); // == 0.5
Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
dojo.style("thinger", {
"opacity": 0.5,
"border": "3px solid black",
"height": "300px"
});
When the CSS style property is hyphenated, the JavaScript property is camelCased.
font-size becomes fontSize, and so on.
dojo.style("thinger",{
fontSize:"14pt",
letterSpacing:"1.2em"
});
dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
dojo.query(".someClassName").style("visibility","hidden");
// or
dojo.query("#baz > div").style({
opacity:0.75,
fontSize:"13pt"
});
id or reference to node to get/set style for
the style property to set in DOM-accessor format
("borderWidth", not "border-width") or an object with key/value
pairs suitable for setting each property.
If passed, sets value on the node for style, handling
cross-browser concerns. When setting a pixel value,
be sure to include "px" in the value. For instance, top: "200px".
Otherwise, in some cases, some browsers will not apply the style.
The node reference to remove data from
If omitted, remove all data in this dataset.
If passed, remove only the passed <code>key</code> in the associated dataset
super expensive: GC all data in the data for nodes that no longer exist in the dom.
MUCH safer to do this yourself, manually, on a per-node basis (via `NodeList.removeData()`)
provided as a stop-gap for exceptionally large/complex applications with constantly changing
content regions (eg: a dijit.layout.ContentPane with replacing data)
There is NO automatic GC going on. If you dojo.destroy() a node, you should _removeNodeData
prior to destruction.
this function can handle all 4 CSS3 Color Module formats: rgb,
rgba, hsl, hsla, including rgb(a) with percentage values.
A dojo.Color object. If obj is passed, it will be the return value.
var thing = dojo.colorFromHex("#ededed"); // grey, longhand
var thing = dojo.colorFromHex("#000"); // black, shorthand
A dojo.Color object. If obj is passed, it will be the return value.
var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha
A dojo.Color object. If obj is passed, it will be the return value.
Acceptable input values for str may include arrays of any form
accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
10, 50)"
A dojo.Color object. If obj is passed, it will be the return value.
function printFirstAndList(items){
dojo.when(findFirst(items), console.log);
dojo.when(findLast(items), console.log);
}
function findFirst(items){
return dojo.when(items, function(items){
return items[0];
});
}
function findLast(items){
return dojo.when(items, function(items){
return items[items.length];
});
}
And now all three of his functions can be used sync or async.
printFirstAndLast([1,2,3,4]) will work just as well as
printFirstAndLast(dojo.xhrGet(...));
Wanted to override getText(), but it is used by
the widget code in too many, synchronous ways right now.
a uri which points at the script to be loaded
a callback function to process the result of evaluating the script
as an expression, typically used by the resource bundle loader to
load JSON-style resources
A relative or absolute uri.
Default false. If fail_ok and loading fails, return null
instead of throwing.
The response text. null is returned when there is a
failure and failure is okay (an exception otherwise)
dojo.addOnWindowUnload(functionPointer)
dojo.addOnWindowUnload(object, "functionName")
dojo.addOnWindowUnload(object, function(){ /* ... */});
dojo.pushContext treats contexts as a stack. The
auto-detected contexts which are initially provided using
dojo.setContext() require authors to keep state in order to
"return" to a previous context, whereas the
dojo.pushContext and dojo.popContext methods provide a more
natural way to augment blocks of code to ensure that they
execute in a different window or frame without issue. If
called without any arguments, the default context (the
context when Dojo is first loaded) is instead pushed into
the stack. If only a single string is passed, a node in the
intitial context's document is looked up and its
contextWindow and contextDocument properties are used as
the context to push. This means that iframes can be given
an ID and code can be executed in the scope of the iframe's
document in subsequent calls easily.
The global context. If a string, the id of the frame to
search for a context and document.
The document element to execute subsequent code with.
Look up a node by ID:
var n = dojo.byId("foo");
Check if a node exists, and use it.
var n = dojo.byId("bar");
if(n){ doStuff() ... }
Allow string or DomNode references to be passed to a custom function:
var foo = function(nodeOrId){
nodeOrId = dojo.byId(nodeOrId);
// ... more stuff
}
A string to match an HTML id attribute or a reference to a DOM Node
Document to work in. Defaults to the current value of
dojo.doc. Can be used to retrieve
node references from other documents.
dojo.body().appendChild(dojo.doc.createElement('div'));
Loads and interprets the script located at relpath, which is
relative to the script root directory. If the script is found but
its interpretation causes a runtime exception, that exception is
not caught by us, so the caller will see it. We return a true
value if and only if the script is found.
A relative path to a script (no leading '/', and typically ending
in '.js').
A module whose existance to check for after loading a path. Can be
used to determine success or failure of the load.
a callback function to pass the result of evaluating the script
Registers a function to be triggered after the DOM has finished
loading and `dojo.require` modules have loaded. Widgets declared in markup
have been instantiated if `djConfig.parseOnLoad` is true when this fires.
Images and CSS files may or may not have finished downloading when
the specified function is called. (Note that widgets' CSS and HTML
code is guaranteed to be downloaded before said widgets are
instantiated, though including css resouces BEFORE any script elements
is highly recommended).
Register an anonymous function to run when everything is ready
dojo.addOnLoad(function(){ doStuff(); });
Register a function to run when everything is ready by pointer:
var init = function(){ doStuff(); }
dojo.addOnLoad(init);
Register a function to run scoped to `object`, either by name or anonymously:
dojo.addOnLoad(object, "functionName");
dojo.addOnLoad(object, function(){ doStuff(); });
This function is mainly a marker for the xdomain loader to know parts of
code that needs be executed outside the function wrappper that is placed around modules.
The init function could be executed more than once, and it should make no assumptions
on what is loaded, or what modules are available. Only the functionality in Dojo Base
is allowed to be used. Avoid using this method. For a valid use case,
see the source for dojox.gfx.
a function reference. Executed immediately.
Modules are loaded via dojo.require by using one of two loaders: the normal loader
and the xdomain loader. The xdomain loader is used when dojo was built with a
custom build that specified loader=xdomain and the module lives on a modulePath
that is a whole URL, with protocol and a domain. The versions of Dojo that are on
the Google and AOL CDNs use the xdomain loader.
If the module is loaded via the xdomain loader, it is an asynchronous load, since
the module is added via a dynamically created script tag. This
means that dojo.require() can return before the module has loaded. However, this
should only happen in the case where you do dojo.require calls in the top-level
HTML page, or if you purposely avoid the loader checking for dojo.require
dependencies in your module by using a syntax like dojo["require"] to load the module.
Sometimes it is useful to not have the loader detect the dojo.require calls in the
module so that you can dynamically load the modules as a result of an action on the
page, instead of right at module load time.
Also, for script blocks in an HTML page, the loader does not pre-process them, so
it does not know to download the modules before the dojo.require calls occur.
So, in those two cases, when you want on-the-fly module loading or for script blocks
in the HTML page, special care must be taken if the dojo.required code is loaded
asynchronously. To make sure you can execute code that depends on the dojo.required
modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
executing.
This type of syntax works with both xdomain and normal loaders, so it is good
practice to always use this idiom for on-the-fly code loading and in HTML script
blocks. If at some point you change loaders and where the code is loaded from,
it will all still work.
More on how dojo.require
`dojo.require("A.B")` first checks to see if symbol A.B is
defined. If it is, it is simply returned (nothing to do).
If it is not defined, it will look for `A/B.js` in the script root
directory.
`dojo.require` throws an exception if it cannot find a file
to load, or if the symbol `A.B` is not defined after loading.
It returns the object `A.B`, but note the caveats above about on-the-fly loading and
HTML script blocks when the xdomain loader is loading a module.
`dojo.require()` does nothing about importing symbols into
the current namespace. It is presumed that the caller will
take care of that.
To use dojo.require in conjunction with dojo.ready:
dojo.require("foo");
dojo.require("bar");
dojo.addOnLoad(function(){
//you can now safely do something with foo and bar
});
For example, to import all symbols into a local block, you might write:
with (dojo.require("A.B")) {
...
}
And to import just the leaf symbol to a local variable:
var B = dojo.require("A.B");
...
module name to load, using periods for separators,
e.g. "dojo.date.locale". Module paths are de-referenced by dojo's
internal mapping of locations to names and are disambiguated by
longest prefix. See <code>dojo.registerModulePath()</code> for details on
registering new modules.
if <code>true</code>, omitModuleCheck skips the step of ensuring that the
loaded file actually defines the symbol it is referenced by.
For example if it called as <code>dojo.require("a.b.c")</code> and the
file located at <code>a/b/c.js</code> does not define an object <code>a.b.c</code>,
and exception will be throws whereas no exception is raised
when called as <code>dojo.require("a.b.c", true)</code>
the required namespace object
Each javascript source file is called a resource. When a
resource is loaded by the browser, `dojo.provide()` registers
that it has been loaded.
Each javascript source file must have at least one
`dojo.provide()` call at the top of the file, corresponding to
the file name. For example, `js/dojo/foo.js` must have
`dojo.provide("dojo.foo");` before any calls to
`dojo.require()` are made.
For backwards compatibility reasons, in addition to registering
the resource, `dojo.provide()` also ensures that the javascript
object for the module exists. For example,
`dojo.provide("dojox.data.FlickrStore")`, in addition to
registering that `FlickrStore.js` is a resource for the
`dojox.data` module, will ensure that the `dojox.data`
javascript object exists, so that calls like
`dojo.data.foo = function(){ ... }` don't fail.
In the case of a build where multiple javascript source files
are combined into one bigger file (similar to a .lib or .jar
file), that file may contain multiple dojo.provide() calls, to
note that it includes multiple resources.
Safely create a `my` object, and make dojo.require("my.CustomModule") work
dojo.provide("my.CustomModule");
A dot-sperated string identifying a resource.
This method takes a "map" of arrays which one can use to
optionally load dojo modules. The map is indexed by the
possible dojo.name_ values, with two additional values:
"default" and "common". The items in the "default" array will
be loaded if none of the other items have been choosen based on
dojo.name_, set by your host environment. The items in the
"common" array will *always* be loaded, regardless of which
list is chosen.
dojo.platformRequire({
browser: [
"foo.sample", // simple module
"foo.test",
["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
],
default: [ "foo.sample._base" ],
common: [ "important.module.common" ]
});
dojo.requireIf(dojo.isBrowser, "my.special.Module");
An unregistered module is given the default path of ../[module],
relative to Dojo root. For example, module acme is mapped to
../acme. If you want to use a different module name, use
dojo.registerModulePath.
If your dojo.js is located at this location in the web root:
/myapp/js/dojo/dojo/dojo.js
and your modules are located at:
/myapp/js/foo/bar.js
/myapp/js/foo/baz.js
/myapp/js/foo/thud/xyzzy.js
Your application can tell Dojo to locate the "foo" namespace by calling:
dojo.registerModulePath("foo", "../../foo");
At which point you can then use dojo.require() to load the
modules (assuming they provide() the same things which are
required). The full code might be:
<script type="text/javascript"
src="/myapp/js/dojo/dojo/dojo.js"></script>
<script type="text/javascript">
dojo.registerModulePath("foo", "../../foo");
dojo.require("foo.bar");
dojo.require("foo.baz");
dojo.require("foo.thud.xyzzy");
</script>
Load translated resource bundles provided underneath the "nls"
directory within a package. Translated resources may be located in
different packages throughout the source tree.
Each directory is named for a locale as specified by RFC 3066,
(http://www.ietf.org/rfc/rfc3066.txt), normalized in lowercase.
Note that the two bundles in the example do not define all the
same variants. For a given locale, bundles will be loaded for
that locale and all more general locales above it, including a
fallback at the root directory. For example, a declaration for
the "de-at" locale will first load `nls/de-at/bundleone.js`,
then `nls/de/bundleone.js` and finally `nls/bundleone.js`. The
data will be flattened into a single Object so that lookups
will follow this cascading pattern. An optional build step can
preload the bundles to avoid data redundancy and the multiple
network hits normally required to load these resources.
A particular widget may define one or more resource bundles,
structured in a program as follows, where moduleName is
mycode.mywidget and bundleNames available include bundleone and
bundletwo:
...
mycode/
mywidget/
nls/
bundleone.js (the fallback translation, English in this example)
bundletwo.js (also a fallback translation)
de/
bundleone.js
bundletwo.js
de-at/
bundleone.js
en/
(empty; use the fallback translation)
en-us/
bundleone.js
en-gb/
bundleone.js
es/
bundleone.js
bundletwo.js
...etc
...
name of the package containing the "nls" directory in which the
bundle is found
bundle name, i.e. the filename without the '.js' suffix. Using "nls" as a
a bundle name is not supported, since "nls" is the name of the folder
that holds bundles. Using "nls" as the bundle name will cause problems
with the custom build.
the locale to load (optional) By default, the browser's user
locale as defined by dojo.locale
A comma-separated list of the available, flattened locales for this
bundle. This argument should only be set by the build process.
var pngPath = dojo.moduleUrl("acme","images/small.png");
console.dir(pngPath); // list the object properties
// create an image and set it's source to pngPath's value:
var img = document.createElement("img");
// NOTE: we assign the string representation of the url object
img.src = pngPath.toString();
// add our image to the document
dojo.body().appendChild(img);
you may de-reference as far as you like down the package
hierarchy. This is sometimes handy to avoid lenghty relative
urls or for building portable sub-packages. In this example,
the `acme.widget` and `acme.util` directories may be located
under different roots (see `dojo.registerModulePath`) but the
the modules which reference them can be unaware of their
relative locations on the filesystem:
// somewhere in a configuration block
dojo.registerModulePath("acme.widget", "../../acme/widget");
dojo.registerModulePath("acme.util", "../../util");
// ...
// code in a module using acme resources
var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when
run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
1.6's indexOf skips the holes in the sparse array.
For details on this method, see:
https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when
run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
1.6's lastIndexOf skips the holes in the sparse array.
For details on this method, see:
https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
run over sparse arrays, this implemenation passes the "holes" in the sparse array to
the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
For more details, see:
https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
// log out all members of the array:
dojo.forEach(
[ "thinger", "blah", "howdy", 10 ],
function(item){
console.log(item);
}
);
// log out the members and their indexes
dojo.forEach(
[ "thinger", "blah", "howdy", 10 ],
function(item, idx, arr){
console.log(item, "at index:", idx);
}
);
// use a scoped object member as the callback
var obj = {
prefix: "logged via obj.callback:",
callback: function(item){
console.log(this.prefix, item);
}
};
// specifying the scope function executes the callback in that scope
dojo.forEach(
[ "thinger", "blah", "howdy", 10 ],
obj.callback,
obj
);
// alternately, we can accomplish the same thing with dojo.hitch()
dojo.forEach(
[ "thinger", "blah", "howdy", 10 ],
dojo.hitch(obj, "callback")
);
the array to iterate over. If a string, operates on individual characters.
a function is invoked with three arguments: item, index, and array
may be used to scope the call to callback
This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
run over sparse arrays, this implemenation passes the "holes" in the sparse array to
the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
For more details, see:
https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
// returns false
dojo.every([1, 2, 3, 4], function(item){ return item>1; });
// returns true
dojo.every([1, 2, 3, 4], function(item){ return item>0; });
the array to iterate on. If a string, operates on individual characters.
a function is invoked with three arguments: item, index,
and array and returns true if the condition is met.
may be used to scope the call to callback
This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
run over sparse arrays, this implemenation passes the "holes" in the sparse array to
the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
For more details, see:
https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
// is true
dojo.some([1, 2, 3, 4], function(item){ return item>1; });
// is false
dojo.some([1, 2, 3, 4], function(item){ return item<1; });
the array to iterate over. If a string, operates on individual characters.
a function is invoked with three arguments: item, index,
and array and returns true if the condition is met.
may be used to scope the call to callback
This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
run over sparse arrays, this implemenation passes the "holes" in the sparse array to
the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
For more details, see:
https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
// returns [2, 3, 4, 5]
dojo.map([1, 2, 3, 4], function(item){ return item+1 });
the array to iterate on. If a string, operates on
individual characters.
a function is invoked with three arguments, (item, index,
array), and returns a value
may be used to scope the call to callback
This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
run over sparse arrays, this implemenation passes the "holes" in the sparse array to
the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
For more details, see:
https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
// returns [2, 3, 4]
dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
the array to iterate over.
a function that is invoked with three arguments (item,
index, array). The return of this function is expected to
be a boolean which determines whether the passed-in item
will be included in the returned array.
may be used to scope the call to callback
Connects listeners to actions, so that after event fires, a
listener is called with the same arguments passed to the original
function.
Since `dojo.connect` allows the source of events to be either a
"regular" JavaScript function or a DOM event, it provides a uniform
interface for listening to all the types of events that an
application is likely to deal with though a single, unified
interface. DOM programmers may want to think of it as
"addEventListener for everything and anything".
When setting up a connection, the `event` parameter must be a
string that is the name of the method/event to be listened for. If
`obj` is null, `dojo.global` is assumed, meaning that connections
to global methods are supported but also that you may inadvertently
connect to a global by passing an incorrect object name or invalid
reference.
`dojo.connect` generally is forgiving. If you pass the name of a
function or method that does not yet exist on `obj`, connect will
not fail, but will instead set up a stub method. Similarly, null
arguments may simply be omitted such that fewer than 4 arguments
may be required to set up a connection See the examples for details.
The return value is a handle that is needed to
remove this connection with `dojo.disconnect`.
When obj.onchange(), do ui.update():
dojo.connect(obj, "onchange", ui, "update");
dojo.connect(obj, "onchange", ui, ui.update); // same
Using return value for disconnect:
var link = dojo.connect(obj, "onchange", ui, "update");
...
dojo.disconnect(link);
When onglobalevent executes, watcher.handler is invoked:
dojo.connect(null, "onglobalevent", watcher, "handler");
When ob.onCustomEvent executes, customEventHandler is invoked:
dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
When ob.onCustomEvent executes, customEventHandler is invoked
with the same scope (this):
dojo.connect(ob, "onCustomEvent", null, customEventHandler);
dojo.connect(ob, "onCustomEvent", customEventHandler); // same
When globalEvent executes, globalHandler is invoked
with the same scope (this):
dojo.connect(null, "globalEvent", null, globalHandler);
dojo.connect("globalEvent", globalHandler); // same
The source object for the event function.
Defaults to <code>dojo.global</code> if null.
If obj is a DOM node, the connection is delegated
to the DOM event manager (unless dontFix is true).
name of the event function in obj.
I.e. identifies a property <code>obj[event]</code>.
The object that method will receive as "this".
If context is null and method is a function, then method
inherits the context of event.
If method is a string then context must be the source
object object for method (context[method]). If context is null,
dojo.global is used.
A function reference, or name of a function in context.
The function identified by method fires after event does.
method receives the same arguments as the event.
See context argument comments for information on method's scope.
If obj is a DOM node, set dontFix to true to prevent delegation
of this connection to the DOM event manager.
Removes the connection between event and the method referenced by handle.
the return value of the dojo.connect call that created the connection.
dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
The name of the topic to publish.
The source object for the event function. Defaults to dojo.global
if null.
The name of the event function in obj.
I.e. identifies a property obj[event].
Create a constructor using a compact notation for inheritance and
prototype extension.
Mixin ancestors provide a type of multiple inheritance.
Prototypes of mixin ancestors are copied to the new class:
changes to mixin prototypes will not affect classes to which
they have been mixed in.
Ancestors can be compound classes created by this version of
dojo.declare. In complex cases all base classes are going to be
linearized according to C3 MRO algorithm
(see http://www.python.org/download/releases/2.3/mro/ for more
details).
"className" is cached in "declaredClass" property of the new class,
if it was supplied. The immediate super class will be cached in
"superclass" property of the new class.
Methods in "props" will be copied and modified: "nom" property
(the declared name of the method) will be added to all copied
functions to help identify them for the internal machinery. Be
very careful, while reusing methods: if you use the same
function under different names, it can produce errors in some
cases.
It is possible to use constructors created "manually" (without
dojo.declare) as bases. They will be called as usual during the
creation of an instance, their methods will be chained, and even
called by "this.inherited()".
Special property "-chains-" governs how to chain methods. It is
a dictionary, which uses method names as keys, and hint strings
as values. If a hint string is "after", this method will be
called after methods of its base classes. If a hint string is
"before", this method will be called before methods of its base
classes.
If "constructor" is not mentioned in "-chains-" property, it will
be chained using the legacy mode: using "after" chaining,
calling preamble() method before each constructor, if available,
and calling postscript() after all constructors were executed.
If the hint is "after", it is chained as a regular method, but
postscript() will be called after the chain of constructors.
"constructor" cannot be chained "before", but it allows
a special hint string: "manual", which means that constructors
are not going to be chained in any way, and programmer will call
them manually using this.inherited(). In the latter case
postscript() will be called after the construction.
All chaining hints are "inherited" from base classes and
potentially can be overridden. Be very careful when overriding
hints! Make sure that all chained methods can work in a proposed
manner of chaining.
Once a method was chained, it is impossible to unchain it. The
only exception is "constructor". You don't need to define a
method in order to supply a chaining hint.
If a method is chained, it cannot use this.inherited() because
all other methods in the hierarchy will be called automatically.
Usually constructors and initializers of any kind are chained
using "after" and destructors of any kind are chained as
"before". Note that chaining assumes that chained methods do not
return any value: any returned value will be discarded.
dojo.declare("my.classes.bar", my.classes.foo, {
// properties to be added to the class prototype
someValue: 2,
// initialization function
constructor: function(){
this.myComplicatedObject = new ReallyComplicatedObject();
},
// other functions
someMethod: function(){
doStuff();
}
});
var MyBase = dojo.declare(null, {
// constructor, properties, and methods go here
// ...
});
var MyClass1 = dojo.declare(MyBase, {
// constructor, properties, and methods go here
// ...
});
var MyClass2 = dojo.declare(MyBase, {
// constructor, properties, and methods go here
// ...
});
var MyDiamond = dojo.declare([MyClass1, MyClass2], {
// constructor, properties, and methods go here
// ...
});
var F = function(){ console.log("raw constructor"); };
F.prototype.method = function(){
console.log("raw method");
};
var A = dojo.declare(F, {
constructor: function(){
console.log("A.constructor");
},
method: function(){
console.log("before calling F.method...");
this.inherited(arguments);
console.log("...back in A");
}
});
new A().method();
// will print:
// raw constructor
// A.constructor
// before calling F.method...
// raw method
// ...back in A
var A = dojo.declare(null, {
"-chains-": {
destroy: "before"
}
});
var B = dojo.declare(A, {
constructor: function(){
console.log("B.constructor");
},
destroy: function(){
console.log("B.destroy");
}
});
var C = dojo.declare(B, {
constructor: function(){
console.log("C.constructor");
},
destroy: function(){
console.log("C.destroy");
}
});
new C().destroy();
// prints:
// B.constructor
// C.constructor
// C.destroy
// B.destroy
var A = dojo.declare(null, {
"-chains-": {
constructor: "manual"
}
});
var B = dojo.declare(A, {
constructor: function(){
// ...
// call the base constructor with new parameters
this.inherited(arguments, [1, 2, 3]);
// ...
}
});
var A = dojo.declare(null, {
"-chains-": {
m1: "before"
},
m1: function(){
console.log("A.m1");
},
m2: function(){
console.log("A.m2");
}
});
var B = dojo.declare(A, {
"-chains-": {
m2: "after"
},
m1: function(){
console.log("B.m1");
},
m2: function(){
console.log("B.m2");
}
});
var x = new B();
x.m1();
// prints:
// B.m1
// A.m1
x.m2();
// prints:
// A.m2
// B.m2
The optional name of the constructor (loosely, a "class")
stored in the "declaredClass" property in the created prototype.
It will be used as a global name for a created constructor.
May be null, a Function, or an Array of Functions. This argument
specifies a list of bases (the left-most one is the most deepest
base).
An object whose properties are copied to the created prototype.
Add an instance-initialization function by making it a property
named "constructor".
New constructor function.
This function is used to mix in properties like dojo._mixin does,
but it skips a constructor property and decorates functions like
dojo.declare does.
It is meant to be used with classes and objects produced with
dojo.declare. Functions mixed in with dojo.safeMixin can use
this.inherited() like normal methods.
This function is used to implement extend() method of a constructor
produced with dojo.declare().
var A = dojo.declare(null, {
m1: function(){
console.log("A.m1");
},
m2: function(){
console.log("A.m2");
}
});
var B = dojo.declare(A, {
m1: function(){
this.inherited(arguments);
console.log("B.m1");
}
});
B.extend({
m2: function(){
this.inherited(arguments);
console.log("B.m2");
}
});
var x = new B();
dojo.safeMixin(x, {
m1: function(){
this.inherited(arguments);
console.log("X.m1");
},
m2: function(){
this.inherited(arguments);
console.log("X.m2");
}
});
x.m2();
// prints:
// A.m1
// B.m1
// X.m1
Target object to accept new properties.
Source object for new properties.
native event object
node to treat as "currentTarget"
The event object. If omitted, window.event is used on IE.
Event object to examine
The standard animation doesn't know what to do with something like
rect(...). This class identifies complex properties by they being a
string and having parenthesis. If so, that property is made into a
dojox.fx._Complex object and the getValue() is obtained from
there.
A simple animation that changes the width of the specified node.
dojo.animateProperty({
node: "nodeId",
properties: { width: 400 },
}).play();
Dojo figures out the start value for the width and converts the
integer specified for the width to the more expressive but
verbose form `{ width: { end: '400', units: 'px' } }` which you
can also specify directly. Defaults to 'px' if ommitted.
Animate width, height, and padding over 2 seconds... the
pedantic way:
dojo.animateProperty({ node: node, duration:2000,
properties: {
width: { start: '200', end: '400', units:"px" },
height: { start:'200', end: '400', units:"px" },
paddingTop: { start:'5', end:'50', units:"px" }
}
}).play();
Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
are written using "mixed case", as the hyphen is illegal as an object key.
Plug in a different easing function and register a callback for
when the animation ends. Easing functions accept values between
zero and one and return a value on that basis. In this case, an
exponential-in curve.
dojo.animateProperty({
node: "nodeId",
// dojo figures out the start value
properties: { width: { end: 400 } },
easing: function(n){
return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
},
onEnd: function(node){
// called when the animation finishes. The animation
// target is passed to this function
}
}).play(500); // delay playing half a second
Like all `dojo.Animation`s, animateProperty returns a handle to the
Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
to access these events outside of the Animation definiton:
var anim = dojo.animateProperty({
node:"someId",
properties:{
width:400, height:500
}
});
dojo.connect(anim,"onEnd", function(){
console.log("animation ended");
});
// play the animation now:
anim.play();
Each property can be a function whose return value is substituted along.
Additionally, each measurement (eg: start, end) can be a function. The node
reference is passed direcly to callbacks.
dojo.animateProperty({
node:"mine",
properties:{
height:function(node){
// shrink this node by 50%
return dojo.position(node).h / 2
},
width:{
start:function(node){ return 100; },
end:function(node){ return 200; }
}
}
}).play();
var ani = dojo.animateProperty({
node:dojo.byId("myDiv"),
duration:600,
properties:{
clip:{start:'rect(0px 50px 50px 0px)', end:'rect(10px 30px 30px 10px)'}
}
}).play();
`dojo.anim` is a simpler (but somewhat less powerful) version
of `dojo.animateProperty`. It uses defaults for many basic properties
and allows for positional parameters to be used in place of the
packed "property bag" which is used for other Dojo animation
methods.
The `dojo.Animation` object returned from `dojo.anim` will be
already playing when it is returned from this function, so
calling play() on it again is (usually) a no-op.
Fade out a node
dojo.anim("id", { opacity: 0 });
Fade out a node over a full second
dojo.anim("id", { opacity: 0 }, 1000);
a DOM node or the id of a node to animate CSS properties on
The number of milliseconds over which the animation
should run. Defaults to the global animation default duration
(350ms).
An easing function over which to calculate acceleration
and deceleration of the animation through its duration.
A default easing algorithm is provided, but you may
plug in any you wish. A large selection of easing algorithms
are available in <code>dojo.fx.easing</code>.
A function to be called when the animation finishes
running.
The number of milliseconds to delay beginning the
animation by. The default is 0.
Removes a node from its parent, clobbering it and all of its
children. Function only works with DomNodes, and returns nothing.
Destroy a node byId:
dojo.destroy("someId");
Destroy all nodes in a list by reference:
dojo.query(".someNode").forEach(dojo.destroy);
A String ID or DomNode reference of the element to be destroyed
Test is node id="bar" is a descendant of node id="foo"
if(dojo.isDescendant("bar", "foo")){ ... }
string id or node reference to test
string id or node reference of potential parent to test against
Make the node id="bar" unselectable
dojo.setSelectable("bar");
Make the node id="bar" selectable
dojo.setSelectable("bar", true);
id or reference to node
state to put the node in. false indicates unselectable, true
allows selection.
Place a node by string id as the last child of another node by string id:
dojo.place("someNode", "anotherNode");
Place a node by string id before another node by string id
dojo.place("someNode", "anotherNode", "before");
Create a Node, and place it in the body element (last child):
dojo.place("<div></div>", dojo.body());
Put a new LI as the first child of a list by id:
dojo.place("<li></li>", "someUl", "first");
id or node reference, or HTML fragment starting with "<" to place relative to refNode
id or node reference to use as basis for placement
string noting the position of node relative to refNode or a
number indicating the location in the childNodes collection of refNode.
Accepted string values are:
* before
* after
* replace
* only
* first
* last
"first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
"only" replaces all children. position defaults to "last" if not specified
DomNode
Returned values is the first argument resolved to a DOM node.
.place() is also a method of `dojo.NodeList`, allowing `dojo.query` node lookups.
Gets a "computed style" object which can be used to gather
information about the current state of the rendered node.
Note that this may behave differently on different browsers.
Values may have different formats and value encodings across
browsers.
Note also that this method is expensive. Wherever possible,
reuse the returned object.
Use the dojo.style() method for more consistent (pixelized)
return values.
dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
Reusing the returned object, avoiding multiple lookups:
var cs = dojo.getComputedStyle(dojo.byId("someNode"));
var w = cs.width, h = cs.height;
A reference to a DOM node. Does NOT support taking an
ID string for speed reasons.
a reference to a DOM node. Does NOT support taking an
ID string for speed reasons.
Number between 0 and 1
a reference to a DOM node. Does NOT support taking an
ID string for performance reasons.
A Number between 0 and 1. 0 specifies transparent.
Number between 0 and 1
Returns an object with `w`, `h`, `l`, `t` properties:
l/t = left/top padding (respectively)
w = the total of the left and right padding
h = the total of the top and bottom padding
If 'node' has position, l/t forms the origin for child nodes.
The w/h are used for calculating boxes.
Normally application code will not need to invoke this
directly, and will use the ...box... functions instead.
* l/t = the sum of left/top border (respectively)
* w = the sum of the left and right border
* h = the sum of the top and bottom border
The w/h are used for calculating boxes.
Normally application code will not need to invoke this
directly, and will use the ...box... functions instead.
* l/t = the sum of left/top padding and left/top border (respectively)
* w = the sum of the left and right padding and border
* h = the sum of the top and bottom padding and border
The w/h are used for calculating boxes.
Normally application code will not need to invoke this
directly, and will use the ...box... functions instead.
DOM Node reference. Id string not supported for performance
reasons.
left offset from parent.
top offset from parent.
width in current box model.
width in current box model.
unit measure to use for other measures. Defaults to "px".
Getter/setter for the margin-box of node.
Returns an object in the expected format of box (regardless
if box is passed). The object might look like:
`{ l: 50, t: 200, w: 300: h: 150 }`
for a node offset from its parent 50px to the left, 200px from
the top with a margin width of 300px and a margin-height of
150px.
Retrieve the marginbox of a passed node
var box = dojo.marginBox("someNodeId");
console.dir(box);
Set a node's marginbox to the size of another node
var box = dojo.marginBox("someNodeId");
dojo.marginBox("someOtherNode", box);
id or reference to DOM Node to get/set box for
If passed, denotes that dojo.marginBox() should
update/set the margin box for node. Box is an object in the
above format. All properties are optional if passed.
Returns an object in the expected format of box (regardless if box is passed).
The object might look like:
`{ l: 50, t: 200, w: 300: h: 150 }`
for a node offset from its parent 50px to the left, 200px from
the top with a content width of 300px and a content-height of
150px. Note that the content box may have a much larger border
or margin box, depending on the box model currently in use and
CSS values set/inherited for node.
While the getter will return top and left values, the
setter only accepts setting the width and height.
id or reference to DOM Node to get/set box for
If passed, denotes that dojo.contentBox() should
update/set the content box for node. Box is an object in the
above format, but only w (width) and h (height) are supported.
All properties are optional if passed.
The following values in IE contain an offset:
event.clientX
event.clientY
node.getBoundingClientRect().left
node.getBoundingClientRect().top
But other position related values do not contain this offset,
such as node.offsetLeft, node.offsetTop, node.style.left and
node.style.top. The offset is always (2, 2) in LTR direction.
When the body is in RTL direction, the offset counts the width
of left scroll bar's width. This function computes the actual
offset.
Returns an object of the form:
{ x: 100, y: 300, w: 20, h: 15 }
If includeScroll==true, the x and y values will include any
document offsets that may affect the position relative to the
viewport.
Uses the border-box model (inclusive of border and padding but
not margin). Does not act as a setter.
Returns an object that measures margin-box (w)idth/(h)eight
and absolute position x/y of the border-box. Also returned
is computed (l)eft and (t)op values in pixels from the
node's offsetParent as returned from marginBox().
Return value will be in the form:
{ l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
Does not act as a setter. If includeScroll is passed, the x and
y params are affected as one would expect in dojo.position().
id or reference to the element to remove the attribute from
the name of the attribute to remove
id or reference to the element to remove the attribute from
the name of the attribute
A DOM Element creation function. A shorthand method for creating a node or
a fragment, and allowing for a convenient optional attribute setting step,
as well as an optional DOM placement reference.
Attributes are set by passing the optional object through `dojo.attr`.
See `dojo.attr` for noted caveats and nuances, and API if applicable.
Placement is done via `dojo.place`, assuming the new node to be the action
node, passing along the optional reference node and position.
Create a DIV:
var n = dojo.create("div");
Create a DIV with content:
var n = dojo.create("div", { innerHTML:"<p>hi</p>" });
Place a new DIV in the BODY, with no attributes set
var n = dojo.create("div", null, dojo.body());
Create an UL, and populate it with LI's. Place the list as the first-child of a
node with id="someId":
var ul = dojo.create("ul", null, "someId", "first");
var items = ["one", "two", "three", "four"];
dojo.forEach(items, function(data){
dojo.create("li", { innerHTML: data }, ul);
});
Create an anchor, with an href. Place in BODY:
dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
Create a `dojo.NodeList()` from a new element (for syntatic sugar):
dojo.query(dojo.create('div'))
.addClass("newDiv")
.onclick(function(e){ console.log('clicked', e.target) })
.place("#someNode"); // redundant, but cleaner.
A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
or an existing DOM node to process.
An object-hash of attributes to set on the newly created node.
Can be null, if you don't want to set any attributes/styles.
See: <code>dojo.attr</code> for a description of available attributes.
Optional reference node. Used by <code>dojo.place</code> to place the newly created
node somewhere in the dom relative to refNode. Can be a DomNode reference
or String ID of a node.
Optional positional reference. Defaults to "last" by way of <code>dojo.place</code>,
though can be set to "first","after","before","last", "replace" or "only"
to further control the placement of the new node relative to the refNode.
'refNode' is required if a 'pos' is specified.
DomNode
Destroy node's children byId:
dojo.empty("someId");
Destroy all nodes' children in a list by reference:
dojo.query(".someNode").forEach(dojo.empty);
a reference to a DOM node or an id.
Create a table row:
var tr = dojo._toDom("<tr><td>First!</td></tr>");
the HTML fragment
optional document to use when creating DOM nodes, defaults to
dojo.doc if not specified.
DocumentFragment
Do something if a node with id="someNode" has class="aSillyClassName" present
if(dojo.hasClass("someNode","aSillyClassName")){ ... }
String ID or DomNode reference to check the class for.
A string class name to look for.
Add a class to some node:
dojo.addClass("someNode", "anewClass");
Add two classes at once:
dojo.addClass("someNode", "firstClass secondClass");
Add two classes at once (using array):
dojo.addClass("someNode", ["firstClass", "secondClass"]);
Available in `dojo.NodeList` for multiple additions
dojo.query("ul > li").addClass("firstLevel");
String ID or DomNode reference to add a class string too
A String class name to add, or several space-separated class names,
or an array of class names.
Remove a class from some node:
dojo.removeClass("someNode", "firstClass");
Remove two classes from some node:
dojo.removeClass("someNode", "firstClass secondClass");
Remove two classes from some node (using array):
dojo.removeClass("someNode", ["firstClass", "secondClass"]);
Remove all classes from some node:
dojo.removeClass("someNode");
Available in `dojo.NodeList()` for multiple removal
dojo.query(".foo").removeClass("foo");
String ID or DomNode reference to remove the class from.
An optional String class name to remove, or several space-separated
class names, or an array of class names. If omitted, all class names
will be deleted.
dojo.replaceClass("someNode", "add1 add2", "remove1 remove2");
Replace all classes with addMe
dojo.replaceClass("someNode", "addMe");
Available in `dojo.NodeList()` for multiple toggles
dojo.query(".findMe").replaceClass("addMe", "removeMe");
String ID or DomNode reference to remove the class from.
A String class name to add, or several space-separated class names,
or an array of class names.
A String class name to remove, or several space-separated class names,
or an array of class names.
dojo.toggleClass("someNode", "hovered");
Forcefully add a class
dojo.toggleClass("someNode", "hovered", true);
Available in `dojo.NodeList()` for multiple toggles
dojo.query(".toggleMe").toggleClass("toggleMe");
If passed, true means to add the class, false means to remove.
Throws for invalid JSON strings, but it does not use a strict JSON parser. It
delegates to eval(). The content passed to this method must therefore come
from a trusted source.
a string literal of a JSON item, for instance:
<code>'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'</code>
Returns a [JSON](http://json.org) serialization of an object.
Note that this doesn't check for infinite recursion, so don't do that!
simple serialization of a trivial object
var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
a custom serializer for an objects of a particular class:
dojo.declare("Furby", null, {
furbies: "are strange",
furbyCount: 10,
__json__: function(){
},
});
an object to be serialized. Objects may define their own
serialization via a special "__json__" or "json" function
property. If a specialized serializer has been defined, it will
be used as a fallback.
if true, we indent objects and arrays to make the output prettier.
The variable <code>dojo.toJsonIndentStr</code> is used as the indent string --
to use something other than the default (tab), change that variable
before calling dojo.toJson().
private variable for recursive calls when pretty printing, do not use.
Doesn't strongly test for "arrayness". Instead, settles for "isn't
a string or number and has a length property". Arguments objects
and DOM collections will return true when passed to
dojo.isArrayLike(), but will return false when passed to
dojo.isArray().
If it walks like a duck and quacks like a duck, return `true`
dojo.hitch(foo, "bar")();
runs foo.bar() in the scope of foo
dojo.hitch(foo, myFunction);
returns a function that runs myFunction in the scope of foo
Expansion on the default positional arguments passed along from
hitch. Passed args are mixed first, additional args after.
var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
var fn = dojo.hitch(foo, "bar", 1, 2);
fn(3); // logs "1, 2, 3"
var foo = { bar: 2 };
dojo.hitch(foo, function(){ this.bar = 10; })();
execute an anonymous function in scope of foo
The scope to use when method executes. If method is a string,
scope is also the object containing method.
A function to be hitched to scope, or the name of the method in
scope to be hitched.
This is a small implementaton of the Boodman/Crockford delegation
pattern in JavaScript. An intermediate object constructor mediates
the prototype chain for the returned object, using it to delegate
down to obj for property lookup when object-local lookup fails.
This can be thought of similarly to ES4's "wrap", save that it does
not act on types but rather on pure objects.
var foo = { bar: "baz" };
var thinger = dojo.delegate(foo, { thud: "xyzzy"});
thinger.bar == "baz"; // delegated to foo
foo.thud == undefined; // by definition
thinger.thud == "xyzzy"; // mixed in from props
foo.bar = "thonk";
thinger.bar == "thonk"; // still delegated to foo's bar
object to delegate to for properties not found directly on the
return object or in props.
object containing properties to assign to the returned object
an Object of anonymous type
the object to "arrayify". We expect the object to have, at a
minimum, a length property which corresponds to integer-indexed
properties.
the location in obj to start iterating from. Defaults to 0.
Optional.
An array to pack with the properties of obj. If provided,
properties in obj are appended at the end of startWith and
startWith is the returned array.
Calling dojo.partial is the functional equivalent of calling:
dojo.hitch(null, funcName, ...);
This version of trim() was selected for inclusion into the base due
to its compact size and relatively good performance
(see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
Uses String.prototype.trim instead, if available.
The fastest but longest version of this function is located at
dojo.string.trim()
String to be trimmed
String
Returns the trimmed string
// uses a dictionary for substitutions:
dojo.replace("Hello, {name.first} {name.last} AKA {nick}!",
{
nick: "Bob",
name: {
first: "Robert",
middle: "X",
last: "Cringely"
}
});
// returns: Hello, Robert Cringely AKA Bob!
// uses an array for substitutions:
dojo.replace("Hello, {0} {2}!",
["Robert", "X", "Cringely"]);
// returns: Hello, Robert Cringely!
// uses a function for substitutions:
function sum(a){
var t = 0;
dojo.forEach(a, function(x){ t += x; });
return t;
}
dojo.replace(
"{count} payments averaging {avg} USD per payment.",
dojo.hitch(
{ payments: [11, 16, 12] },
function(_, key){
switch(key){
case "count": return this.payments.length;
case "min": return Math.min.apply(Math, this.payments);
case "max": return Math.max.apply(Math, this.payments);
case "sum": return sum(this.payments);
case "avg": return sum(this.payments) / this.payments.length;
}
}
)
);
// prints: 3 payments averaging 13 USD per payment.
// uses an alternative PHP-like pattern for substitutions:
dojo.replace("Hello, ${0} ${2}!",
["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
// returns: Hello, Robert Cringely!
String to be used as a template.
If an object, it is used as a dictionary to look up substitutions.
If a function, it is called for every substitution with following
parameters: a whole match, a name, an offset, and the whole template
string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
for more details).
Optional regular expression objects that overrides the default pattern.
Must be global and match one item. The default is: /\{([^\}]+)\}/g,
which matches patterns like that: "{xxx}", where "xxx" is any sequence
of characters, which doesn't include "}".
String
Returns the substituted string.
Invoke callback with globalObject as dojo.global and
globalObject.document as dojo.doc. If provided, globalObject
will be executed in the context of object thisObject
When callback() returns or throws an error, the dojo.global
and dojo.doc will be restored to its previous state.
Invoke callback with documentObject as dojo.doc. If provided,
callback will be executed in the context of object thisObject
When callback() returns or throws an error, the dojo.doc will
be restored to its previous state.
Returns the value encoded in a form field as
as a string or an array of strings. Disabled form elements
and unchecked radio and checkboxes are skipped. Multi-select
elements are returned as an array of string values.
Returns the values encoded in an HTML form as
string properties in an object which it then returns. Disabled form
elements, buttons, and other non-value form elements are skipped.
Multi-select elements are returned as an array of string values.
This form:
<form id="test_form">
<input type="text" name="blah" value="blah">
<input type="text" name="no_value" value="blah" disabled>
<input type="button" name="no_value2" value="blah">
<select type="select" multiple name="multi" size="5">
<option value="blah">blah</option>
<option value="thud" selected>thud</option>
<option value="thonk" selected>thonk</option>
</select>
</form>
yields this object structure as the result of a call to
formToObject():
{
blah: "blah",
multi: [
"thud",
"thonk"
]
};
this object:
{
blah: "blah",
multi: [
"thud",
"thonk"
]
};
yields the following query string:
"blah=blah&multi=thud&multi=thonk"
This string:
"foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
results in this object structure:
{
foo: [ "bar", "baz" ],
thinger: " spaces =blah",
zonk: "blarg"
}
Note that spaces and other urlencoded entities are correctly
handled.
The args object passed into the public io call. Recognized properties on
the args object are:
The canceller function used for the Deferred object. The function
will receive one argument, the Deferred object that is related to the
canceller.
The first OK callback to be registered with Deferred. It has the opportunity
to transform the OK response. It will receive one argument -- the Deferred
object returned from this function.
The first error callback to be registered with Deferred. It has the opportunity
to do cleanup on an error. It will receive two arguments: error (the
Error object) and dfd, the Deferred object returned from this function.
Used by IO transports. An IO transport should
call this method before making the network connection.
The Deferred object to watch.
Function used to check if the IO request is still valid. Gets the dfd
object as its only argument.
Function used to check if basic IO call worked. Gets the dfd
object as its only argument.
Function used to process response. Gets the dfd
object as its only argument.
Sends an HTTP request with the given method.
See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
for those HTTP methods. There are also methods for "raw" PUT and POST methods
via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase.
If the request has an HTTP body, then pass true for hasBody.
Text to append to the message.
Text to indicate when in the future the behavior will be removed.
This can be used to mark a function, file, or module as
experimental. Experimental code is not ready to be used, and the
APIs are subject to change without notice. Experimental code may be
completed deleted without going through the normal deprecation
process.
dojo.experimental("dojo.data.Result");
dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
The name of a module, or the name of a module file or a specific
function
some additional message for the user
Handles getting and setting of location.hash.
- If no arguments are passed, acts as a getter.
- If a string is passed, acts as a setter.
the hash is set - #string.
If true, updates the hash value in the current history
state instead of creating a new history state.
when used as a getter, returns the current hash string.
when used as a setter, returns the new hash string.
An alias to the private dataCache for NodeList-data. NEVER USE THIS!
This private is only exposed for the benefit of unit testing, and is
removed during the build process.
Adds dojo.fx animation support to dojo.query()
Adds a chainable html method to dojo.query() / Nodelist instances for setting/replacing node content
Adds a chainable methods to dojo.query() / Nodelist instances for manipulating HTML
and DOM nodes and their properties.
Adds a chainable methods to dojo.query() / Nodelist instances for traversing the DOM
The root relative path to dojo.js (as a string)
Detect spidermonkey
D.O.H. Test files for Dojo unit testing.
Menu text
Class to apply to DOMNode to make it display an icon.
Text for the accelerator (shortcut) key combination.
Note that although Menu can display accelerator keys there
is no infrastructure to actually catch and execute these
accelerators.
If true, the menu item is disabled.
If false, the menu item is enabled.
srcNodeRefinnerHTML contains both the menu item text and a popup widget
The first part holds the menu item text and the second part is the popup
<div dojoType="dijit.PopupMenuItem">
<span>pick me</span>
<popup> ... </popup>
</div>
myProgressBar.update({'indeterminate': true});
myProgressBar.update({'progress': 80});
myProgressBar.update({'indeterminate': true, label:"Loading ..." })
May provide progress and/or maximum properties on this parameter;
see attribute specs for details.
(Percentage or Number)
Number or percentage indicating amount of task completed.
Deprecated. Use "value" instead.
(Percentage or Number)
Number or percentage indicating amount of task completed.
With "%": percentage value, 0% <= progress <= 100%, or
without "%": absolute value, 0 <= progress <= maximum.
Infinity means that the progress bar is indeterminate.
Max sample number
Number of places to show in values; 0 by default
If false: show progress value (number or percentage).
If true: show that a process is underway but that the amount completed is unknown.
Deprecated. Use "value" instead.
Label on progress bar. Defaults to percentage for determinate progress bar and
blank for indeterminate progress bar.
this is the field name (for a form) if set. This needs to be set if you want to use
this widget in a dijit.form.Form widget (such as dijit.Dialog)
URL to image to use for indeterminate progress bar when display is in high contrast mode
An accessible container with a title Heading, and a content
section that slides open and closed. TitlePane is an extension to
`dijit.layout.ContentPane`, providing all the useful content-control aspects from it.
True if you want to open the pane, false if you want to close it.
True to allow user to open/close pane by clicking title bar.
Title of the pane
Whether pane is opened or closed.
Whether pane can be opened or closed by clicking the title bar.
Tabindex setting for the title (so users can tab to the title then
use space/enter to open/close the title pane)
Time in milliseconds to fade in/fade out
The root className to be placed on this widget's domNode.
Milliseconds to fade in/fade out
|| String
|| String
Text to display in the tooltip.
Specified as innerHTML when creating the widget from markup.
Number of milliseconds to wait after hovering over/focusing on the object, before
the tooltip is displayed.
Id of domNode(s) to attach the tooltip to.
When user hovers over specified dom node, the tooltip will appear.
See description of <code>dijit.Tooltip.defaultPosition</code> for details on position parameter.
Keep keyboard focus in dialog; close dialog on escape key
Description of tooltip dialog (required for a11y)
Don't change this parameter from the default value.
This ContentPane parameter doesn't make sense for TooltipDialog, since TooltipDialog
is never a child of a layout container, nor can you specify the size of
TooltipDialog in order to control the size of an inner widget.
A Toggle to modify the default focus behavior of a Dialog, which
is to focus on the first dialog element after opening the dialog.
False will disable autofocusing. Default: true
The root className to use for the various states of this widget
DomNode
The pointer to the first focusable node in the dialog.
Set by <code>dijit._DialogMixin._getFocusItems</code>.
DomNode
The pointer to which node has focus prior to our dialog.
Set by <code>dijit._DialogMixin._getFocusItems</code>.
0 for top level nodes, 1 for their children, 2 for their
grandchildren, etc.
data item.
lower case attribute to use, e.g. 'icon', 'label' or 'row'.
upper case attribute to use, e.g. 'Icon', 'Label' or 'Row'.
Deferred that fires when expansion is complete
Deferred object that fires after all previously opened children
have been expanded again (or fires instantly if there are no such children).
In particular, setting a node as selected involves setting tabIndex
so that when user tabs to the tree, focus will go to that node (only).
In particular, setting a node as selected involves setting tabIndex
so that when user tabs to the tree, focus will go to that node (only).
the dojo.data entry this tree represents
Indicates that this is a TreeNode. Used by <code>dijit.Tree</code> only,
should not be accessed directly.
Text of this tree node
This node has children, so show the expando node (+ sign)
This node is currently expanded (ie, opened)
Dynamic loading-related stuff.
When an empty folder node appears, it is "UNCHECKED" first,
then after dojo.data query it becomes "LOADING" and, finally "LOADED"
Levels from this node to the root node
For each node in nodes[], which came from source, create a hash of name/value
pairs to be passed to Tree.model.newItem(). Returns array of those hashes.
The DOMNodes dragged from the source container
The target TreeNode.rowNode
The source container the nodes were dragged from, perhaps another Tree or a plain dojo.dnd.Source
Object[]
Array of name/value hashes for each new item to be added to the Tree, like:
[
{ id: 123, label: "apple", foo: "bar" },
{ id: 456, label: "pear", zaz: "bam" }
]
The source which provides items
Array of DOM nodes corresponding to nodes being dropped, dijitTreeRow nodes if
source is a dijit.Tree.
In the base case, this is called to check if target can become a child of source.
When betweenThreshold is set, position="before" or "after" means that we
are asking if the source node can be dropped before/after the target node.
The dijitTreeRoot DOM node inside of the TreeNode that we are dropping on to
Use dijit.getEnclosingWidget(target) to get the TreeNode.
The (set of) nodes we are dropping
"over", "before", or "after"
If persist == true the loading may encompass many levels of fetches
from the data store, each asynchronous. Waits for all to finish.
or id
Array of tree nodes that refer to passed item
or id
or ids
|| String[]
Array of arrays of items or item id's
Deferred to indicate when the set is complete
Object suitable for input to dojo.style() like {backgroundImage: "url(...)"}
Object suitable for input to dojo.style() like {color: "red", background: "green"}
Object suitable for input to dojo.style() like {background-color: "#bbb"}
Like { node: TreeNode, key: 'a' } where key is the key the user pressed.
Internal flag used when _expandNode() calls itself, don't set.
Deferred that fires when the node is loaded and opened and (if persist=true) all it's descendants
that were previously opened too
It marks that the current node is the selected one, and the previously
selected node no longer is.
Developers can override this method to define their own TreeNode class;
However it will probably be removed in a future release in favor of a way
of just specifying a widget for the label, rather than one that contains
the children too.
Deprecated. Use "model" parameter instead.
The store to get data to display in the tree.
Interface to read tree data, get notifications of changes to tree data,
and for handling drop operations (i.e drag and drop onto the tree)
Deprecated. User should specify query to the model directly instead.
Specifies datastore query to return the root item or top items for the tree.
Deprecated. Use dijit.tree.ForestStoreModel directly instead.
Used in conjunction with query parameter.
If a query is specified (rather than a root node id), and a label is also specified,
then a fake root node is created and displayed, with this label.
Should the root node be displayed, or hidden?
Deprecated. This information should be specified in the model.
One ore more attributes that holds children of a tree node
or Item[][]
Full paths from rootNode to selected nodes expressed as array of items or array of ids.
Since setting the paths may be asynchronous (because ofwaiting on dojo.data), set("paths", ...)
returns a Deferred to indicate when the set is complete.
or Item[]
Backward compatible singular variant of paths.
The currently selected items in this tree.
This property can only be set (via set('selectedItems', ...)) when that item is already
visible in the tree. (I.e. the tree has already been expanded to show that node.)
Should generally use <code>paths</code> attribute to set the selected items instead.
Backward compatible singular variant of selectedItems.
If true, clicking a folder node's label will open it, rather than calling onClick()
If true, double-clicking a folder node's label will open it, rather than calling onDblClick()
Enables/disables use of cookies for state saving.
Fully expand the tree on load. Overrides <code>persist</code>.
Class name to use as as the dnd controller. Specifying this class enables DnD.
Generally you should specify this as "dijit.tree.dndSource".
Default of "dijit.tree._dndSelector" handles selection only (no actual DnD).
Number of pixels mouse moves before it's considered the start of a drag operation
Set to a positive value to allow drag and drop "between" nodes.
If during DnD mouse is over a (target) node but less than betweenThreshold
pixels from the bottom edge, dropping the the dragged node will make it
the next sibling of the target node, rather than the child.
Similarly, if mouse is over a target node but less that betweenThreshold
pixels from the top edge, dropping the dragged node will make it
the target node's previous sibling rather than the target node's child.
Number of pixels to indent tree nodes (relative to parent node).
Default is 19 but can be overridden by setting CSS class dijitTreeIndent
and calling resize() or startup() on tree after it's in the DOM.
If multiple characters are typed where each keystroke happens within
multiCharSearchDuration of the previous keystroke,
search for nodes matching all the keystrokes.
For example, typing "ab" will search for entries starting with
"ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
Either "next" or "previous"
Use this mixin for widgets that needs to know about and
keep track of their widget children. Suitable for widgets like BorderContainer
and TabContainer which contain (only) a set of child widgets.
It's not suitable for widgets like ContentPane
which contains mixed HTML (plain DOM nodes in addition to widgets),
and where contained widgets are not necessarily directly below
this.containerNode. In that case calls like addChild(node, position)
wouldn't make sense.
Inserts specified child widget's dom node as a child of this widget's
container node, and possibly does other processing (such as layout).
or int
if 1, get the next sibling
if -1, get the previous sibling
Indicates that this widget acts as a "parent" to the descendant widgets.
When the parent is started it will call startup() on the child widgets.
See also <code>isLayoutContainer</code>.
By mixing this class into your widget, and setting the this.baseClass attribute, it will automatically
maintain CSS classes on the widget root node (this.domNode) depending on hover,
active, focus, etc. state. Ex: with a baseClass of dijitButton, it will apply the classes
dijitButtonHovered and dijitButtonActive, as the user moves the mouse over the widget and clicks it.
It also sets CSS like dijitButtonDisabled based on widget semantic state.
By setting the cssStateNodes attribute, a widget can also track events on subnodes (like buttons
within the widget).
In the case where a widget has multiple
states, it sets the class based on all possible
combinations. For example, an invalid form widget that is being hovered
will be "dijitInput dijitInputInvalid dijitInputHover dijitInputInvalidHover".
The widget may have one or more of the following states, determined
by this.state, this.checked, this.valid, and this.selected:
- Error - ValidationTextBox sets this.state to "Error" if the current input value is invalid
- Incomplete - ValidationTextBox sets this.state to "Incomplete" if the current input value is not finished yet
- Checked - ex: a checkmark or a ToggleButton in a checked state, will have this.checked==true
- Selected - ex: currently selected tab will have this.selected==true
In addition, it may have one or more of the following states,
based on this.disabled and flags set in _onMouse (this.active, this.hovering) and from focus manager (this.focused):
- Disabled - if the widget is disabled
- Active - if the mouse (or space/enter key?) is being pressed down
- Focused - if the widget has focus
- Hover - if the mouse is over the widget
Given class=foo, will set the following CSS class on the node
- fooActive: if the user is currently pressing down the mouse button while over the node
- fooHover: if the user is hovering the mouse over the node, but not pressing down a button
- fooFocus: if the node is focused
Note that it won't set any classes if the widget is disabled.
Should be a sub-node of the widget, not the top node (this.domNode), since the top node
is handled specially and automatically just by mixing in this class.
CSS class name (ex: dijitSliderUpArrow).
List of sub-nodes within the widget that need CSS classes applied on mouse hover/press and focus
.
Each entry in the hash is a an attachpoint names (like "upArrowButton") mapped to a CSS class names
(like "dijitUpArrowButton"). Example:
{
"upArrowButton": "dijitUpArrowButton",
"downArrowButton": "dijitDownArrowButton"
}
The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
is hovered, etc.
True if cursor is over this widget
True if mouse was pressed while over this widget, and hasn't been released yet
After the user has pressed the submit button, the Dialog
first calls onExecute() to notify the container to hide the
dialog and restore focus to wherever it used to be.
*Then* this method is called.
type:
callback
Developer shouldn't override or connect to this method;
it's a private communication device between the TooltipDialog
and the thing that opened it (ex: `dijit.form.DropDownButton`)
type:
protected
Developer shouldn't override or connect to this method;
it's a private communication device between the TooltipDialog
and the thing that opened it (ex: `dijit.form.DropDownButton`)
type:
protected
return value of dijit.popup.open()
If true, refocuses the button widget
The button/icon/node to click to display the drop down.
Can be set via a dojoAttachPoint assignment.
If missing, then either focusNode or domNode (if focusNode is also missing) will be used.
Will set CSS class dijitUpArrow, dijitDownArrow, dijitRightArrow etc. on this node depending
on where the drop down is set to be positioned.
Can be set via a dojoAttachPoint assignment.
If missing, then _buttonNode will be used.
The node to set the popupActive class on.
Can be set via a dojoAttachPoint assignment.
If missing, then focusNode or _buttonNode (if focusNode is missing) will be used.
The node to display the popup around.
Can be set via a dojoAttachPoint assignment.
If missing, then domNode will be used.
Set to true to make the drop down at least as wide as this
widget. Set to false if the drop down should just be its
default width
Set to true to make the drop down exactly as wide as this
widget. Overrides autoWidth.
The max height for our dropdown.
Any dropdown taller than this will have scrollbars.
Set to 0 for no max height, or -1 to limit height to available space in viewport
When set to false, the click events will not be stopped, in
case you want to use them in your subwidget
To use this mixin, call connectKeyNavHandlers() in
postCreate() and call startupKeyNavChildren() in startup().
It provides normalized keyboard and focusing code for Container
widgets.
Key codes for navigating to the next child.
Reference to container's child widget
If true and if widget has multiple focusable nodes, focus the
last one instead of the first one
Sets tabIndex=-1 on each child, so that the tab key will
leave the container rather than visiting each child.
Initially the container itself has a tabIndex, but when it gets
focus, switch focus to first child...
The current widget
* 1 = after
* -1 = before
The currently focused child widget, or null if there isn't one
Tab index of the container; same as HTML tabIndex attribute.
Note then when user tabs into the container, focus is immediately
moved to the first item in the container.
A mixin for a grid showing various entities, so the user can pick a certain entity.
id's for each cell of the palette, used to create Dye JS object for each cell
Localized tooltip for each cell
The event.
At any point in time there's exactly one
cell with tabIndex != -1. If focus is inside the palette then
focus is on that cell.
After calling this method, arrow key handlers and mouse click handlers
should focus the cell in a setTimeout().
value of the cell to select
parameter used to tell the select whether or not to fire
onChange event.
Value corresponding to cell.
much the key is navigated.
many times typematic has fired.
Number of milliseconds before a held key or button becomes typematic
Fraction of time used to change the typematic timer between events
1.0 means that each typematic event fires at defaultTimeout intervals
< 1.0 means that each typematic event fires at an increasing faster rate
Currently selected color/emoticon/etc.
Index of the currently selected cell. Initially, none selected
The currently focused cell (if the palette itself has focus), or otherwise
the cell to be focused when the palette itself gets focus.
Different from value, which represents the selected (i.e. clicked) cell.
This is the number of cells horizontally across.
This is the number of cells vertically down.
Widget tab index.
CSS class applied to each cell in the palette
Name of javascript class for Object created for each cell of the palette.
dyeClass should implements dijit.Dye interface
For example color hex value, emoticon ascii value etc, entity hex value.
The surrounding cell
URL for blank cell image
Event
Event
Event
Event
Event
Event
Event
Event
Event
Event
Event
Event
This method is deprecated, use get() or set() directly.
The property to get or set. If an object is passed here and not
a string, its keys are used as names of attributes to be set
and the value of the object as values to set in the widget.
Optional. If provided, attr() operates as a setter. If omitted,
the current value of the named property is returned.
Provide widget-specific analog to dojo.connect, except with the
implicit use of this widget as the target object.
This version of connect also provides a special "ondijitclick"
event which triggers on a click or space or enter keyup.
Events connected with `this.connect` are disconnected upon
destruction.
var btn = new dijit.form.Button();
// when foo.bar() is called, call the listener we're going to
// provide in the scope of btn
btn.connect(foo, "bar", function(){
console.debug(this.toString());
});
A handle that can be passed to `disconnect` in order to disconnect before
the widget is destroyed.
This widget or a widget it contains has focus, or is "active" because
it was recently clicked.
List of nodes that correctly handle click events via native browser support,
and don't need dijit's help
Parameter for children of <code>dijit.layout.BorderContainer</code>.
Values: "top", "bottom", "leading", "trailing", "left", "right", "center".
See the <code>dijit.layout.BorderContainer</code> description for details.
Parameter for children of <code>dijit.layout.BorderContainer</code>.
Children with a higher layoutPriority will be placed closer to the BorderContainer center,
between children with a lower layoutPriority.
Parameter for child of <code>dijit.layout.BorderContainer</code> where region != "center".
If true, enables user to resize the widget by putting a draggable splitter between
this widget and the region=center widget.
Parameter for children of <code>dijit.layout.BorderContainer</code>.
Specifies a minimum size (in pixels) for this widget when resized by a splitter.
Parameter for children of <code>dijit.layout.BorderContainer</code>.
Specifies a maximum size (in pixels) for this widget when resized by a splitter.
"none", "left", "right", "bottom", "top", and "client".
See the LayoutContainer description for details on this parameter.
Deprecated. Parameter for children of <code>dijit.layout.SplitContainer</code>.
Minimum size (width or height) of a child of a SplitContainer.
The value is relative to other children's sizeShare properties.
Deprecated. Parameter for children of <code>dijit.layout.SplitContainer</code>.
Size (width or height) of a child of a SplitContainer.
The value is relative to other children's sizeShare properties.
For example, if there are two children and each has sizeShare=10, then
each takes up 50% of the available space.
Parameter for children of <code>dijit.layout.StackContainer</code> or subclasses.
Specifies that this widget should be the initially displayed pane.
Note: to change the selected child use <code>dijit.layout.StackContainer.selectChild</code>
Parameter for children of <code>dijit.layout.StackContainer</code> or subclasses.
True if user can close (destroy) this child, such as (for example) clicking the X on the tab.
Parameter for children of <code>dijit.layout.StackContainer</code> or subclasses.
CSS Class specifying icon to use in label associated with this pane.
Parameter for children of <code>dijit.layout.StackContainer</code> or subclasses.
When true, display title of this widget as tab label etc., rather than just using
icon specified in iconClass
Column of the grid to place the widget.
Defined only if dojo.require("dojox.layout.GridContainerLite") is done.
If true, the widget can not be draggable.
Defined only if dojo.require("dojox.layout.GridContainerLite") is done.
A parameter needed by RadioGroupSlide only. An optional paramter to force
the ContentPane to slide in from a set direction. Defaults
to "random", or specify one of "top", "left", "right", "bottom"
to slideFrom top, left, right, or bottom.
The label to display for a given widget
The label to display for a given widget. This is interchangeable
with the 'label' parameter, as some widgets already have a use
for the 'label', and this can be used instead to avoid conflicts.
Setting spanLabel to true makes the widget take up both the
label and value cells. Defaults to false.
The number of columns this widget should span.
a css size value (e.g. "100px")
Defines a type of widget.
Map widget properties and functions to the handlers specified in
the dom node and it's descendants. This function iterates over all
nodes and looks for these properties:
* dojoAttachPoint
* dojoAttachEvent
* waiRole
* waiState
the node to search for properties. All children will be searched.
a function which will be used to obtain property for a given
DomNode/Widget
The URL to get the template from.
a string to use in lieu of fetching the template from a URL. Takes precedence
over templatePath
Mixed
Either string (if there are ${} variables that need to be replaced) or just
a DOM tree (if the node can be cloned directly)
A string that represents the widget template. Pre-empts the
templatePath. In builds that have their strings "interned", the
templatePath is converted to an inline templateString, thereby
preventing a synchronous network call.
Use in conjunction with dojo.cache() to load from a file.
Path to template (HTML file) for this widget relative to dojo.baseUrl.
Deprecated: use templateString with dojo.cache() instead.
Should we parse the template to find widgets that might be
declared in markup inside it? False by default.
A fallback to preserve the 1.0 - 1.3 behavior of children in
templates having their startup called before the parent widget
fires postCreate. Defaults to 'false', causing child widgets to
have their .startup() called immediately before a parent widget
.startup(), but always after the parent .postCreate(). Set to
'true' to re-enable to previous, arguably broken, behavior.
List of widget attribute names associated with dojoAttachPoint=... in the
template, ex: ["containerNode", "labelNode"]
List of connections associated with dojoAttachEvent=... in the
template
The current value
Set the value of the TimePicker.
Redraws the TimePicker around the new date.
Removes the bottom time and add one to the top
Remove the top time and add one to the bottom
The root className to use for the various states of this widget
ISO-8601 string representing the amount by which
every clickable element in the time picker increases.
Set in local time, without a time zone.
Example: <code>T00:15:00</code> creates 15 minute increments
Must divide dijit._TimePicker.visibleIncrement evenly
ISO-8601 string representing the amount by which
every element with a visible time in the time picker increases.
Set in local time, without a time zone.
Example: <code>T01:00:00</code> creates text in every 1 hour increment
ISO-8601 string representing the range of this TimePicker.
The TimePicker will only display times in this range.
Example: <code>T05:00:00</code> displays 5 hours of options
Date to display.
Defaults to current time and date.
Can be a Date object or an ISO-8601 string.
If you specify the GMT time zone (<code>-01:00</code>),
the time will be converted to the local time in the local time zone.
Otherwise, the time is considered to be in the local time zone.
If you specify the date and isDate is true, the date is used.
Example: if your local time zone is <code>GMT -05:00</code>,
<code>T10:00:00</code> becomes <code>T10:00:00-05:00</code> (considered to be local time),
<code>T10:00:00-01:00</code> becomes <code>T06:00:00-05:00</code> (4 hour difference),
<code>T10:00:00Z</code> becomes <code>T05:00:00-05:00</code> (5 hour difference between Zulu and local time)
<code>yyyy-mm-ddThh:mm:ss</code> is the format to set the date and time
Example: <code>2007-06-01T09:00:00</code>
Specifies valid range of times (start time, end time)
The string to filter by
See <code>dijit._TimePicker.clickableIncrement</code>
See <code>dijit._TimePicker.visibleIncrement</code>
See <code>dijit._TimePicker.visibleRange</code>
Create calls a number of widget methods (postMixInProperties, buildRendering, postCreate,
etc.), some of which of you'll want to override. See http://docs.dojocampus.org/dijit/_Widget
for a discussion of the widget creation lifecycle.
Of course, adventurous developers could override create entirely, but this should
only be done as a last resort.
Hash of initialization parameters for widget, including
scalar values (like title, duration etc.) and functions,
typically callbacks like onClick.
If a srcNodeRef (DOM node) is specified:
- use srcNodeRef.innerHTML as my contents
- if this is a behavioral widget then apply behavior
to that srcNodeRef
- otherwise, replace srcNodeRef with my generated DOM
tree
Skips over blank/false attribute values, unless they were explicitly specified
as parameters to the widget, since those are the default anyway,
and setting tabIndex="" is different than not setting tabIndex at all.
It processes the attributes in the attribute map first, and then
it goes through and processes the attributes for the _setXXXAttr
functions that have been specified
Most widgets will mixin `dijit._Templated`, which implements this
method.
Called after the DOM fragment has been created, but not necessarily
added to the document. Do not include any operations which rely on
node dimensions or placement.
Called after a widget and its children have been created and added to the page,
and all related widgets have finished their create() cycle, up through postCreate().
This is useful for composite widgets that need to control or layout sub-widgets.
Many layout widgets can use this as a wiring phase.
This is the generic "destructor" function that all widget users
should call to cleanly discard with a widget. Once a widget is
destroyed, it is removed from the manager object.
If true, this method will leave the original DOM structure
alone of descendant Widgets. Note: This will NOT work with
dijit._Templated widgets.
If true, this method will leave the original DOM structure alone.
Note: This will not yet work with _Templated widgets
If true, this method will leave the original DOM structure alone
during tear-down. Note: this will not work with _Templated
widgets yet.
If true, the preserveDom attribute is passed to all descendant
widget's .destroy() method. Not for use with _Templated
widgets.
Determines which node to set the style on based on style setting
in attributeMap.
Get a named property from a widget. The property may
potentially be retrieved via a getter method. If no getter is defined, this
just retrieves the object's property.
For example, if the widget has a properties "foo"
and "bar" and a method named "_getFooAttr", calling:
myWidget.get("foo");
would be equivalent to writing:
widget._getFooAttr();
and:
myWidget.get("bar");
would be equivalent to writing:
widget.bar;
property to get.
Sets named properties on a widget which may potentially be handled by a
setter in the widget.
For example, if the widget has a properties "foo"
and "bar" and a method named "_setFooAttr", calling:
myWidget.set("foo", "Howdy!");
would be equivalent to writing:
widget._setFooAttr("Howdy!");
and:
myWidget.set("bar", 3);
would be equivalent to writing:
widget.bar = 3;
set() may also be called with a hash of name/value pairs, ex:
myWidget.set({
foo: "Howdy",
bar: 3
})
This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
property to set.
value to set in the property.
When a widget is cast to a string, this method will be used to generate the
output. Currently, it does not implement any sort of reversible
serialization.
Provide widget-specific analog to dojo.connect, except with the
implicit use of this widget as the target object.
Events connected with `this.connect` are disconnected upon
destruction.
var btn = new dijit.form.Button();
// when foo.bar() is called, call the listener we're going to
// provide in the scope of btn
btn.connect(foo, "bar", function(){
console.debug(this.toString());
});
A handle that can be passed to `disconnect` in order to disconnect before
the widget is destroyed.
Provide widget-specific analog to dojo.subscribe, except with the
implicit use of this widget as the target object.
var btn = new dijit.form.Button();
// when /my/topic is published, this button changes its label to
// be the parameter of the topic.
btn.subscribe("/my/topic", function(v){
this.set("label", v);
});
A convenience function provided in all _Widgets, providing a simple
shorthand mechanism to put an existing (or newly created) Widget
somewhere in the dom, and allow chaining.
// create a Button with no srcNodeRef, and place it in the body:
var button = new dijit.form.Button({ label:"click" }).placeAt(dojo.body());
// now, 'button' is still the widget reference to the newly created button
dojo.connect(button, "onClick", function(e){ console.log('click'); });
// create a button out of a node with id="src" and append it to id="wrapper":
var button = new dijit.form.Button({},"src").placeAt("wrapper");
// place a new button as the first element of some div
var button = new dijit.form.Button({ label:"click" }).placeAt("wrapper","first");
// create a contentpane and add it to a TabContainer
var tc = dijit.byId("myTabs");
new dijit.layout.ContentPane({ href:"foo.html", title:"Wow!" }).placeAt(tc)
The String id of a domNode, a domNode reference, or a reference to a Widget posessing
an addChild method.
If passed a string or domNode reference, the position argument
accepts a string just as dojo.place does, one of: "first", "last",
"before", or "after".
If passed a _Widget reference, and that widget reference has an ".addChild" method,
it will be called passing this widget instance into that method, supplying the optional
position index passed.
dijit._Widget
Provides a useful return of the newly created dijit._Widget instance so you
can "chain" this function by instantiating, placing, then saving the return value
to a variable.
A unique, opaque ID string that can be assigned by users or by the
system. If the developer passes an ID which is known not to be
unique, the specified ID is ignored and the system-generated ID is
used instead.
Rarely used. Overrides the default Dojo locale used to render this widget,
as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
Value must be among the list of locales specified during by the Dojo bootstrap,
formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).
Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
attribute. Either left-to-right "ltr" or right-to-left "rtl". If undefined, widgets renders in page's
default direction.
HTML class attribute
HTML style attributes as cssText string or name/value hash
HTML title attribute.
For form widgets this specifies a tooltip to display when hovering over
the widget (just like the native HTML title attribute).
For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
etc., it's used to specify the tab label, accordion pane title, etc.
When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
this specifies the tooltip to appear when the mouse is hovered over that text.
Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
widget state.
pointer to original DOM node
This is our visible representation of the widget! Other DOM
Nodes may by assigned to other properties, usually through the
template system's dojoAttachPoint syntax, but the domNode
property is the canonical "top level" node in widget UI.
Designates where children of the source DOM node will be placed.
"Children" in this case refers to both DOM nodes and widgets.
For example, for myWidget:
<div dojoType=myWidget>
<b> here's a plain DOM node
<span dojoType=subWidget>and a widget</span>
<i> and another plain DOM node </i>
</div>
containerNode would point to:
<b> here's a plain DOM node
<span dojoType=subWidget>and a widget</span>
<i> and another plain DOM node </i>
In templated widgets, "containerNode" is set via a
dojoAttachPoint assignment.
containerNode must be defined for any widget that accepts innerHTML
(like ContentPane or BorderContainer or even Button), and conversely
is null for widgets that don't, like TextBox.
startup() has completed.
Path to a blank 1x1 image.
Used by <img> nodes in templates that really get their image via CSS background-image.
Any dijit._Widget subclass.
Using the default `dijit.registry` instance:
dijit.registry.forEach(function(widget){
console.log(widget.declaredClass);
});
A callback function to run for each item. Is passed the widget, the index
in the iteration, and the full hash, similar to <code>dojo.forEach</code>.
An optional scope parameter
Returns self, in order to allow for further chaining.
Arbitrary: select the odd widgets in this list
dijit.registry.filter(function(w, i){
return i % 2 == 0;
}).forEach(function(w){ /* odd ones */ });
Callback function to test truthiness. Is passed the widget
reference and the pseudo-index in the object.
Option scope to use for the filter function.
Test if an id is in a particular WidgetSet
var ws = new dijit.WidgetSet();
ws.add(dijit.byId("bar"));
var t = ws.byId("bar") // returns a widget
var x = ws.byId("foo"); // returns undefined
Find all `dijit.TitlePane`s in a page:
dijit.registry.byClass("dijit.TitlePane").forEach(function(tp){ tp.close(); });
The Class to scan for. Full dot-notated string.
Work with the widget .domNodes in a real Array
dojo.map(dijit.registry.toArray(), function(w){ return w.domNode; });
var nodes = dijit.registry.map(function(w){ return w.domNode; });
A new array of the returned values.
A callback function run for every widget in this list. Exits loop
when the first false return is encountered.
Optional scope parameter to use for the callback
A callback function run for every widget in this list. Exits loop
when the first true return is encountered.
Optional scope parameter to use for the callback
Is an instance of `dijit.WidgetSet`
vertical coordinate in pixels, relative to document body
horizontal offset in pixels, relative to document body
vertical offset in pixels, relative to document body
width in pixels
height in pixels
new dijit.BackgroundIframe(node)
Makes a background iframe as a child of node, that fills
area (and position) of node
|| DomNode
|| DomNode
Stack of currently popped up widgets.
(someone opened _stack[0], and then it opened _stack[1], etc.)
Z-index of the first popup. (If first popup opens other
popups they get a higher z-index.)
widget to display
the button etc. that is displaying this popup
DOM node (typically a button); place popup relative to this node. (Specify this *or* "x" and "y" parameters.)
Absolute horizontal position (in pixels) to place node at. (Specify this *or* "around" parameter.)
Absolute vertical position (in pixels) to place node at. (Specify this *or* "around" parameter.)
When the around parameter is specified, orient should be an
ordered list of tuples of the form (around-node-corner, popup-node-corner).
dijit.popup.open() tries to position the popup according to each tuple in the list, in order,
until the popup appears fully within the viewport.
The default value is {BL:'TL', TL:'BL'}, which represents a list of two tuples:
1. (BL, TL)
2. (TL, BL)
where BL means "bottom left" and "TL" means "top left".
So by default, it first tries putting the popup below the around node, left-aligning them,
and then tries to put it above the around node, still left-aligning them. Note that the
default is horizontally reversed when in RTL mode.
When an (x,y) position is specified rather than an around node, orient is either
"R" or "L". R (for right) means that it tries to put the popup to the right of the mouse,
specifically positioning the popup's top-right corner at the mouse position, and if that doesn't
fit in the viewport, then it tries, in order, the bottom-right corner, the top left corner,
and the top-right corner.
adding a buffer around the opening position. This is only useful when around is not set.
an object defining the key to listen for:
charOrCode:
the printable character (string) or keyCode (number) to listen for.
keyCode:
(deprecated - use charOrCode) the keyCode (number) to listen for (implies charCode = 0).
charCode:
(deprecated - use charOrCode) the charCode (number) to listen for.
ctrlKey:
desired ctrl key state to initiate the callback sequence:
- pressed (true)
- released (false)
- either (unspecified)
altKey:
same as ctrlKey but for the alt key
shiftKey:
same as ctrlKey but for the shift key
an array of dojo.connect handles
an array of dojo.connect handles
the DOM node object to listen on for mouse events.
the DOM node object to listen on for key events.
an array of dojo.connect handles
dijit._editor.RichText is the core of dijit.Editor, which provides basic
WYSIWYG editing features. It also encapsulates the differences
of different js engines for various browsers. Do not use this widget
with an HTML <TEXTAREA> tag, since the browser unescapes XML escape characters,
like <. This can have unexpected behavior and lead to security issues
such as scripting attacks.
dijit._editor.RichText is the core of dijit.Editor, which provides basic
WYSIWYG editing features. It also encapsulates the differences
of different js engines for various browsers. Do not use this widget
with an HTML <TEXTAREA> tag, since the browser unescapes XML escape characters,
like <. This can have unexpected behavior and lead to security issues
such as scripting attacks.
Overwrite this to setup your own handlers. The default
implementation does not use Editor commands, but directly
executes the builtin commands within the underlying browser
support.
Sets up the editing area asynchronously. This will result in
the creation and replacement with an iframe.
A dojo.uri.Uri pointing to the url of the external css file
Editor contents should be set to this value
The key argument should be in lowercase if it is a letter character
If you don't want to have update too often,
onNormalizedDisplayChanged should be used instead
If something needs to happen immediately after a
user change, please use onDisplayChanged instead.
The command to test for
The command to execute
optional argument to the command
defaults to false. Should the post-filtering be run over a copy
of the live DOM? Most users should pass "true" here unless they
*really* know that none of the installed filters are going to
mess up the editing session.
post-filtering allows plug-ins and users to specify any number
of transforms over the editor's content, enabling many common
use-cases such as transforming absolute to relative URLs (and
vice-versa), ensuring conformance with a particular DTD, etc.
The filters are registered in the contentDomPostFilters and
contentPostFilters arrays. Each item in the
contentDomPostFilters array is a function which takes a DOM
Node or array of nodes as its only argument and returns the
same. It is then passed down the chain for further filtering.
The contentPostFilters array behaves the same way, except each
member operates on strings. Together, the DOM and string-based
filtering allow the full range of post-processing that should
be necessaray to enable even the most agressive of post-editing
conversions to take place.
If nonDestructive is set to "true", the nodes are cloned before
filtering proceeds to avoid potentially destructive transforms
to the content which may still needed to be edited further.
Once DOM filtering has taken place, the serialized version of
the DOM which is passed is run through each of the
contentPostFilters functions.
a node, set of nodes, which to filter using each of the current
members of the contentDomPostFilters and contentPostFilters arrays.
defaults to "false". If true, ensures that filtering happens on
a clone of the passed-in content and not the actual node
itself.
Whether or not to save the changes. If false, the changes are discarded.
Moz can not handle strong/em tags correctly, so to help
mozilla and also to normalize output, convert them to 'b' and 'i'.
Note the IE generates 'strong' and 'em' rather than 'b' and 'i'
to the exec command, if any.
to the exec command, if any.
to the exec command, if any.
to the exec command, if any.
to the exec command, if any.
content to insert, if any.
used, operates by selection.
used, operates by selection.
used, operates by selection.
used, operates by selection.
node to process the children of;
node to check.
node to remove from the starting range.
range to adapt.
whether to inherit the parent's width or simply use 100%
Focus into this widget when the page is loaded
Specifies the name of a (hidden) <textarea> node on the page that's used to save
the editor content on page leave. Used to restore editor contents after navigating
to a new page and then hitting the back button.
semicolon (";") separated list of css files for the editing area
Set height to fix the editor at a specific height, with scrolling.
By default, this is 300px. If you want to have the editor always
resizes to accommodate the content, use AlwaysShowToolbar plugin
and set height="". If this editor is used within a layout widget,
set height="100%".
The minimum height that the editor should have.
Used to concat contents from multiple editors into a single string,
so they can be saved into a single <textarea> node. See "name" attribute.
USed to separate name from content. Just a colon isn't safe.
Deferred which is fired when the editor finishes loading.
Call myEditor.onLoadDeferred.then(callback) it to be informed
when the rich-text area initialization is finalized.
Make tab key and shift-tab indent and outdent rather than navigating.
Caution: sing this makes web pages inaccessible to users unable to use a mouse.
When true, disables the browser's native spell checking, if supported.
Works only in Firefox.
Pre content filter function register array.
these filters will be executed before the actual
editing area gets the html content.
events which should be connected to the underlying editing area
onClick handled specially
Events which should be connected to the underlying editing
area, events in this array will be addListener with
capture=true.
TODO: looking at the code I don't see any distinction between events and captureEvents,
so get rid of this for 2.0 if not sooner
The editor is disabled; the text cannot be changed.
Specify this in extraPlugins (or plugins) parameter and also set
height to "".
Enables/disables the handler for scroll events
Height in px of the editor at the last time we did sizing
This plugin has three modes:
* blockModeForEnter=BR
* blockModeForEnter=DIV
* blockModeForEnter=P
In blockModeForEnter=P, the ENTER key starts a new
paragraph, and shift-ENTER starts a new line in the current paragraph.
For example, the input:
first paragraph <shift-ENTER>
second line of first paragraph <ENTER>
second paragraph
will generate:
<p>
first paragraph
<br/>
second line of first paragraph
</p>
<p>
second paragraph
</p>
In BR and DIV mode, the ENTER key conceptually goes to a new line in the
current paragraph, and users conceptually create a new paragraph by pressing ENTER twice.
For example, if the user enters text into an editor like this:
one <ENTER>
two <ENTER>
three <ENTER>
<ENTER>
four <ENTER>
five <ENTER>
six <ENTER>
It will appear on the screen as two 'paragraphs' of three lines each. Markupwise, this generates:
BR:
one<br/>
two<br/>
three<br/>
<br/>
four<br/>
five<br/>
six<br/>
DIV:
<div>one</div>
<div>two</div>
<div>three</div>
<div> </div>
<div>four</div>
<div>five</div>
<div>six</div>
Manually handle enter key event to make the behavior consistent across
all supported browsers. See class description for details.
The node to check.
The position to find within the text node
This property decides the behavior of Enter key. It can be either P,
DIV, BR, or empty (which means disable this feature). Anything else
will trigger errors. The default is 'BR'
See class description for more details.
HTML to stick into a new empty block
Regex for testing if a given tag is a block level (display:block) tag
The value to set in the select.
parameter used to tell the select whether or not to fire
onChange event.
The label to apply to this particular FontDropDown.
Over-ride denoting the template has widgets to parse.
Flag to indicate that the returned label should be plain text
instead of an example.
The template used to construct the labeled dropdown.
The 'insert value' associated with a name
The text name of the value
Use generic (web standard) font names
The editor 'command' implemented by this plugin.
The 'insert value' associated with a name
The text name of the value
The editor 'command' implemented by this plugin.
The HTML font size values supported by this plugin
sizes according to the old HTML FONT SIZE
The 'insert value' associated with a name
The text name of the value
block format node to remove (and leave the contents behind)
The editor 'command' implemented by this plugin.
The HTML format tags supported by this plugin
The commands provided by this plugin are:
* fontName
Provides a drop down to select from a list of font names
* fontSize
Provides a drop down to select from a list of font sizes
* formatBlock
Provides a drop down to select from a list of block styles
which can easily be added to an editor by including one or more of the above commands
in the `plugins` attribute as follows:
plugins="['fontName','fontSize',...]"
It is possible to override the default dropdown list by providing an Array for the `custom` property when
instantiating this plugin, e.g.
plugins="[{name:'dijit._editor.plugins.FontChoice', command:'fontName', custom:['Verdana','Myriad','Garamond']},...]"
Alternatively, for `fontName` only, `generic:true` may be specified to provide a dropdown with
[CSS generic font families](http://www.w3.org/TR/REC-CSS2/fonts.html#generic-font-families)
Note that the editor is often unable to properly handle font styling information defined outside
the context of the current editor instance, such as pre-populated HTML.
Override _Plugin.useDefaultCommand...
processing is handled by this plugin, not by dijit.Editor.
The editor to configure for this plugin to use.
The key event.
zIndex value used for overlaying the full page.
default is 500.
The original view state of the editor.
The original view state of the iframe of the editor.
Connection point used for handling resize when window resizes.
Read-Only variable used to denote of the editor is in fullscreen mode or not.
The command provided by this plugin is:
* createLink
Content being set.
anchor/link to process for data for the dropdown.
The double-click event.
Used for validating input as correct URL. While file:// urls are not terribly
useful, they are technically valid.
Used for validating input as correct email address. Taken from dojox.validate
host.
String used for templating the HTML to insert at the desired point.
Tag used for the link type.
Template for contents of TooltipDialog to pick URL
The command provided by this plugin is:
* insertImage
The mousedown event.
Content being set.
The double-click event.
Over-ride for template since img dialog doesn't need target that anchor tags may.
String used for templating the <img> HTML to insert at the desired point.
Tag used for the link type (img).
Object The editor object to attach the newPage capability to.
The default content to insert into the editor as the new page.
The default is the <br> tag, a single blank line.
Object The editor object to attach the print capability to.
The commands provided by this plugin are:
* foreColor - sets the text color
* hiliteColor - sets the background color
False as we do not use the default editor command/click behavior.
Object The editor object to attach the print capability to.
Boolean value indicating if it should be in source mode or not.
The HTML to filter
The HTML to filter
The HTML to filter
The HTML to filter
Boolean flag used to indicate if script tags should be stripped from the document.
Defaults to true.
Boolean flag used to indicate if iframe tags should be stripped from the document.
Defaults to true.
Boolean flag used to indicate if the source view should be readonly or not.
Cannot be changed after initialization of the plugin.
Defaults to false.
The tag name to determine if it has an ancestor of.
The tag name to determine if it has an ancestor of.
The node to inspect.
The node to inspect.
Boolean to indicate whether to collapse the cursor to the beginning of the selection or end.
DOMNode The element you wish to select the children content of.
Boolean to indicate if the foxus should change or not.
DOMNode The element to select.
Boolean indicating if the focus should be changed. IE only.
Buttons can display a label, an icon, or both.
A label should always be specified (through innerHTML) or the label
attribute. It can be hidden via showLabel=false.
Set the label (text) of the button; takes an HTML string.
String
Text to display in button.
If the label is hidden (showLabel=false) then and no title has
been specified, then label is also set as title attribute of icon.
Set this to true to hide the label text and display only the icon.
(If showLabel=false then iconClass must be specified.)
Especially useful for toolbars.
If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
The exception case is for computers in high-contrast mode, where the label
will still be displayed, since the icon doesn't appear.
Class to apply to DOMNode in button to make it display an icon
Defines the type of button. "button", "submit", or "reset".
"start" or "end"
Text that describes the options menu (accessibility)
Corresponds to the native HTML <input> element's attribute.
In markup, specified as "checked='checked'" or just "checked".
True if the button is depressed, or the checkbox is checked,
or the radio button is selected, etc.
User interacts with real html inputs.
On onclick (which occurs by mouse click, space-bar, or
using the arrow keys to switch the selected radio button),
we update the state of the checkbox/radio.
There are two modes:
1. High contrast mode
2. Normal mode
In case 1, the regular html inputs are shown and used by the user.
In case 2, the regular html inputs are invisible but still used by
the user. They are turned quasi-invisible and overlay the background-image.
During initialization, just saves as attribute to the <input type=checkbox>.
After initialization,
when passed a boolean, controls whether or not the CheckBox is checked.
If passed a string, changes the value attribute of the CheckBox (the one
specified as "value" when the CheckBox was constructed (ex: <input
dojoType="dijit.CheckBox" value="chicken">)
If the CheckBox is checked, returns the value attribute.
Otherwise returns false.
type attribute on <input> node.
Overrides <code>dijit.form.Button.type</code>. Users should not change this value.
As an initialization parameter, equivalent to value field on normal checkbox
(if checked, the value is passed as the value when form is submitted).
However, get('value') will return either the string or false depending on
whether or not the checkbox is checked.
set('value', string) will check the checkbox and change the value to the
specified string
set('value', boolean) will change the checked state.
Should this widget respond to user input?
In markup, this is specified as "readOnly".
Similar to disabled except readOnly form values are submitted.
Provides a store for inlined data like:
<select>
<option value="AL">Alabama</option>
...
Actually. just implements the subset of dojo.data.Read/Notification
needed for ComboBox and FilteringSelect to work.
Note that an item is just a pointer to the <option> DomNode.
|| args || null
Given arguments like:
{identity: "CA", onItem: function(item){...}
Call `onItem()` with the DOM node `<option value="CA">California</option>`
All widgets that mix in dijit.form.ComboBoxMixin must extend `dijit.form._FormValueWidget`.
1. generates drop-down list and calls _showResultList() to display it
2. if this result list is from user pressing "more choices"/"previous choices"
then tell screen reader to announce new option
Users shouldn't call this function; they should be calling
set('item', value)
The label that the ComboBox should display
This is the item returned by the dojo.data.store implementation that
provides the data for this ComboBox, it's the currently selected item.
Argument to data provider.
Specifies number of search results per page (before hitting "next" button)
Reference to data provider object used by this ComboBox
Mixin to the dojo.data store's fetch.
For example, to set the sort order of the ComboBox menu, pass:
{ sort: [{attribute:"name",descending: true}] }
To override the default queryOptions so that deep=false, do:
{ queryOptions: {ignoreCase: true, deep: false} }
A query that can be passed to 'store' to initially filter the items,
before doing further filtering based on <code>searchAttr</code> and the key.
Any reference to the <code>searchAttr</code> is ignored.
If user types in a partial string, and then tab out of the <code><input></code> box,
automatically copy the first entry displayed in the drop down list to
the <code><input></code> field
One of: "first", "all" or "none".
If the ComboBox/FilteringSelect opens with the search results and the searched
string can be found, it will be highlighted. If set to "all"
then will probably want to change <code>queryExpr</code> parameter to '*${0}*'
Highlighting is only performed when <code>labelType</code> is "text", so as to not
interfere with any HTML markup an HTML label might contain.
Delay in milliseconds between when user types something and we start
searching based on that value
Search for items in the data store where this attribute (in the item)
matches what the user typed
The entries in the drop down list come from this attribute in the
dojo.data items.
If not specified, the searchAttr attribute is used instead.
Specifies how to interpret the labelAttr in the data store items.
Can be "html" or "text".
This specifies what query ComboBox/FilteringSelect sends to the data store,
based on what the user has typed. Changing this expression will modify
whether the drop down shows only exact matches, a "starting with" match,
etc. Use it in conjunction with highlightMatch.
dojo.data query expression pattern.
<code>${0}</code> will be substituted for the user text.
<code>*</code> is used for wildcards.
<code>${0}*</code> means "starts with", <code>*${0}*</code> means "contains", <code>${0}</code> means "is"
Set true if the ComboBox/FilteringSelect should ignore case when matching possible items
Set this textbox to have a down arrow button, to display the drop down list.
Defaults to true.
Name of the dropdown widget class used to select a date/time.
Subclasses should specify this.
of dojo.data items
store
to produce a label in the drop down list from a dojo.data item
Holds "next" and "previous" text for paging buttons on drop down
The drop down box's values are populated from an class called
a data provider, which returns a list of values based on the characters
that the user has typed into the input box.
If OPTION tags are used as the data provider via markup,
then the OPTION tag's child text node is used as the widget value
when selected. The OPTION tag's value attribute is ignored.
To set the default value when using OPTION tags, specify the selected
attribute on 1 of the child OPTION tags.
Some of the options to the ComboBox are actually arguments to the data
provider.
Sets the value of the select.
CurrencyTextBox is similar to `dijit.form.NumberTextBox` but has a few
extra features related to currency:
1. After specifying the currency type (american dollars, euros, etc.) it automatically
sets parse/format options such as how many decimal places to show.
2. The currency mark (dollar sign, euro mark, etc.) is displayed when the field is blurred
but erased during editing, so that the user can just enter a plain number.
the [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD"
Despite the name, this parameter specifies both constraints on the input
(including minimum/maximum allowed values) as well as
formatting options. See <code>dijit.form.CurrencyTextBox.__Constraints</code> for details.
Follows the pattern of `dijit.form.NumberTextBox.constraints`.
In general developers won't need to set this parameter
The value of this widget as a JavaScript Date object, with only year/month/day specified.
If specified in markup, use the format specified in <code>dojo.date.stamp.fromISOString</code>.
set("value", ...) accepts either a Date object or a string.
value.toString()="NaN"
An enhanced version of the HTML SELECT tag, populated dynamically. It works
very nicely with very large data sets because it can load and page data as needed.
It also resembles ComboBox, but does not allow values outside of the provided ones.
If OPTION tags are used as the data provider via markup, then the
OPTION tag's child text node is used as the displayed value when selected
while the OPTION tag's value attribute is used as the widget value on form submit.
To set the default value when using OPTION tags, specify the selected
attribute on 1 of the child OPTION tags.
Similar features:
- There is a drop down list of possible values.
- You can only enter a value from the drop down list. (You can't
enter an arbitrary value.)
- The value submitted with the form is the hidden value (ex: CA),
not the displayed value a.k.a. label (ex: California)
Enhancements over plain HTML version:
- If you type in some text then it will filter down the list of
possible values in the drop down list.
- List can be specified either as a static list or via a javascript
function (that can get the list from a server)
Sets the value of the select.
Also sets the label to the corresponding value by reverse lookup.
Users shouldn't call this function; they should be calling
set('item', value)
Sets textbox to display label. Also performs reverse lookup
to set the hidden value.
Doesn't work as expected when the FilteringSelect has a custom labelFunc(), since in that case
it's impossible to do a reverse lookup (from label --> item) without a full data store scan.
App must call set("displayedValue", ...) with the intended item.searchAttr, rather than
labelFunc(item).
True (default) if user is required to enter a value into this field.
This method is intended to be over-ridden, but by default it checks and
returns the validity of form elements. When the `submit`
method is called programmatically, the return value from
`onSubmit` is used to compute whether or not submission
should proceed
Name of form for scripting.
Server-side form handler.
HTTP method used to submit the form, either "GET" or "POST".
Encoding type for the form, ex: application/x-www-form-urlencoded.
List of supported charsets.
List of MIME types for file upload.
Target frame for the document to be opened in.
Number of hash marks to generate
For HorizontalSlider, this is either "topDecoration" or "bottomDecoration",
and indicates whether this rule goes above or below the slider.
CSS style to apply to individual hash marks
VerticalRule will override this...
CSS style to apply to individual text labels
Array of text labels to render - evenly spaced from left-to-right or bottom-to-top.
Alternately, minimum and maximum can be specified, to get numeric labels.
Number of generated numeric labels that should be rendered as '' on the ends when labels[] are not specified
Show increment/decrement buttons at the ends of the slider?
The minimum value the slider can be set to.
The maximum value the slider can be set to.
If specified, indicates that the slider handle has only 'discreteValues' possible positions,
and that after dragging the handle, it will snap to the nearest possible position.
Thus, the slider has only 'discreteValues' possible values.
For example, if minimum=10, maxiumum=30, and discreteValues=3, then the slider handle has
three possible positions, representing values 10, 20, or 30.
If discreteValues is not specified or if it's value is higher than the number of pixels
in the slider bar, then the slider handle can be moved freely, and the slider's value will be
computed/reported based on pixel position (in this case it will likely be fractional,
such as 123.456789).
If discreteValues is also specified, this indicates the amount of clicks (ie, snap positions)
that the slider handle is moved via pageup/pagedown keys.
If discreteValues is not specified, it indicates the number of pixels.
If clicking the slider bar changes the value or not
The time in ms to take to animate the slider handle from 0% to 100%,
when clicking the slider bar to make the handle move.
The visible display may
be locale-dependent and interactive. The value sent to the server is stored in a hidden
input field which uses the `name` attribute declared by the original widget. That value sent
to the server is defined by the dijit.form.MappedTextBox.serialize method and is typically
locale-neutral.
// move all the selected values from "bar" to "foo"
dijit.byId("foo").addSelected(dijit.byId("bar"));
Returns an array of the selected options' values.
Set the value(s) of this Select based on passed values
If null, onChange is not fired.
Number of elements to display on a page
NOTE: may be removed in version 2.0, since elements may have variable height;
set the size via style="..." or CSS class names instead.
for Form
A `dijit.form.NumberTextBox` extension to provide keyboard accessible value selection
as well as icons for spinning direction. When using the keyboard, the typematic rules
apply, meaning holding the key will gradually increase or decrease the value and
accelerate.
NumberTextBox is a textbox for entering and displaying numbers, supporting
the following main features:
1. Enforce minimum/maximum allowed values (as well as enforcing that the user types
a number rather than a random string)
2. NLS support (altering roles of comma and dot as "thousands-separator" and "decimal-point"
depending on locale).
3. Separate modes for editing the value and displaying it, specifically that
the thousands separator character (typically comma) disappears when editing
but reappears after the field is blurred.
4. Formatting and constraints regarding the number of places (digits after the decimal point)
allowed on input, and number of places displayed when blurred (see `constraints` parameter).
The number to be converted into a string.
Formatting options
String representing a number
Formatting options
Despite the name, this parameter specifies both constraints on the input
(including minimum/maximum allowed values) as well as
formatting options like places (the number of digits to display after
the decimal point). See <code>dijit.form.NumberTextBox.__Constraints</code> for details.
The value of this NumberTextBox as a Javascript Number (i.e., not a String).
If the displayed value is blank, the value is NaN, and if the user types in
an gibberish value (like "hello world"), the value is undefined
(i.e. get('value') returns undefined).
Symmetrically, set('value', NaN) will clear the displayed value,
whereas set('value', undefined) will have no effect.
The message to display if value is out-of-range
The margin box to set this dropdown to.
actually loads the child menu items - we only do this when we are
populating for showing the dropdown.
Show missing or invalid messages if appropriate, and highlight textbox field.
Used when a select is initially set to no value and the user is required to
set the value.
Add in our style to be applied to the focus node
Can be true or false, default is false.
Shows current state (ie, validation result) of input (Normal, Warning, or Error)
Currently displayed error/prompt message
See description of dijit.Tooltip.defaultPosition for details on this parameter.
What to display in an "empty" dropdown
Whether or not we have been loaded
Whether or not our children have been loaded
The number of characters per line.
For `dijit.form.TextBox` this basically returns the value of the <input>.
For `dijit.form.MappedTextBox` subclasses, which have both
a "displayed value" and a separate "submit value",
This treats the "displayed value" as the master value, computing the
submit value from it via this.parse().
Sets the value of the widget to "value" which can be of
any type as determined by the widget.
visual element value is also set to a corresponding,
but not necessarily the same, value.
If true, an onChange event is fired immediately instead of
waiting for the next blur event.
If specified, used to set the visual element value,
otherwise a computed visual value is used.
Returns the displayed value (what the user sees on the screen),
after filtering (ie, trimming spaces etc.).
For some subclasses of TextBox (like ComboBox), the displayed value
is different from the serialized value that's actually
sent to the server (see dijit.form.ValidationTextBox.serialize)
Sets the value of the visual element to the string "value".
The widget value is also set to a corresponding,
but not necessarily the same, value.
For MappedTextBox subclasses, this is called twice
- once with the display value
- once the value as set/returned by set('value', ...)
and get('value'), ex: a Number for NumberTextBox.
In the latter case it does corrections like converting null to NaN. In
the former case the NumberTextBox.filter() method calls this.inherited()
to execute standard trimming code in TextBox.filter().
TODO: break this into two methods in 2.0
Removes leading and trailing whitespace if true. Default is false.
Converts all characters to uppercase if true. Default is false.
Converts all characters to lowercase if true. Default is false.
Converts the first character of each word to uppercase if true.
HTML INPUT tag maxLength declaration.
If true, all text will be selected when focused with mouse
Defines a hint to help users fill out the input field (as defined in HTML 5).
This should only contain plain text (no html markup).
allows IE to disallow focus, but Firefox cannot be disabled for mousedown events
For subclasses like ComboBox where the displayed value
(ex: Kentucky) and the serialized value (ex: KY) are different,
this represents the displayed value.
Setting 'displayedValue' through set('displayedValue', ...)
updates 'value', and vice-versa. Otherwise 'value' is updated
from 'displayedValue' periodically, like onBlur etc.
TODO: move declaration to MappedTextBox?
Problem is that ComboBox references displayedValue,
for benefit of FilteringSelect.
if the textbox is blank, what value should be reported
A textarea that dynamically expands/contracts (changing it's height) as
the user types, to display all the text without requiring a scroll bar.
Takes nearly all the parameters (name, value, etc.) that a vanilla textarea takes.
Rows is not supported since this widget adjusts the height.
The value of this widget as a JavaScript Date object. Note that the date portion implies time zone and daylight savings rules.
Example:
new dijit.form.TimeTextBox({value: dojo.date.stamp.fromISOString("T12:59:59", new Date())})
When passed to the parser in markup, must be specified according to locale-independent
<code>dojo.date.stamp.fromISOString</code> format.
Example:
<input dojotype='dijit.form.TimeTextBox' value='T12:34:00'>
value.toString()="NaN"
FIXME: in markup, you have no control over daylight savings
Show missing or invalid messages if appropriate, and highlight textbox field.
User is required to enter data into this field.
If defined, display this hint string immediately on focus to the textbox, if empty.
Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
Think of this like a tooltip that tells the user what to do, not an error message
that tells the user what they've done wrong.
Message disappears when user starts typing.
The message to display if value is invalid.
The translated string value is read from the message file by default.
Set to "" to use the promptMessage instead.
The message to display if value is empty and the field is required.
The translated string value is read from the message file by default.
Set to "" to use the invalidMessage instead.
Currently error/prompt message.
When using the default tooltip implementation, this will only be
displayed when the field is focused.
user-defined object needed to pass parameters to the validator functions
regular expression string used to validate the input
Do not specify both regExp and regExpGen
Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
See description of <code>dijit.Tooltip.defaultPosition</code> for details on this parameter.
locale used for validation, picks up value from this widget's lang attribute
various flags passed to regExpGen function
Minimum signed value. Default is -Infinity
Maximum signed value. Default is +Infinity
This is either "leftDecoration" or "rightDecoration",
to indicate whether this rule goes to the left or to the right of the slider.
Note that on RTL system, "leftDecoration" would actually go to the right, and vice-versa.
Specifies if the slider values go from high-on-top (true), or low-on-top (false)
TODO: expose this in 1.2 - the css progress/remaining bar classes need to be reversed
Set this textbox to display a down arrow button, to open the drop down list.
Set to true to open drop down upon clicking anywhere on the textbox.
Despite the name, this parameter specifies both constraints on the input
(including starting/ending dates/times allowed) as well as
formatting options like whether the date is displayed in long (ex: December 25, 2005)
or short (ex: 12/25/2005) format. See <code>dijit.form._DateTimeTextBox.__Constraints</code> for details.
JavaScript namespace to find calendar routines. Uses Gregorian calendar routines
at dojo.date, by default.
The default value to focus in the popupClass widget when the textbox value is empty.
The value of this widget as a JavaScript Date object. Use get("value") / set("value", val) to manipulate.
When passed to the parser in markup, must be specified according to <code>dojo.date.stamp.fromISOString</code>
value.toString()="NaN"
Name of the popup widget class used to select a date/time.
Subclasses should specify this.
default is no popup = text only
Specifies constraints.selector passed to dojo.date functions, should be either
"date" or "time".
Subclass must specify this.
Can extract all the form widgets
values and combine them into a single javascript object, or alternately
take such an object and set the values for all the contained
form widgets
Will be "Error" if one or more of the child widgets has an invalid value,
"Incomplete" if not all of the required child widgets are filled in. Otherwise, "",
which indicates that the form is ready to be submitted.
If passed in as a string, that string is used to look up the option
in the array of options - based on the value property.
(See dijit.form.__SelectOption).
If passed in a number, then the option with the given index (0-based)
within this select will be returned.
If passed in a dijit.form.__SelectOption, the same option will be
returned if and only if it exists within this select.
If passed an array, then an array will be returned with each element
in the array being looked up.
If not passed a value, then all options will be returned
The option corresponding with the given value or index. null
is returned if any of the following are true:
- A string value is passed in which doesn't exist
- An index is passed in which is outside the bounds of the array of options
- A dijit.form.__SelectOption is passed in which is not a part of the select
The store you would like to use - it MUST implement Identity,
and MAY implement Notification.
The value that this widget should set itself to *after* the store
has been loaded
The arguments that will be passed to the store's fetch() function
or String[]
An array of items that will be loaded, when needed
Whether or not we are multi-valued
A store which, at the very least impelements dojo.data.api.Identity
to use for getting our list of options - rather than reading them
from the <option> html tags.
A query to use when fetching items from our store
Query options to use when fetching from the store
Flag to sort the options returned from a store by the label of
the store.
By default loadChildren is called when the items are fetched from the
store. This property allows delaying loadChildren (and the creation
of the options/menuitems) until the user clicks the button to open the
dropdown.
The value of the option. Setting to empty (or missing) will
place a separator at that location
The label for our option. It can contain html tags.
Whether or not we are a selected option
Whether or not this specific option is disabled
Represents a single HTML element.
All these widgets should have these attributes just like native HTML input elements.
You can set them during widget construction or afterwards, via `dijit._Widget.attr`.
They also share some common methods.
the new value
For a slider, for example, dragging the slider is priorityChange==false,
but on mouse up, it's priorityChange==true. If intermediateChanges==false,
onChange is only called form priorityChange=true events.
Name used when submitting form; same as "name" attribute or plain HTML elements
Corresponds to the native HTML <input> element's attribute.
Corresponds to the native HTML <input> element's attribute.
Corresponds to the native HTML <input> element's attribute.
Order fields are traversed when user hits the tab key
Should this widget respond to user input?
In markup, this is specified as "disabled='disabled'", or just "disabled".
Fires onChange for each value change or only on demand
On focus, should this widget scroll into view?
Indicates that changes to the value should call onChange() callback.
This is false during widget initialization, to avoid calling onChange()
when the initial value is set.
Each _FormValueWidget represents a single input value, and has a (possibly hidden) <input> element,
to which it serializes it's input value, so that form submission (either normal submission or via FormBind?)
works as expected.
Sets the value of the widget.
If the value has changed, then fire onChange event, unless priorityChange
is specified as null (or false?)
Should this widget respond to user input?
In markup, this is specified as "readOnly".
Similar to disabled except readOnly form values are submitted.
This class basically (conceptually) extends `dijit.form.ValidationTextBox`.
It modifies the template to have up/down arrows, and provides related handling code.
Number of milliseconds before a held arrow key or up/down button becomes typematic
minimum number of milliseconds that typematic event fires when held key or button is held
Fraction of time used to change the typematic timer between events.
1.0 means that each typematic event fires at defaultTimeout intervals.
< 1.0 means that each typematic event fires at an increasing faster rate.
Adjust the value by this much when spinning using the arrow keys/buttons
Adjust the value by this much when spinning using the PgUp/Dn keys
parent node
{l, t, w, h} object specifying dimensions of container into which to place children
an array of Widgets or at least objects containing:
* domNode: pointer to DOM node to position
* region or layoutAlign: position to place DOM node
* resize(): (optional) method to set size of node
* id: (optional) Id of widgets, referenced from resize object, below.
If specified, the slider for the region with the specified id has been dragged, and thus
the region's height or width should be adjusted according to changedRegionSize
See changedRegionId.
This is called from a handler on AccordionContainer.domNode
(setup in StackContainer), and is also called directly from
the click handler for accordion labels
Amount of time (in ms) it takes to slide panes
The name of the widget used to display the title of each pane
Pixels of space available for the open pane
(my content box size minus the cumulative size of all the title bars)
Name of class to use to instantiate title
(Wish we didn't have a separate widget for just the title but maintaining it
for backwards compatibility, is it worth it?)
A BorderContainer is a box with a specified size, such as style="width: 500px; height: 500px;",
that contains a child widget marked region="center" and optionally children widgets marked
region equal to "top", "bottom", "leading", "trailing", "left" or "right".
Children along the edges will be laid out according to width or height dimensions and may
include optional splitters (splitter="true") to make them resizable by the user. The remaining
space is designated for the center region.
The outer size must be specified on the BorderContainer node. Width must be specified for the sides
and height for the top and bottom, respectively. No dimensions should be specified on the center;
it will fill the remaining space. Regions named "leading" and "trailing" may be used just like
"left" and "right" except that they will be reversed in right-to-left environments.
For complex layouts, multiple children can be specified for a single region. In this case, the
layoutPriority flag on the children determines which child is closer to the edge (low layoutPriority)
and which child is closer to the center (high layoutPriority). layoutPriority can also be used
instead of the design attribute to conrol layout precedence of horizontal vs. vertical panes.
With no arguments, measures the height of top/bottom panes, the width
of left/right panes, and then sizes all panes accordingly.
With changedRegion specified (as "left", "top", "bottom", or "right"),
it changes that region's width/height to changedRegionSize and
then resizes other regions that were affected.
Id of the child which should be resized because splitter was dragged.
The new width/height (in pixels) to make specified child
Which design is used for the layout:
- "headline" (default) where the top and bottom extend
the full width of the container
- "sidebar" where the left and right sides extend from top to bottom.
Give each pane a border and margin.
Margin determined by domNode.paddingLeft.
When false, only resizable panes have a gutter (i.e. draggable splitter) for resizing.
Specifies whether splitters resize as you drag (true) or only upon mouseup (false)
Save splitter positions in a cookie.
Optional hook to override the default Splitter widget used by BorderContainer
This is instantiated by `dijit.layout.BorderContainer`. Users should not
create it directly.
Pointer to the parent BorderContainer
Region of pane associated with this splitter.
"top", "bottom", "left", "right".
If true, the child's size changes and the child widget is redrawn as you drag the splitter;
otherwise, the size doesn't change until you drop the splitter (by mouse-up)
Instantiated by `dijit.layout.BorderContainer`. Users should not
create directly.
This widget embeds a document fragment in the page, specified
either by uri, javascript generated markup or DOM reference.
Any widgets within this content are instantiated and managed,
but laid out according to the HTML structure. Unlike IFRAME,
ContentPane embeds a document fragment as would be found
inside the BODY tag of a full HTML document. It should not
contain the HTML, HEAD, or BODY tags.
For more advanced functionality with scripts and
stylesheets, see dojox.layout.ContentPane. This widget may be
used stand alone or as a base class for other widgets.
ContentPane is useful as a child of other layout containers
such as BorderContainer or TabContainer, but note that those
widgets can contain any widget as a child.
Reset the (external defined) content of this pane and replace with new url
Note: It delays the download until widget is shown if preload is false.
url to the page you want to get, must be within the same domain as your mainpage
the new Content may be String, DomNode or NodeList
if data is a NodeList (or an array of nodes) nodes are copied
so you can import nodes from another document implicitly
If I am a child of a layout widget then it actually returns true if I've ever been visible,
not whether I'm currently visible, since that's much faster than tracing up the DOM/widget
tree every call, and at least solves the performance problem on page load by deferring loading
hidden ContentPanes until they are first shown
For a plain ContentPane, this is called on initialization, from startup().
If the ContentPane is a hidden pane of a TabContainer etc., then it's
called whenever the pane is made visible.
Does necessary processing, including href download and layout/resize of
child widget(s)
1. cancels any currently in-flight requests
2. posts "loading..." message
3. sends XHR to download new data
The string returned by this function will be the html
that tells the user we are loading something.
Override with your own function if you want to change text.
The href of the content that displays now.
Set this at construction if you want to load data externally when the
pane is shown. (Set preload=true to load it immediately.)
Changing href after creation doesn't have any effect; Use set('href', ...);
|| DomNode || NodeList || dijit._Widget
The innerHTML of the ContentPane.
Note that the initialization parameter / argument to set("content", ...)
can be a String, DomNode, Nodelist, or _Widget.
Extract visible content from inside of <body> .... </body>.
I.e., strip <html> and <head> (and it's contents) from the href
Parse content and create the widgets, if any.
Flag passed to parser. Root for attribute names to search for. If scopeName is dojo,
will search for data-dojo-type (or dojoType). For backwards compatibility
reasons defaults to dojo._scopeName (which is "dojo" except when
multi-version support is used, when it will be something like dojo16, dojo20, etc.)
Prevent caching of data from href's by appending a timestamp to the href.
Force load of data on initialization even if pane is hidden.
Refresh (re-download) content when pane goes from hidden to shown
Message that shows while downloading
Message that shows if an error occurs
True if the ContentPane has data in it, either specified
during initialization (via href or inline content), or set
via set('content', ...) / set('href', ...)
False if it doesn't have any content, or if ContentPane is
still in the process of downloading href.
Parameters to pass to xhrGet() request, for example:
<div dojoType="dijit.layout.ContentPane" href="./bar" ioArgs="{timeout: 500}">
Indicates that this widget acts as a "parent" to the descendant widgets.
When the parent is started it will call startup() on the child widgets.
See also <code>isLayoutContainer</code>.
This is the <code>dojo.Deferred</code> returned by set('href', ...) and refresh().
Calling onLoadDeferred.addCallback() or addErrback() registers your
callback to be called only once, when the prior set('href', ...) call or
the initial href parameter to the constructor finishes loading.
This is different than an onLoad() handler which gets called any time any href
or content is loaded.
Flag from the parser that this ContentPane is inside a template
so the contents are pre-parsed.
(TODO: this declaration can be commented out in 2.0)
Provides Delphi-style panel layout semantics.
A LayoutContainer is a box with a specified size (like style="width: 500px; height: 500px;"),
that contains children widgets marked with "layoutAlign" of "left", "right", "bottom", "top", and "client".
It takes it's children marked as left/top/bottom/right, and lays them out along the edges of the box,
and then it takes the child marked "client" and puts it into the remaining space in the middle.
Left/right positioning is similar to CSS's "float: left" and "float: right",
and top/bottom positioning would be similar to "float: top" and "float: bottom", if there were such
CSS.
Note that there can only be one client element, but there can be multiple left, right, top,
or bottom elements.
LinkPane is just a ContentPane that is declared in markup similarly
to an anchor. The anchor's body (the words between `<a>` and `</a>`)
become the title of the widget (used for TabContainer, AccordionContainer, etc.)
If an number argument is passed to the function, that horizontal
pixel position is scrolled to. Otherwise the currently selected
tab is scrolled to.
An optional pixel value to scroll to, indicating distance from left.
The mouse click event.
The mouse click event.
The mouse click event.
If the direction is 1, the widget scrolls to the right, if it is
-1, it scrolls to the left.
Integer amount of horizontal scroll
True if a menu should be used to select tabs when they are too
wide to fit the TabContainer, false otherwise.
True if a slider should be used to select tabs when they are too
wide to fit the TabContainer, false otherwise.
The css class to apply to the tab strip, if it is visible.
The distance in pixels from the edge of the tab strip which,
if a scroll animation is less than, forces the scroll to
go all the way to the left/right.
A Container widget with sizing handles in-between each child.
Contains multiple children widgets, all of which are displayed side by side
(either horizontally or vertically); there's a bar between each of the children,
and you can adjust the relative size of each child by dragging the bars.
You must specify a size (width and height) for the SplitContainer.
a widget to add
postion in the "stack" to add the child widget
If true, the children's size changes as you drag the bar;
otherwise, the sizes don't change until you drop the bar (by mouse-up)
Size in pixels of the bar between each child
FIXME: this should be a CSS attribute (at 7 because css wants it to be 7 until we fix to css)
either 'horizontal' or vertical; indicates whether the children are
arranged side-by-side or up/down.
Save splitter positions in a cookie
A container for widgets (ContentPanes, for example) That displays
only one Widget at a time.
Publishes topics [widgetId]-addChild, [widgetId]-removeChild, and [widgetId]-selectChild
Can be base class for container, Wizard, Show, etc.
Reference to child widget or id of child widget
Promise that fires when page has finished showing, or true if there's no href
If true, change the size of my currently displayed child to match my size
Remembers the selected child across sessions
References the currently selected child widget, if any.
Adjust selected child with selectChild() method.
Monitors the specified StackContainer, and whenever a page is
added, deleted, or selected, updates itself accordingly.
The id of the page container that I point to
The name of the button widget to create to correspond to each page
The button-like or tab-like object you click to select or delete a page
A TabContainer is a container that has multiple panes, but shows only
one pane at a time. There are a set of tabs corresponding to each pane,
where each tab has the name (aka title) of the pane, and optionally a close button.
True if a menu should be used to select tabs when they are too
wide to fit the TabContainer, false otherwise.
True if a slider should be used to select tabs when they are too
wide to fit the TabContainer, false otherwise.
An optional parameter to override the widget used to display the tab labels
Lets the user select the currently shown pane in a TabContainer or StackContainer.
TabController also monitors the TabContainer, and whenever a pane is
added or deleted updates itself accordingly.
Defines where tabs go relative to the content.
"top", "bottom", "left-h", "right-h"
The name of the tab widget to create to correspond to each page
Contains the title of the pane, and optionally a close-button to destroy the pane.
This is an internal widget and should not be instantiated directly.
takes an HTML string.
Inherited ToggleButton implementation will Set the label (text) of the button;
Need to set the alt attribute of icon on tab buttons if no label displayed
The CSS class applied to the domNode.
- false - don't adjust size of children
- true - if there is a single visible child widget, set it's size to
however big the ContentPane is
Indicates that this widget will call resize() on it's child widgets
when they become visible.
Change size mode:
When changeSize is specified, changes the marginBox of this widget
and forces it to relayout its contents accordingly.
changeSize may specify height, width, or both.
If resultSize is specified it indicates the size the widget will
become after changeSize has been applied.
Notification mode:
When changeSize is null, indicates that the caller has already changed
the size of the widget, or perhaps it changed because the browser
window was resized. Tells widget to relayout its contents accordingly.
If resultSize is also specified it indicates the size the widget has
become.
In either mode, this method also:
1. Sets this._borderBox and this._contentBox to the new size of
the widget. Queries the current domNode size if necessary.
2. Calls layout() to resize contents (and maybe adjust child widgets).
Sets the widget to this margin-box size and position.
May include any/all of the following properties:
{w: int, h: int, l: int, t: int}
The margin-box size of this widget after applying changeSize (if
changeSize is specified). If caller knows this size and
passes it in, we don't need to query the browser to get the size.
{w: int, h: int}
This class name is applied to the widget's domNode
and also may be used to generate names for sub nodes,
for example dijitTabContainer-content.
Indicates that this widget is going to call resize() on its
children widgets, setting their size, when they become visible.
A TabContainer is a container that has multiple panes, but shows only
one pane at a time. There are a set of tabs corresponding to each pane,
where each tab has the name (aka title) of the pane, and optionally a close button.
Defines where tabs go relative to tab content.
"top", "bottom", "left-h", "right-h"
Defines whether the tablist gets an extra class for layouting, putting a border/shading
around the set of tabs. Not supported by claro theme.
If true, use styling for a TabContainer nested inside another TabContainer.
For tundra etc., makes tabs look like links, and hides the outer
border since the outer TabContainer already has a border.
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, in milliseconds, to wait before firing.
The delay is a delta with respect to the previous automation call.
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);
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, 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:
doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
Approximate time Robot will spend moving the mouse
The default is 100ms.
x offset relative to the node, in pixels, to move the mouse. The default is half the node's width.
y offset relative to the node, in pixels, to move the mouse. The default is half the node's height.
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.
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(dojo.keys.ENTER, 500); });
}
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.
store.setValue(item, "root", true);
store.unsetAttribute(item, "root");
Note that the default implementation requeries the top level items every time
a new item is created, since any new item could be a top level item (even in
addition to being a child of another item, since items can have multiple parents).
If developers can detect which items are possible top level items (based on the item and the
parentInfo parameters), they should override this method to only call _requeryTop() for top
level items. Often all top level items have parentInfo==null, but
that will depend on which store you use and what your data is like.
Handles updates to an item's children by calling onChildrenChange(), and
other updates to an item by calling onChange().
Also, any change to any item re-executes the query for the tree's top-level items,
since this modified item may have started/stopped matching the query for top level items.
If possible, developers should override this function to only call _requeryTop() when
the change to the item has caused it to stop/start being a top level item in the tree.
| array
| array
ID of fabricated root item
Label of fabricated root item
Specifies the set of children of the root item.
Developers will need to override this method if new items get added
to parents with multiple children attributes, in order to define which
children attribute points to the new item.
Note that there will also be an onChildrenChange() callback for the parent
of this item.
If the new item is a child of an existing item,
calls onChildrenChange() with the new list of children
for that existing item.
Handles updates to an item's children by calling onChildrenChange(), and
other updates to an item by calling onChange().
See `onNewItem` for more details on handling updates to an item's children.
| array
| array
Underlying store
One or more attribute names (attributes in the dojo.data item) that specify that item's children
Name of attribute in the Object passed to newItem() that specifies the id.
If newItemIdAttr is set then it's used when newItem() is called to see if an
item with the same id already exists, and if so just links to the old item
(so that the old item ends up with two parents).
Setting this to null or "" will make every drop create a new item.
If specified, get label for tree node from this attribute, rather
than by calling store.getLabel()
Pointer to the root item (read only, not a parameter)
Specifies datastore query to return the root item for the tree.
Must only return a single item. Alternately can just pass in pointer
to root item.
Setting this to true will cause the TreeStoreModel to defer calling loadItem on nodes
until they are expanded. This allows for lazying loading where only one
loadItem (and generally one network call, consequently) per expansion
(rather than one for each child).
This relies on partial loading of the children items; each children item of a
fully loaded item should contain the label and info about having children.
Node or node's id to build the container on
A dict of parameters, which gets mixed into the object
A name of the state to change
new state
A node
A variable suffix for a class name
A node
A variable suffix for a class name
The currently hovered TreeNode.rowNode (which is the DOM node
associated w/a given node in the tree, excluding it's descendants)
Node or node's id to build the container on
params: dijit.tree.__SourceArgs
A dict of parameters, which gets mixed into the object
Node node to add
Whether the node should become anchor.
Node node to remove
Node the node to check whether it's in the current selection
Node[] list of tree nodes to make selected
mouse event
mouse event
mouse event
Indicates whether this is meant to be a multi-select action (e.g. ctrl-click)
Indicates whether this is meant to be a ranged action (e.g. shift-click)
DomNode>
(id, DomNode) map for every TreeNode that's currently selected.
The DOMNode is the TreeNode.rowNode.
Allows selection of only one element, if true.
Tree hasn't been tested in singular=true mode, unclear if it works.
The source which provides items
Array of DOM nodes corresponding to nodes being dropped, dijitTreeRow nodes if
source is a dijit.Tree.
The "copy" control key was pressed
onmousemouse event
onmousedown event
onmouseup event
In the base case, this is called to check if target can become a child of source.
When betweenThreshold is set, position="before" or "after" means that we
are asking if the source node can be dropped before/after the target node.
The dijitTreeRoot DOM node inside of the TreeNode that we are dropping on to
Use dijit.getEnclosingWidget(target) to get the TreeNode.
The (set of) nodes we are dropping
"over", "before", or "after"
The dijit.tree.dndSource / dojo.dnd.Source which has the mouse over it
The dijit.tree.dndSource / dojo.dnd.Source which is providing the items
The list of transferred items, dndTreeNode nodes if dragging from a Tree
Copy items, if true, move items otherwise
For each node in nodes[], which came from source, create a hash of name/value
pairs to be passed to Tree.model.newItem(). Returns array of those hashes.
Object[]
Array of name/value hashes for each new item to be added to the Tree, like:
[
{ id: 123, label: "apple", foo: "bar" },
{ id: 456, label: "pear", zaz: "bam" }
]
Updates data store items according to where node was dragged from and dropped
to. The tree will then respond to those data store updates and redraw itself.
The dijit.tree.dndSource / dojo.dnd.Source which is providing the items
The list of transferred items, dndTreeNode nodes if dragging from a Tree
Copy items, if true, move items otherwise
DragSource object.
tree row onto which the dragged nodes are being dropped.
Can be used as a DnD source.
List of accepted types (text strings) for the Tree; defaults to
["text"]
Copy items, if true, use a state of Ctrl key otherwise
The move delay in pixels before detecting a drag; 5 by default
Distance from upper/lower edge of node to allow drop to reorder nodes
Can be used as a DnD source. Defaults to true.
List of accepted types (text strings) for a target; defaults to
["text", "treeNode"]
Copy items, if true, use a state of Ctrl key otherwise,
The move delay in pixels before detecting a drag; 0 by default
Distance from upper/lower edge of node to allow drop to reorder nodes
Tree passes in values to the constructor to specify the callbacks.
"item" is typically a dojo.data.Item but it's just a black box so
it could be anything.
This (like `dojo.data.api.Read`) is just documentation, and not meant to be used.
Objects of this class keep list of arrays in the form [name, check,
wrap, directReturn] that are used to determine what the contextual
result of a set of checked arguments is. All check/wrap functions
in this registry should be of the same arity.
a way to identify this matcher.
a function that arguments are passed to from the adapter's
match() function. The check function should return true if the
given arguments are appropriate for the wrap function.
If directReturn is true, the value passed in for wrap will be
returned instead of being called. Alternately, the
AdapterRegistry can be set globally to "return not call" using
the returnWrappers property. Either way, this behavior allows
the registry to act as a "search" function instead of a
function interception library.
If override is given and true, the check function will be given
highest priority. Otherwise, it will be the lowest priority
adapter.
DeferredList takes an array of existing deferreds and returns a new deferred of its own
this new deferred will typically have its callback fired when all of the deferreds in
the given list have fired their own deferreds. The parameters `fireOnOneCallback` and
fireOnOneErrback, will fire before all the deferreds as appropriate
dojo.NodeList instances provide many utilities that reflect
core Dojo APIs for Array iteration and manipulation, DOM
manipulation, and event handling. Instead of needing to dig up
functions in the dojo.* namespace, NodeLists generally make the
full power of Dojo available for DOM manipulation tasks in a
simple, chainable way.
Stash or get some arbirtrary data on/from these nodes. This private _data function is
exposed publicly on `dojo.NodeList`, eg: as the result of a `dojo.query` call.
DIFFERS from jQuery.data in that when used as a getter, the entire list is ALWAYS
returned. EVEN WHEN THE LIST IS length == 1.
A single-node version of this function is provided as `dojo._nodeData`, which follows
the same signature, though expects a String ID or DomNode reference in the first
position, before key/value arguments.
node: String|DomNode
The node to associate data with
Set a key `bar` to some data, then retrieve it.
dojo.query(".foo").data("bar", "touched");
var touched = dojo.query(".foo").data("bar");
if(touched[0] == "touched"){ alert('win'); }
Get all the data items for a given node.
var list = dojo.query(".foo").data();
var first = list[0];
Set the data to a complex hash. Overwrites existing keys with new value
dojo.query(".foo").data({ bar:"baz", foo:"bar" });
Then get some random key:
dojo.query(".foo").data("foo"); // returns [`bar`]
If an object, act as a setter and iterate over said object setting data items as defined.
If a string, and <code>value</code> present, set the data for defined <code>key</code> to <code>value</code>
If a string, and <code>value</code> absent, act as a getter, returning the data associated with said <code>key</code>
The value to set for said <code>key</code>, provided <code>key</code> is a string (and not an object)
Object|Anything|Nothing
When used as a setter via `dojo.NodeList`, a NodeList instance is returned
for further chaning. When used as a getter via `dojo.NodeList` an ARRAY
of items is returned. The items in the array correspond to the elements
in the original list. This is true even when the list length is 1, eg:
when looking up a node by ID (#foo)
If ommitted, clean all data for this node.
If passed, remove the data item found at <code>key</code>
Fade in all tables with class "blah":
dojo.query("table.blah").wipeIn().play();
Utilizing `auto` to get the NodeList back:
dojo.query(".titles").wipeIn({ auto:true }).onclick(someFunction);
Additional dojo.Animation arguments to mix into this set with the addition of
an <code>auto</code> parameter.
dojo.Animation|dojo.NodeList
A special args member `auto` can be passed to automatically play the animation.
If args.auto is present, the original dojo.NodeList will be returned for further
chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
Wipe out all tables with class "blah":
dojo.query("table.blah").wipeOut().play();
Additional dojo.Animation arguments to mix into this set with the addition of
an <code>auto</code> parameter.
dojo.Animation|dojo.NodeList
A special args member `auto` can be passed to automatically play the animation.
If args.auto is present, the original dojo.NodeList will be returned for further
chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
Move all tables with class "blah" to 300/300:
dojo.query("table.blah").slideTo({
left: 40,
top: 50
}).play();
Additional dojo.Animation arguments to mix into this set with the addition of
an <code>auto</code> parameter.
dojo.Animation|dojo.NodeList
A special args member `auto` can be passed to automatically play the animation.
If args.auto is present, the original dojo.NodeList will be returned for further
chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
Fade in all tables with class "blah":
dojo.query("table.blah").fadeIn().play();
Additional dojo.Animation arguments to mix into this set with the addition of
an <code>auto</code> parameter.
dojo.Animation|dojo.NodeList
A special args member `auto` can be passed to automatically play the animation.
If args.auto is present, the original dojo.NodeList will be returned for further
chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
Fade out all elements with class "zork":
dojo.query(".zork").fadeOut().play();
Fade them on a delay and do something at the end:
var fo = dojo.query(".zork").fadeOut();
dojo.connect(fo, "onEnd", function(){ /*...*/ });
fo.play();
Using `auto`:
dojo.query("li").fadeOut({ auto:true }).filter(filterFn).forEach(doit);
Additional dojo.Animation arguments to mix into this set with the addition of
an <code>auto</code> parameter.
dojo.Animation|dojo.NodeList
A special args member `auto` can be passed to automatically play the animation.
If args.auto is present, the original dojo.NodeList will be returned for further
chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
dojo.query(".zork").animateProperty({
duration: 500,
properties: {
color: { start: "black", end: "white" },
left: { end: 300 }
}
}).play();
dojo.query(".grue").animateProperty({
auto:true,
properties: {
height:240
}
}).onclick(handler);
dojo.Animation|dojo.NodeList
A special args member `auto` can be passed to automatically play the animation.
If args.auto is present, the original dojo.NodeList will be returned for further
chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
Another way to fade out:
dojo.query(".thinger").anim({ opacity: 0 });
animate all elements with the "thigner" class to a width of 500
pixels over half a second
dojo.query(".thinger").anim({ width: 500 }, 700);
the properties to animate. does NOT support the <code>auto</code> parameter like other
NodeList-fx methods.
Optional. The time to run the animations for
Optional. The easing function to use.
A function to be called when the animation ends
how long to delay playing the returned animation
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.
dojo.query(".thingList").html("<li dojoType='dojo.dnd.Moveable'>1</li><li dojoType='dojo.dnd.Moveable'>2</li><li dojoType='dojo.dnd.Moveable'>3</li>",
{
parseContent: true,
onBegin: function(){
this.content = this.content.replace(/([0-9])/g, this.id + ": $1");
this.inherited("onBegin", arguments);
}
}).removeClass("notdone").addClass("done");
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
This method is simpler than the dojo.NodeList.html() method provided by
`dojo.NodeList-html`. This method just does proper innerHTML insertion of HTML fragments,
and it allows for the innerHTML to be read for the first node in the node list.
Since dojo.NodeList-html already took the "html" name, this method is called
"innerHTML". However, if dojo.NodeList-html has not been loaded yet, this
module will define an "html" method that can be used instead. 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.
The nodes represented by the value argument will be cloned if more than one
node is in this NodeList. The nodes in this NodeList are returned in the "set"
usage of this method, not the HTML that was inserted.
assume a DOM created by this markup:
<div id="foo"></div>
<div id="bar"></div>
This code inserts <p>Hello World</p> into both divs:
dojo.query("div").innerHTML("<p>Hello World</p>");
assume a DOM created by this markup:
<div id="foo"><p>Hello Mars</p></div>
<div id="bar"><p>Hello World</p></div>
This code returns "<p>Hello Mars</p>":
var message = dojo.query("div").innerHTML();
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
assume a DOM created by this markup:
<div id="foo"></div>
<div id="bar"></div>
This code inserts "Hello World" into both divs:
dojo.query("div").text("Hello World");
assume a DOM created by this markup:
<div id="foo"><p>Hello Mars <span>today</span></p></div>
<div id="bar"><p>Hello World</p></div>
This code returns "Hello Mars today":
var message = dojo.query("div").text();
if no value is passed, the result is String, the text value of the first node.
If a value is passed, the return is this dojo.NodeList
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.
assume a DOM created by this markup:
<div id="foo"><p>Hello Mars</p></div>
<div id="bar"><p>Hello World</p></div>
Running this code:
dojo.query("div").append("<span>append</span>");
Results in this DOM structure:
<div id="foo"><p>Hello Mars</p><span>append</span></div>
<div id="bar"><p>Hello World</p><span>append</span></div>
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the appended content.
The nodes in this NodeList will be cloned if the query
matches more than one element. Only the DOM nodes are cloned, not
any attached event handlers.
assume a DOM created by this markup:
<span>append</span>
<p>Hello Mars</p>
<p>Hello World</p>
Running this code:
dojo.query("span").appendTo("p");
Results in this DOM structure:
<p>Hello Mars<span>append</span></p>
<p>Hello World<span>append</span></p>
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the matched nodes from the query.
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.
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the appended content.
assume a DOM created by this markup:
<div id="foo"><p>Hello Mars</p></div>
<div id="bar"><p>Hello World</p></div>
Running this code:
dojo.query("div").prepend("<span>prepend</span>");
Results in this DOM structure:
<div id="foo"><span>prepend</span><p>Hello Mars</p></div>
<div id="bar"><span>prepend</span><p>Hello World</p></div>
The nodes in this NodeList will be cloned if the query
matches more than one element. Only the DOM nodes are cloned, not
any attached event handlers.
assume a DOM created by this markup:
<span>prepend</span>
<p>Hello Mars</p>
<p>Hello World</p>
Running this code:
dojo.query("span").prependTo("p");
Results in this DOM structure:
<p><span>prepend</span>Hello Mars</p>
<p><span>prepend</span>Hello World</p>
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the matched nodes from the query.
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.
assume a DOM created by this markup:
<div id="foo"><p>Hello Mars</p></div>
<div id="bar"><p>Hello World</p></div>
Running this code:
dojo.query("div").after("<span>after</span>");
Results in this DOM structure:
<div id="foo"><p>Hello Mars</p></div><span>after</span>
<div id="bar"><p>Hello World</p></div><span>after</span>
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the appended content.
The nodes in this NodeList will be cloned if the query
matches more than one element. Only the DOM nodes are cloned, not
any attached event handlers.
assume a DOM created by this markup:
<span>after</span>
<p>Hello Mars</p>
<p>Hello World</p>
Running this code:
dojo.query("span").insertAfter("p");
Results in this DOM structure:
<p>Hello Mars</p><span>after</span>
<p>Hello World</p><span>after</span>
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the matched nodes from the query.
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.
assume a DOM created by this markup:
<div id="foo"><p>Hello Mars</p></div>
<div id="bar"><p>Hello World</p></div>
Running this code:
dojo.query("div").before("<span>before</span>");
Results in this DOM structure:
<span>before</span><div id="foo"><p>Hello Mars</p></div>
<span>before</span><div id="bar"><p>Hello World</p></div>
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the appended content.
The nodes in this NodeList will be cloned if the query
matches more than one element. Only the DOM nodes are cloned, not
any attached event handlers.
assume a DOM created by this markup:
<span>before</span>
<p>Hello Mars</p>
<p>Hello World</p>
Running this code:
dojo.query("span").insertBefore("p");
Results in this DOM structure:
<span>before</span><p>Hello Mars</p>
<span>before</span><p>Hello World</p>
dojo.NodeList, the nodes currently in this NodeList will be returned,
not the matched nodes from the query.
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.
dojo.NodeList
html will be cloned if the NodeList has more than one
element. Only DOM nodes are cloned, not any attached
event handlers.
assume a DOM created by this markup:
<b>one</b>
<b>two</b>
Running this code:
dojo.query("b").wrap("<div><span></span></div>");
Results in this DOM structure:
<div><span><b>one</b></span></div>
<div><span><b>two</b></span></div>
dojo.NodeList, the nodes in the current NodeList will be returned,
not the nodes from html argument.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".red").wrapAll('<div class="allRed"></div>');
Results in this DOM structure:
<div class="container">
<div class="allRed">
<div class="red">Red One</div>
<div class="red">Red Two</div>
</div>
<div class="blue">Blue One</div>
<div class="blue">Blue Two</div>
</div>
dojo.NodeList, the nodes in the current NodeList will be returned,
not the nodes from html argument.
html will be cloned if the NodeList has more than one
element. Only DOM nodes are cloned, not any attached
event handlers.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".red").wrapInner('<span class="special"></span>');
Results in this DOM structure:
<div class="container">
<div class="red"><span class="special">Red One</span></div>
<div class="blue">Blue One</div>
<div class="red"><span class="special">Red Two</span></div>
<div class="blue">Blue Two</div>
</div>
dojo.NodeList, the nodes in the current NodeList will be returned,
not the nodes from html argument.
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.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".red").replaceWith('<div class="green">Green</div>');
Results in this DOM structure:
<div class="container">
<div class="green">Green</div>
<div class="blue">Blue One</div>
<div class="green">Green</div>
<div class="blue">Blue Two</div>
</div>
The nodes currently in this NodeList will be returned, not the replacing content.
Note that the returned nodes have been removed from the DOM.
The nodes in this NodeList will be cloned if the query
matches more than one element. Only the DOM nodes are cloned, not
any attached event handlers.
assume a DOM created by this markup:
<div class="container">
<div class="spacer">___</div>
<div class="red">Red One</div>
<div class="spacer">___</div>
<div class="blue">Blue One</div>
<div class="spacer">___</div>
<div class="red">Red Two</div>
<div class="spacer">___</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".red").replaceAll(".blue");
Results in this DOM structure:
<div class="container">
<div class="spacer">___</div>
<div class="spacer">___</div>
<div class="red">Red One</div>
<div class="red">Red Two</div>
<div class="spacer">___</div>
<div class="spacer">___</div>
<div class="red">Red One</div>
<div class="red">Red Two</div>
</div>
The nodes currently in this NodeList will be returned, not the matched nodes
from the query. The nodes currently in this NodeLIst could have
been cloned, so the returned NodeList will include the cloned nodes.
Only the DOM nodes are cloned, not any attached event handlers.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".red").clone().appendTo(".container");
Results in this DOM structure:
<div class="container">
<div class="red">Red One</div>
<div class="blue">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
<div class="red">Red One</div>
<div class="red">Red Two</div>
</div>
dojo.NodeList, a cloned set of the original nodes.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
Some Text
<div class="blue">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".container").children();
returns the four divs that are children of the container div.
Running this code:
dojo.query(".container").children(".red");
returns the two divs that have the class "red".
a CSS selector.
dojo.NodeList, all immediate child elements for the nodes in this dojo.NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
Some Text
<div class="blue">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".red").closest(".container");
returns the div with class "container".
a CSS selector.
If specified, query is relative to "root" rather than document body.
dojo.NodeList, the closest parent that matches the query, including the current
node in this dojo.NodeList if it matches the query.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue first"><span class="text">Blue One</span></div>
<div class="red">Red Two</div>
<div class="blue"><span class="text">Blue Two</span></div>
</div>
Running this code:
dojo.query(".text").parent();
returns the two divs with class "blue".
Running this code:
dojo.query(".text").parent(".first");
returns the one div with class "blue" and "first".
a CSS selector.
dojo.NodeList, immediate parent elements for nodes in this dojo.NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue first"><span class="text">Blue One</span></div>
<div class="red">Red Two</div>
<div class="blue"><span class="text">Blue Two</span></div>
</div>
Running this code:
dojo.query(".text").parents();
returns the two divs with class "blue", the div with class "container",
the body element and the html element.
Running this code:
dojo.query(".text").parents(".container");
returns the one div with class "container".
a CSS selector.
dojo.NodeList, all parent elements for nodes in this dojo.NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
Some Text
<div class="blue first">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".first").siblings();
returns the two divs with class "red" and the other div
with class "blue" that does not have "first".
Running this code:
dojo.query(".first").siblings(".red");
returns the two div with class "red".
a CSS selector.
dojo.NodeList, all sibling elements for nodes in this dojo.NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
Some Text
<div class="blue first">Blue One</div>
<div class="red">Red Two</div>
<div class="blue last">Blue Two</div>
</div>
Running this code:
dojo.query(".first").next();
returns the div with class "red" and has innerHTML of "Red Two".
Running this code:
dojo.query(".last").next(".red");
does not return any elements.
a CSS selector.
dojo.NodeList, the next element for nodes in this dojo.NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
Some Text
<div class="blue first">Blue One</div>
<div class="red next">Red Two</div>
<div class="blue next">Blue Two</div>
</div>
Running this code:
dojo.query(".first").nextAll();
returns the two divs with class of "next".
Running this code:
dojo.query(".first").nextAll(".red");
returns the one div with class "red" and innerHTML "Red Two".
a CSS selector.
dojo.NodeList, all sibling elements that come after the nodes in this dojo.NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
Some Text
<div class="blue first">Blue One</div>
<div class="red">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".first").prev();
returns the div with class "red" and has innerHTML of "Red One".
Running this code:
dojo.query(".first").prev(".blue");
does not return any elements.
a CSS selector.
dojo.NodeList, the previous element for nodes in this dojo.NodeList.
The returned nodes will be in reverse DOM order -- the first node in the list will
be the node closest to the original node/NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red prev">Red One</div>
Some Text
<div class="blue prev">Blue One</div>
<div class="red second">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".second").prevAll();
returns the two divs with class of "prev".
Running this code:
dojo.query(".first").prevAll(".red");
returns the one div with class "red prev" and innerHTML "Red One".
a CSS selector.
dojo.NodeList, all sibling elements that come before the nodes in this dojo.NodeList.
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red prev">Red One</div>
Some Text
<div class="blue prev">Blue One</div>
<div class="red second">Red Two</div>
<div class="blue">Blue Two</div>
</div>
Running this code:
dojo.query(".second").prevAll().andSelf();
returns the two divs with class of "prev", as well as the div with class "second".
dojo.NodeList
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue first">Blue One</div>
<div class="red">Red Two</div>
<div class="blue last">Blue Two</div>
</div>
Running this code:
dojo.query(".blue").first();
returns the div with class "blue" and "first".
dojo.NodeList, with the first node in this dojo.NodeList
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="red">Red One</div>
<div class="blue first">Blue One</div>
<div class="red">Red Two</div>
<div class="blue last">Blue Two</div>
</div>
Running this code:
dojo.query(".blue").last();
returns the last div with class "blue",
dojo.NodeList, with the last node in this dojo.NodeList
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="interior red">Red One</div>
<div class="interior blue">Blue One</div>
<div class="interior red">Red Two</div>
<div class="interior blue">Blue Two</div>
</div>
Running this code:
dojo.query(".interior").even();
returns the two divs with class "blue"
dojo.NodeList, with the even nodes in this dojo.NodeList
.end() can be used on the returned dojo.NodeList to get back to the
original dojo.NodeList.
assume a DOM created by this markup:
<div class="container">
<div class="interior red">Red One</div>
<div class="interior blue">Blue One</div>
<div class="interior red">Red Two</div>
<div class="interior blue">Blue Two</div>
</div>
Running this code:
dojo.query(".interior").odd();
returns the two divs with class "red"
dojo.NodeList, with the odd nodes in this dojo.NodeList
If content is an object, it can have special properties "template" and
"parse". If "template" is defined, then the template value is run through
dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere),
or if templateFunc is a function on the content, that function will be used to
transform the template into a final string to be used for for passing to dojo._toDom.
If content.parse is true, then it is remembered for later, for when the content
nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
(if dojo.parser has been dojo.required elsewhere).
Allows for cloning the nodes in the array, and for
optionally parsing widgets, if ary._runParse is true.
Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there
is no parent dojo.NodeList, an empty dojo.NodeList is returned.
dojo.query("a")
.filter(".disabled")
// operate on the anchors that only have a disabled class
.style("color", "grey")
.end()
// jump back to the list of anchors
.style(...)
This method behaves exactly like the Array.slice method
with the caveat that it returns a dojo.NodeList and not a
raw Array. For more details, see Mozilla's (slice
documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice]
Can be a positive or negative integer, with positive
integers noting the offset to begin at, and negative
integers denoting an offset from the end (i.e., to the left
of the end)
Optional parameter to describe what position relative to
the NodeList's zero index to end the slice at. Like begin,
can be positive or negative.
This method behaves exactly like the Array.splice method
with the caveat that it returns a dojo.NodeList and not a
raw Array. For more details, see Mozilla's (splice
documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice]
For backwards compatibility, calling .end() on the spliced NodeList
does not return the original NodeList -- splice alters the NodeList in place.
begin can be a positive or negative integer, with positive
integers noting the offset to begin at, and negative
integers denoting an offset from the end (i.e., to the left
of the end)
Optional parameter to describe what position relative to
the NodeList's zero index to end the slice at. Like begin,
can be positive or negative.
Any number of optional parameters may be passed in to be
spliced into the NodeList
dojo.NodeList
For more details on the behavior of indexOf, see Mozilla's
(indexOf
docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf]
The value to search for.
The location to start searching from. Optional. Defaults to 0.
Positive Integer or 0 for a match, -1 of not found.
For more details on the behavior of lastIndexOf, see
Mozilla's (lastIndexOf
docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf]
The value to search for.
The location to start searching from. Optional. Defaults to 0.
Positive Integer or 0 for a match, -1 of not found.
the callback
the context
the callback
the context
This method behaves exactly like the Array.concat method
with the caveat that it returns a `dojo.NodeList` and not a
raw Array. For more details, see the (Array.concat
docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat]
Any number of optional parameters may be passed in to be
spliced into the NodeList
dojo.NodeList
A String class name to add, or several space-separated class names,
or an array of class names.
An optional String class name to remove, or several space-separated
class names, or an array of class names. If omitted, all class names
will be deleted.
dojo.NodeList, this list
the CSS class to add
If passed, true means to add the class, false means to remove.
add an onclick handler to every button on the page
dojo.query("div:nth-child(odd)").connect("onclick", function(e){
console.log("clicked!");
});
attach foo.bar() to every odd div's onmouseover
dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
the name of the method to attach to. For DOM events, this should be
the lower-case name of the event
if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
reference a function or be the name of the function in the global
namespace to attach. If 3 arguments are provided
(methodName, objOrFunc, funcName), objOrFunc must be the scope to
locate the bound function in
optional. A string naming the function in objOrFunc to bind to the
event. May also be a function reference.
may be a string representing any valid CSS3 selector or a DOM node.
In the selector case, only the first matching element will be used
for relative positioning.
can be one of:
"last" (default)
"first"
"before"
"after"
"only"
"replace"
or an offset in the childNodes property
CSS selector like ".foo" or "div > span"
`dojo.NodeList` containing the orphaned elements
a DOM node or a query string or a query result.
Represents the nodes to be adopted relative to the
first element of this NodeList.
can be one of:
"last" (default)
"first"
"before"
"after"
"only"
"replace"
or an offset in the childNodes property
assume a DOM created by this markup:
<div id="foo">
<p>
bacon is tasty, <span>dontcha think?</span>
</p>
</div>
<div id="bar">
<p>great comedians may not be funny <span>in person</span></p>
</div>
If we are presented with the following definition for a NodeList:
var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar"));
it's possible to find all span elements under paragraphs
contained by these elements with this sub-query:
var spans = l.query("p span");
"regular" JS filter syntax as exposed in dojo.filter:
dojo.query("*").filter(function(item){
// highlight every paragraph
return (item.nodeName == "p");
}).style("backgroundColor", "yellow");
the same filtering using a CSS selector
dojo.query("*").filter("p").styles("backgroundColor", "yellow");
If a string, a CSS rule like ".thinger" or "div > span".
Grabs all buttons in the page and converts them to diji.form.Buttons.
var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true});
Shorten the list to the first, second, and third elements
dojo.query("a").at(0, 1, 2).forEach(fn);
Retrieve the first and last elements of a unordered list:
dojo.query("ul > li").at(0, -1).forEach(cb);
Do something for the first element only, but end() out back to
the original list and continue chaining:
dojo.query("a").at(0).onclick(fn).end().forEach(function(n){
console.log(n); // all anchors on the page.
})
One or more 0-based indices of items in the current
NodeList. A negative index will start at the end of the
list and go backwards.
dojo.NodeList
Sets up event handlers that can catch events on any subnodes matching a given selector,
including nodes created after delegate() has been called.
This allows an app to setup a single event handler on a high level node, rather than many
event handlers on subnodes. For example, one onclick handler for a Tree widget, rather than separate
handlers for each node in the tree.
Since setting up many event handlers is expensive, this can increase performance.
Note that delegate() will not work for events that don't bubble, like focus.
onmouseenter/onmouseleave also don't currently work.
dojo.query("navbar").delegate("a", "onclick", function(evt){
console.log("user clicked anchor ", this.node);
});
CSS selector valid to <code>dojo.query</code>, like ".foo" or "div > span". The
selector is relative to the nodes in this NodeList, not the document root.
For example myNodeList.delegate("> a", "onclick", ...) will catch events on
anchor nodes which are (immediate) children of the nodes in myNodeList.
Standard event name used as an argument to <code>dojo.connect</code>, like "onclick".
Callback function passed the event object, and where this == the node that matches the selector.
That means that for example, after setting up a handler via
dojo.query("body").delegate("fieldset", "onclick", ...)
clicking on a fieldset or *any nodes inside of a fieldset* will be reported
as a click on the fieldset itself.
The template string or location
The context object or location
// fade all elements with class "bar" to to 50% opacity
dojo.query(".bar").addClassFx("bar").play();
dojo.query(".box").removeClassFx("bar").play();
dojo.query(".box").toggleClass("bar").play();
// size all divs with class "blah"
dojo.query("div.blah").sizeTo({
width:50,
height:50
}).play();
// slide all tables with class "blah" 10 px
dojo.query("table.blah").slideBy({ top:10, left:10 }).play();
// highlight all links with class "foo"
dojo.query("a.foo").hightlight().play();
// fade all elements with class "bar" to to 50% opacity
dojo.query(".bar").fadeTo({ end: 0.5 }).play();
dojo.query(".box").wipeTo({ width: 300px }).play();
Get a named property on a Stateful object. The property may
potentially be retrieved via a getter method in subclasses. In the base class
this just retrieves the object's property.
For example:
stateful = new dojo.Stateful({foo: 3});
stateful.get("foo") // returns 3
stateful.foo // returns 3
The property to get.
Sets named properties on a stateful object and notifies any watchers of
the property. A programmatic setter may be defined in subclasses.
For example:
stateful = new dojo.Stateful();
stateful.watch(function(name, oldValue, value){
// this will be called on the set below
}
stateful.set(foo, 5);
set() may also be called with a hash of name/value pairs, ex:
myObj.set({
foo: "Howdy",
bar: 3
})
This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
The property to set.
The value to set in the property.
Indicates the property to watch. This is optional (the callback may be the
only parameter), and if omitted, all the properties will be watched
The function to execute when the property changes. This will be called after
the property has been changed. The callback will be called with the |this|
set to the instance, the first argument as the name of the property, the
second argument as the old value and the third argument as the new value.
An object handle for the watch. The unwatch method of this object
can be used to discontinue watching this property:
var watchHandle = obj.watch("foo", callback);
watchHandle.unwatch(); // callback won't be called now
var c = new dojo.Color(); // no color
c.setColor("#ededed"); // greyish
the default implementation does nothing, include dojo.colors to
augment it with real checks
var c = new dojo.Color("#000000");
console.log(c.toRgb()); // [0,0,0]
console.log(new dojo.Color([0,0,0]).toHex()); // #000000
var c = new dojo.Color("#FFF").toCss();
console.log(c); // rgb('255','255','255')
The dojo.Deferred API is based on the concept of promises that provide a
generic interface into the eventual completion of an asynchronous action.
The motivation for promises fundamentally is about creating a
separation of concerns that allows one to achieve the same type of
call patterns and logical data flow in asynchronous code as can be
achieved in synchronous code. Promises allows one
to be able to call a function purely with arguments needed for
execution, without conflating the call with concerns of whether it is
sync or async. One shouldn't need to alter a call's arguments if the
implementation switches from sync to async (or vice versa). By having
async functions return promises, the concerns of making the call are
separated from the concerns of asynchronous interaction (which are
handled by the promise).
The dojo.Deferred is a type of promise that provides methods for fulfilling the
promise with a successful result or an error. The most important method for
working with Dojo's promises is the then() method, which follows the
CommonJS proposed promise API. An example of using a Dojo promise:
var resultingPromise = someAsyncOperation.then(function(result){
... handle result ...
},
function(error){
... handle error ...
});
The .then() call returns a new promise that represents the result of the
execution of the callback. The callbacks will never affect the original promises value.
The dojo.Deferred instances also provide the following functions for backwards compatibility:
* addCallback(handler)
* addErrback(handler)
* callback(result)
* errback(result)
Callbacks are allowed to return promises themselves, so
you can build complicated sequences of events with ease.
The creator of the Deferred may specify a canceller. The canceller
is a function that will be called if Deferred.cancel is called
before the Deferred fires. You can use this to implement clean
aborting of an XMLHttpRequest, etc. Note that cancel will fire the
deferred with a CancelledError (unless your canceller returns
another kind of error), so the errbacks should be prepared to
handle that error for cancellable Deferreds.
This method is used inside method of classes produced with
dojo.declare to call a super method (next in the chain). It is
used for manually controlled chaining. Consider using the regular
chaining, because it is faster. Use "this.inherited()" only in
complex cases.
This method cannot me called from automatically chained
constructors including the case of a special (legacy)
constructor chaining. It cannot be called from chained methods.
If "this.inherited()" cannot find the next-in-chain method, it
does nothing and returns "undefined". The last method in chain
can be a default method implemented in Object, which will be
called last.
If "name" is specified, it is assumed that the method that
received "args" is the parent method for this call. It is looked
up in the chain list and if it is found the next-in-chain method
is called. If it is not found, the first-in-chain method is
called.
If "name" is not specified, it will be derived from the calling
method (using a methoid property "nom").
var B = dojo.declare(A, {
method1: function(a, b, c){
this.inherited(arguments);
},
method2: function(a, b){
return this.inherited(arguments, [a + b]);
}
});
// next method is not in the chain list because it is added
// manually after the class was created.
B.prototype.method3 = function(){
console.log("This is a dynamically-added method.");
this.inherited("method3", arguments);
};
var B = dojo.declare(A, {
method: function(a, b){
var super = this.inherited(arguments, true);
// ...
if(!super){
console.log("there is no super method");
return 0;
}
return super.apply(this, arguments);
}
});
The optional method name. Should be the same as the caller's
name. Usually "name" is specified in complex dynamic cases, when
the calling method was dynamically added, undecorated by
dojo.declare, and it cannot be determined.
The caller supply this argument, which should be the original
"arguments".
If "true", the found function will be returned without
executing it.
If Array, it will be used to call a super method. Otherwise
"args" will be used.
Whatever is returned by a super method, or a super method itself,
if "true" was specified as newArgs.
This method is a convenience method for "this.inherited()".
It uses the same algorithm but instead of executing a super
method, it returns it, or "undefined" if not found.
var B = dojo.declare(A, {
method: function(a, b){
var super = this.getInherited(arguments);
// ...
if(!super){
console.log("there is no super method");
return 0;
}
return super.apply(this, arguments);
}
});
The optional method name. Should be the same as the caller's
name. Usually "name" is specified in complex dynamic cases, when
the calling method was dynamically added, undecorated by
dojo.declare, and it cannot be determined.
The caller supply this argument, which should be the original
"arguments".
Returns a super method (Function) or "undefined".
This method is used with instances of classes produced with
dojo.declare to determine of they support a certain interface or
not. It models "instanceof" operator.
var A = dojo.declare(null, {
// constructor, properties, and methods go here
// ...
});
var B = dojo.declare(null, {
// constructor, properties, and methods go here
// ...
});
var C = dojo.declare([A, B], {
// constructor, properties, and methods go here
// ...
});
var D = dojo.declare(A, {
// constructor, properties, and methods go here
// ...
});
var a = new A(), b = new B(), c = new C(), d = new D();
console.log(a.isInstanceOf(A)); // true
console.log(b.isInstanceOf(A)); // false
console.log(c.isInstanceOf(A)); // true
console.log(d.isInstanceOf(A)); // true
console.log(a.isInstanceOf(B)); // false
console.log(b.isInstanceOf(B)); // true
console.log(c.isInstanceOf(B)); // true
console.log(d.isInstanceOf(B)); // false
console.log(a.isInstanceOf(C)); // false
console.log(b.isInstanceOf(C)); // false
console.log(c.isInstanceOf(C)); // true
console.log(d.isInstanceOf(C)); // false
console.log(a.isInstanceOf(D)); // false
console.log(b.isInstanceOf(D)); // false
console.log(c.isInstanceOf(D)); // false
console.log(d.isInstanceOf(D)); // true
Class constructor.
"true", if this object is inherited from this class, "false"
otherwise.
Adds source properties to the constructor's prototype. It can
override existing properties.
This method is similar to dojo.extend function, but it is specific
to constructors produced by dojo.declare. It is implemented
using dojo.safeMixin, and it skips a constructor property,
and properly decorates copied functions.
var A = dojo.declare(null, {
m1: function(){},
s1: "Popokatepetl"
});
A.extend({
m1: function(){},
m2: function(){},
f1: true,
d1: 42
});
Source object which properties are going to be copied to the
constructor's prototype.
a copy of the HTML content is added to each item in the
list, with an optional position argument. If no position
argument is provided, the content is appended to the end of
each item.
Each argument is evaluated in order relative to the next until
a canonical uri is produced. To get an absolute Uri relative to
the current document use:
new dojo._Url(document.baseURI, url)
DOM node to attach the event to
the name of the handler to remove the function from
the handle returned from add
Event object to examine
The button value (example: dojo.mouseButton.LEFT)
Event object to examine
Event object to examine
Event object to examine
Numeric value of the left mouse button for the platform.
Numeric value of the middle mouse button for the platform.
Numeric value of the right mouse button for the platform.
To use, simply require dojox.fx.ext-dojo.reverse and a reverse()
method will be added to all dojo.Animations.
It can be used at any time during the animation. It does not
need to be called when it ends. It also reverses the easing -
if dojo.fx.easing.quadIn is used, dojo.fx.easing.quadOut will
be used when animating backwards.
Convenience function. Fire event "evt" and pass it the
arguments specified in "args".
Fires the callback in the scope of the `dojo.Animation`
instance.
The event to fire.
The arguments to pass to the event.
How many milliseconds to delay before starting.
If true, starts the animation from the beginning; otherwise,
starts it from its current position.
dojo.Animation
The instance to allow chaining.
A percentage in decimal notation (between and including 0.0 and 1.0).
If true, play the animation after setting the progress.
If true, the animation will end.
The time in milliseonds the animation will take to run
A two element array of start and end values, or a <code>dojo._Line</code> instance to be
used in the Animation.
The number of times to loop the animation
the time in milliseconds to wait before advancing to next frame
(used as a fps timer: 1000/rate = fps)
The time in milliseconds to wait before starting animation after it
has been .play()'ed
Synthetic event fired before a dojo.Animation begins playing (synchronous)
Synthetic event fired as a dojo.Animation begins playing (useful?)
Synthetic event fired at each interval of a <code>dojo.Animation</code>
Synthetic event fired after the final frame of a <code>dojo.Animation</code>
Synthetic event fired any time a <code>dojo.Animation</code> is play()'ed
Synthetic event fired when a <code>dojo.Animation</code> is paused
Synthetic event fires when a <code>dojo.Animation</code> is stopped
a floating point number greater than 0 and less than 1
Beginning value for range
Ending value for range
The node referenced in the animation
Duration of the animation in milliseconds.
Acceptable values are: text (default), json, json-comment-optional,
json-comment-filtered, javascript, xml. See <code>dojo.contentHandlers</code>
false is default. Indicates whether the request should
be a synchronous (blocking) request.
Additional HTTP headers to send in the request.
false is default. Indicates whether a request should be
allowed to fail (and therefore no console error message in
the event of a failure)
A map of availble XHR transport handle types. Name matches the
`handleAs` attribute passed to XHR calls. Each contentHandler is
called, passing the xhr object for manipulation. The return value
from the contentHandler will be passed to the `load` or `handle`
functions defined in the original xhr call.
A contentHandler which expects comment-filtered JSON.
the json-comment-filtered option was implemented to prevent
"JavaScript Hijacking", but it is less secure than standard JSON. Use
standard JSON instead. JSON prefixing can be used to subvert hijacking.
Will throw a notice suggesting to use application/json mimetype, as
json-commenting can introduce security issues. To decrease the chances of hijacking,
use the standard `json` contentHandler, and prefix your "JSON" with: {}&&
use djConfig.useCommentedJson = true to turn off the notice
The response in the format as defined with handleAs.
Provides additional information about the request.
The response in the format as defined with handleAs.
Provides additional information about the request.
Provides a string that tells you whether this function
was called because of success (load) or failure (error).
The response in the format as defined with handleAs.
Provides additional information about the request.
URL to server endpoint.
Contains properties with string values. These
properties will be serialized as name1=value2 and
passed in the request.
Milliseconds to wait for the response. If this time
passes, the then error callbacks are called.
DOM node for a form. Used to extract the form values
and send to the server.
Default is false. If true, then a
"dojo.preventCache" parameter is sent in the request
with a value that changes with each request
(timestamp). Useful only with GET-type requests.
Acceptable values depend on the type of IO
transport (see specific IO calls for more information).
rawBody: String?
Sets the raw body for an HTTP request. If this is used, then the content
property is ignored. This is mostly useful for HTTP methods that have
a body to their requests, like PUT or POST. This property can be used instead
of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively.
Set this explicitly to false to prevent publishing of topics related to
IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
will be published via dojo.publish for different phases of an IO operation.
See dojo.__IoPublish for a list of topics that are published.
the original object argument to the IO call.
For XMLHttpRequest calls only, the
XMLHttpRequest object that was used for the
request.
The final URL used for the call. Many times it
will be different than the original args.url
value.
For non-GET requests, the
name1=value1&name2=value2 parameters sent up in
the request.
The final indicator on how the response will be
handled.
For dojo.io.script calls only, the internal
script ID used for the request.
For dojo.io.script calls only, indicates
whether the script tag that represents the
request can be deleted after callbacks have
been called. Used internally to know when
cleanup can happen on JSONP-type requests.
For dojo.io.script calls only: holds the JSON
response for JSONP-type requests. Used
internally to hold on to the JSON responses.
You should not need to access it directly --
the same object should be passed to the success
callbacks directly.
"/dojo/io/start" is sent when there are no outstanding IO
requests, and a new IO request is started. No arguments
are passed with this topic.
"/dojo/io/send" is sent whenever a new IO request is started.
It passes the dojo.Deferred for the request with the topic.
"/dojo/io/load" is sent whenever an IO request has loaded
successfully. It passes the response and the dojo.Deferred
for the request with the topic.
"/dojo/io/error" is sent whenever an IO request has errored.
It passes the error and the dojo.Deferred
for the request with the topic.
"/dojo/io/done" is sent whenever an IO request has completed,
either by loading or by erroring. It passes the error and
the dojo.Deferred for the request with the topic.
"/dojo/io/stop" is sent when all outstanding IO requests have
finished. No arguments are passed with this topic.
console.time("load");
console.time("myFunction");
console.timeEnd("load");
console.timeEnd("myFunction");
Only call this method before the page's DOM is finished loading. Otherwise
it will not work. Be careful with xdomain loading or djConfig.debugAtAllCosts scenarios,
in order for this method to work, dojo.back will need to be part of a build layer.
It is recommended that you call this method as part of an event
listener that is registered via dojo.addOnLoad().
See the addToHistory() function for the list of valid args properties.
To support getting back button notifications, the object
argument should implement a function called either "back",
"backButton", or "handle". The string "back" will be passed as
the first and only argument to this callback.
To support getting forward button notifications, the object
argument should implement a function called either "forward",
"forwardButton", or "handle". The string "forward" will be
passed as the first and only argument to this callback.
If you want the browser location string to change, define "changeUrl" on the object. If the
value of "changeUrl" is true, then a unique number will be appended to the URL as a fragment
identifier (http://some.domain.com/path#uniquenumber). If it is any other value that does
not evaluate to false, that value will be used as the fragment identifier. For example,
if changeUrl: 'page1', then the URL will look like: http://some.domain.com/path#page1
There are problems with using dojo.back with semantically-named fragment identifiers
("hash values" on an URL). In most browsers it will be hard for dojo.back to know
distinguish a back from a forward event in those cases. For back/forward support to
work best, the fragment ID should always be a unique value (something using new Date().getTime()
for example). If you want to detect hash changes using semantic fragment IDs, then
consider using dojo.hash instead (in Dojo 1.4+).
dojo.back.addToHistory({
back: function(){ console.log('back pressed'); },
forward: function(){ console.log('forward pressed'); },
changeUrl: true
});
A very simple, lightweight mechanism for applying code to
existing documents, based around `dojo.query` (CSS3 selectors) for node selection,
and a simple two-command API: `dojo.behavior.add()` and `dojo.behavior.apply()`;
Behaviors apply to a given page, and are registered following the syntax
options described by `dojo.behavior.add` to match nodes to actions, or "behaviors".
Added behaviors are applied to the current DOM when .apply() is called,
matching only new nodes found since .apply() was last called.
Add the specified behavior to the list of behaviors which will
be applied the next time apply() is called. Calls to add() for
an already existing behavior do not replace the previous rules,
but are instead additive. New nodes which match the rule will
have all add()-ed behaviors applied to them when matched.
The "found" method is a generalized handler that's called as soon
as the node matches the selector. Rules for values that follow also
apply to the "found" key.
The "on*" handlers are attached with `dojo.connect()`, using the
matching node
If the value corresponding to the ID key is a function and not a
list, it's treated as though it was the value of "found".
dojo.behavior.add() can be called any number of times before
the DOM is ready. `dojo.behavior.apply()` is called automatically
by `dojo.addOnLoad`, though can be called to re-apply previously added
behaviors anytime the DOM changes.
There are a variety of formats permitted in the behaviorObject
Simple list of properties. "found" is special. "Found" is assumed if
no property object for a given selector, and property is a function.
dojo.behavior.add({
"#id": {
"found": function(element){
// node match found
},
"onclick": function(evt){
// register onclick handler for found node
}
},
"#otherid": function(element){
// assumes "found" with this syntax
}
});
If property is a string, a dojo.publish will be issued on the channel:
dojo.behavior.add({
// dojo.publish() whenever class="noclick" found on anchors
"a.noclick": "/got/newAnchor",
"div.wrapper": {
"onclick": "/node/wasClicked"
}
});
dojo.subscribe("/got/newAnchor", function(node){
// handle node finding when dojo.behavior.apply() is called,
// provided a newly matched node is found.
});
Scoping can be accomplished by passing an object as a property to
a connection handle (on*):
dojo.behavior.add({
"#id": {
// like calling dojo.hitch(foo,"bar"). execute foo.bar() in scope of foo
"onmouseenter": { targetObj: foo, targetFunc: "bar" },
"onmouseleave": { targetObj: foo, targetFunc: "baz" }
}
});
Bahaviors match on CSS3 Selectors, powered by dojo.query. Example selectors:
dojo.behavior.add({
// match all direct descendants
"#id4 > *": function(element){
// ...
},
// match the first child node that's an element
"#id4 > :first-child": { ... },
// match the last child node that's an element
"#id4 > :last-child": { ... },
// all elements of type tagname
"tagname": {
// ...
},
"tagname1 tagname2 tagname3": {
// ...
},
".classname": {
// ...
},
"tagname.classname": {
// ...
}
});
Applies all currently registered behaviors to the document,
taking care to ensure that only incremental updates are made
since the last time add() or apply() were called.
If new matching nodes have been added, all rules in a behavior will be
applied to that node. For previously matched nodes, only
behaviors which have been added since the last call to apply()
will be added to the nodes.
apply() is called once automatically by `dojo.addOnLoad`, so
registering behaviors with `dojo.behavior.add` before the DOM is
ready is acceptable, provided the dojo.behavior module is ready.
Calling appy() manually after manipulating the DOM is required
to rescan the DOM and apply newly .add()ed behaviors, or to match
nodes that match existing behaviors when those nodes are added to
the DOM.
module and url are used to call `dojo.moduleUrl()` to generate a module URL.
If value is specified, the cache value for the moduleUrl will be set to
that value. Otherwise, dojo.cache will fetch the moduleUrl and store it
in its internal cache and return that cached value for the URL. To clear
a cache value pass null for value. Since XMLHttpRequest (XHR) is used to fetch the
the URL contents, only modules on the same domain of the page can use this capability.
The build system can inline the cache values though, to allow for xdomain hosting.
Copied from dijit._Templated._sanitizeTemplateString.
an [ISO 4217](http://en.wikipedia.org/wiki/ISO_4217) currency code
Returns a zero-based index for first day of the week, as used by the local (Gregorian) calendar.
e.g. Sunday (returns 0), or Monday (returns 1)
Returns a hash containing the start and end days of the weekend according to local custom using locale,
or by default in the user's locale.
e.g. {start:6, end:0}
If a number, the number of days from today at which the cookie
will expire. If a date, the date past which the cookie will expire.
If expires is in the past, the cookie will be deleted.
If expires is omitted or is 0, the cookie will expire when the browser closes. << FIXME: 0 seems to disappear right away? FF3.
The path to use for the cookie.
The domain to use for the cookie.
Whether to only send the cookie on secure connections
If one argument is passed, returns the value of the cookie
For two or more arguments, acts as a setter.
extends dojo.number to provide culturally-appropriate formatting of values
in various world currencies, including use of a currency symbol. The currencies are specified
by a three-letter international symbol in all uppercase, and support for the currencies is
provided by the data in `dojo.cldr`. The scripts generating dojo.cldr specify which
currency support is included. A fixed number of decimal places is determined based
on the currency type and is not determined by the 'pattern' argument. The fractional
portion is optional, by default, and variable length decimals are not supported.
Create a string from a Number using a known, localized pattern.
[Formatting patterns](http://www.unicode.org/reports/tr35/#Number_Elements)
appropriate to the locale are chosen from the [CLDR](http://unicode.org/cldr)
as well as the appropriate symbols and delimiters and number of decimal places.
the number to be formatted.
Returns regular expression with positive and negative match, group and decimal separators
Note: the options.places default, the number of decimal places to accept, is defined by the currency type.
Create a Number from a string using a known, localized pattern.
[Formatting patterns](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
are chosen appropriate to the locale, as well as the appropriate symbols and delimiters
and number of decimal places.
A string representation of a currency value
Should not be set. Value is assumed to be "currency".
localized currency symbol. The default will be looked up in table of supported currencies in <code>dojo.cldr</code>
A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found.
an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD".
For use with dojo.currency only.
number of decimal places to show. Default is defined based on which currency is used.
Should not be set. Value is assumed to be currency.
an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD".
For use with dojo.currency only.
localized currency symbol. The default will be looked up in table of supported currencies in <code>dojo.cldr</code>
A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found.
fixed number of decimal places to accept. The default is determined based on which currency is used.
Whether to include the fractional portion, where the number of decimal places are implied by the currency
or explicit 'places' parameter. The value [true,false] makes the fractional portion optional.
By default for currencies, it the fractional portion is optional.
typeMap: object)
The structure of the typeMap object is as follows:
{
type0: function || object,
type1: function || object,
...
typeN: function || object
}
Where if it is a function, it is assumed to be an object constructor that takes the
value of _value as the initialization parameters. If it is an object, then it is assumed
to be an object of general form:
{
type: function, //constructor.
deserialize: function(value) //The function that parses the value and constructs the object defined by type appropriately.
}
The item to test for being contained by the store.
The attribute to test for being contained by the store.
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
The query options parameter, if any.
|| keywordArgs || null
Function to parse the loaded data into item format and build the internal items array.
The JS data object containing the raw data to convery into item format.
array
Array of items in store item format.
Method to add an reference map entry for an item and attribute. //
The item that is referenced.
The item that holds the new reference to refItem.
The attribute on parentItem that contains the new reference.
typeMap: object)
The structure of the typeMap object is as follows:
{
type0: function || object,
type1: function || object,
...
typeN: function || object
}
Where if it is a function, it is assumed to be an object constructor that takes the
value of _value as the initialization parameters. It is serialized assuming object.toString()
serialization. If it is an object, then it is assumed
to be an object of general form:
{
type: function, //constructor.
deserialize: function(value) //The function that parses the value and constructs the object defined by type appropriately.
serialize: function(object) //The function that converts the object back into the proper file format form.
}
anything
Method to add an reference map entry for an item and attribute. //
The item that is referenced.
The item that holds the new reference to refItem.
The attribute on parentItem that contains the new reference.
Method to remove an reference map entry for an item and attribute. This will
also perform cleanup on the map such that if there are no more references at all to
the item, its reference object and entry are removed.
The item that is referenced.
The item holding a reference to refItem.
The attribute on parentItem that contains the reference.
Function to dump the reverse reference map of all items in the store for debug purposes.
array or object to examine.
| array
| array
Over-ride of base close function of ItemFileReadStore to add in check for store state.
If the store is still dirty (unsaved changes), then an error will be thrown instead of
clearing the internal state for reload from the url.
configuration information to pass into the data store.
options.objectStore:
The object store to use as the source provider for this data store
The item to get the value from
property to look up value for
the default value
property to look up value for
attribute: /* string
store.loadItem({
item: item, // this item may or may not be loaded
onItem: function(item){
// do something with the item
}
});
The data to be added in as an item.
to delete
var itemId = store.getIdentity(kermit);
assert(kermit === store.findByIdentity(store.getIdentity(kermit)));
The item from the store from which to obtain its identifier.
var itemId = store.getIdentity(kermit);
var identifiers = store.getIdentityAttributes(itemId);
assert(typeof identifiers === "array" || identifiers === null);
The item from the store from which to obtain the array of public attributes that
compose the identifier, if any.
An anonymous object that defines the item to locate and callbacks to invoke when the
item has been located and load has completed. The format of the object is as follows:
{
identity: string|object,
onItem: Function,
onError: Function,
scope: object
}
The *identity* parameter.
The identity parameter is the identity of the item you wish to locate and load
This attribute is required. It should be a string or an object that toString()
can be called on.
The *onItem* parameter.
Function(item)
The onItem parameter is the callback to invoke when the item has been loaded. It takes only one
parameter, the item located, or null if none found.
The *onError* parameter.
Function(error)
The onError parameter is the callback to invoke when the item load encountered an error. It takes only one
parameter, the error object
The *scope* parameter.
If a scope object is provided, all of the callback functions (onItem,
onError, etc) will be invoked in the context of the scope object.
In the body of the callback function, the value of the "this"
keyword will be the scope object. If no scope object is provided,
the callback functions will be called in the context of dojo.global.
For example, onItem.call(scope, item, request) vs.
onItem.call(dojo.global, item, request)
This API defines a set of APIs that all datastores that conform to the
Notifications API must implement. In general, most stores will implement
these APIs as no-op functions for users who wish to monitor them to be able
to connect to then via dojo.connect(). For non-users of dojo.connect,
they should be able to just replace the function on the store to obtain
notifications. Both read-only and read-write stores may implement
this feature. In the case of a read-only store, this feature makes sense if
the store itself does internal polling to a back-end server and periodically updates
its cache of items (deletes, adds, and updates).
This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.
Its purpose is to provide a hook point for those who wish to monitor actions on items in the store
in a simple manner. The general expected usage is to dojo.connect() to the store's
implementation and be called after the store function is called.
The item being modified.
The attribute being changed represented as a string name.
The old value of the attribute. In the case of single value calls, such as setValue, unsetAttribute, etc,
this value will be generally be an atomic value of some sort (string, int, etc, object). In the case of
multi-valued attributes, it will be an array.
The new value of the attribute. In the case of single value calls, such as setValue, this value will be
generally be an atomic value of some sort (string, int, etc, object). In the case of multi-valued attributes,
it will be an array. In the case of unsetAttribute, the new value will be 'undefined'.
Nothing.
This function is called any time a new item is created in the store.
It is called immediately after the store newItem processing has completed.
The item created.
An optional javascript object that is passed when the item created was placed in the store
hierarchy as a value f another item's attribute, instead of a root level item. Note that if this
function is invoked with a value for parentInfo, then onSet is not invoked stating the attribute of
the parent item was modified. This is to avoid getting two notification events occurring when a new item
with a parent is created. The structure passed in is as follows:
{
item: someItem, //The parent item
attribute: "attribute-name-string", //The attribute the new item was assigned to.
oldValue: something //Whatever was the previous value for the attribute.
//If it is a single-value attribute only, then this value will be a single value.
//If it was a multi-valued attribute, then this will be an array of all the values minues the new one.
newValue: something //The new value of the attribute. In the case of single value calls, such as setValue, this value will be
//generally be an atomic value of some sort (string, int, etc, object). In the case of multi-valued attributes,
//it will be an array.
}
Nothing.
This function is called any time an item is deleted from the store.
It is called immediately after the store deleteItem processing has completed.
The item deleted.
Nothing.
Saying that an "item x does not have a value for an attribute y"
is identical to saying that an "item x does not have attribute y".
It is an oxymoron to say "that attribute is present but has no values"
or "the item has that attribute but does not have any attribute values".
If store.hasAttribute(item, attribute) returns false, then
store.getValue(item, attribute) will return undefined.
var darthVader = store.getValue(lukeSkywalker, "father");
The item to access values on.
The attribute to access represented as a string.
Optional. A default value to use for the getValue return in the attribute does not exist or has no value.
var friendsOfLuke = store.getValues(lukeSkywalker, "friends");
The item to access values on.
The attribute to access represented as a string.
var array = store.getAttributes(kermit);
The item to access attributes on.
var trueOrFalse = store.hasAttribute(kermit, "color");
The item to access attributes on.
The attribute to access represented as a string.
var trueOrFalse = store.containsValue(kermit, "color", "green");
The item to access values on.
The attribute to access represented as a string.
The value to match as a value for the attribute.
var yes = store.isItem(store.newItem());
var no = store.isItem("green");
Can be anything.
var yes = store.isItemLoaded(store.newItem());
var no = store.isItemLoaded("green");
Can be anything.
An anonymous object that defines the item to load and callbacks to invoke when the
load has completed. The format of the object is as follows:
{
item: object,
onItem: Function,
onError: Function,
scope: object
}
The *item* parameter.
The item parameter is an object that represents the item in question that should be
contained by the store. This attribute is required.
A Request object will always be returned and is returned immediately.
The basic request is nothing more than the keyword args passed to fetch and
an additional function attached, abort(). The returned request object may then be used
to cancel a fetch. All data items returns are passed through the callbacks defined in the
fetch parameters and are not present on the 'request' object.
This does not mean that custom stores can not add methods and properties to the request object
returned, only that the API does not require it. For more info about the Request API,
see dojo.data.api.Request
Fetch all books identified by the query and call 'showBooks' when complete
var request = store.fetch({query:"all books", onComplete: showBooks});
Fetch all items in the story and call 'showEverything' when complete.
var request = store.fetch(onComplete: showEverything);
Fetch only 10 books that match the query 'all books', starting at the fifth book found during the search.
This demonstrates how paging can be done for specific queries.
var request = store.fetch({query:"all books", start: 4, count: 10, onComplete: showBooks});
Fetch all items that match the query, calling 'callback' each time an item is located.
var request = store.fetch({query:"foo/bar", onItem:callback});
Fetch the first 100 books by author King, call showKing when up to 100 items have been located.
var request = store.fetch({query:{author:"King"}, start: 0, count:100, onComplete: showKing});
Locate the books written by Author King, sort it on title and publisher, then return the first 100 items from the sorted items.
var request = store.fetch({query:{author:"King"}, sort: [{ attribute: "title", descending: true}, {attribute: "publisher"}], ,start: 0, count:100, onComplete: 'showKing'});
Fetch the first 100 books by authors starting with the name King, then call showKing when up to 100 items have been located.
var request = store.fetch({query:{author:"King*"}, start: 0, count:100, onComplete: showKing});
Fetch the first 100 books by authors ending with 'ing', but only have one character before it (King, Bing, Ling, Sing, etc.), then call showBooks when up to 100 items have been located.
var request = store.fetch({query:{author:"?ing"}, start: 0, count:100, onComplete: showBooks});
Fetch the first 100 books by author King, where the name may appear as King, king, KING, kInG, and so on, then call showKing when up to 100 items have been located.
var request = store.fetch({query:{author:"King"}, queryOptions:(ignoreCase: true}, start: 0, count:100, onComplete: showKing});
Paging
var store = new dojo.data.LargeRdbmsStore({url:"jdbc:odbc:foobar"});
var fetchArgs = {
query: {type:"employees", name:"Hillary *"}, // string matching
sort: [{attribute:"department", descending:true}],
start: 0,
count: 20,
scope: displayer,
onBegin: showThrobber,
onItem: displayItem,
onComplete: stopThrobber,
onError: handleFetchError,
};
store.fetch(fetchArgs);
...
and then when the user presses the "Next Page" button...
fetchArgs.start += 20;
store.fetch(fetchArgs); // get the next 20 items
The keywordArgs parameter may either be an instance of
conforming to dojo.data.api.Request or may be a simple anonymous object
that may contain any of the following:
{
query: query-object or query-string,
queryOptions: object,
onBegin: Function,
onItem: Function,
onComplete: Function,
onError: Function,
scope: object,
start: int
count: int
sort: array
}
All implementations should accept keywordArgs objects with any of
the 9 standard properties: query, onBegin, onItem, onComplete, onError
scope, sort, start, and count. Some implementations may accept additional
properties in the keywordArgs object as valid parameters, such as
{includeOutliers:true}.
The *query* parameter.
The query may be optional in some data store implementations.
The dojo.data.api.Read API does not specify the syntax or semantics
of the query itself -- each different data store implementation
may have its own notion of what a query should look like.
However, as of dojo 0.9, 1.0, and 1.1, all the provided datastores in dojo.data
and dojox.data support an object structure query, where the object is a set of
name/value parameters such as { attrFoo: valueBar, attrFoo1: valueBar1}. Most of the
dijit widgets, such as ComboBox assume this to be the case when working with a datastore
when they dynamically update the query. Therefore, for maximum compatibility with dijit
widgets the recommended query parameter is a key/value object. That does not mean that the
the datastore may not take alternative query forms, such as a simple string, a Date, a number,
or a mix of such. Ultimately, The dojo.data.api.Read API is agnostic about what the query
format.
Further note: In general for query objects that accept strings as attribute
value matches, the store should also support basic filtering capability, such as *
(match any character) and ? (match single character). An example query that is a query object
would be like: { attrFoo: "value*"}. Which generally means match all items where they have
an attribute named attrFoo, with a value that starts with 'value'.
The *queryOptions* parameter
The queryOptions parameter is an optional parameter used to specify optiosn that may modify
the query in some fashion, such as doing a case insensitive search, or doing a deep search
where all items in a hierarchical representation of data are scanned instead of just the root
items. It currently defines two options that all datastores should attempt to honor if possible:
{
ignoreCase: boolean, //Whether or not the query should match case sensitively or not. Default behaviour is false.
deep: boolean //Whether or not a fetch should do a deep search of items and all child
//items instead of just root-level items in a datastore. Default is false.
}
The *onBegin* parameter.
function(size, request);
If an onBegin callback function is provided, the callback function
will be called just once, before the first onItem callback is called.
The onBegin callback function will be passed two arguments, the
the total number of items identified and the Request object. If the total number is
unknown, then size will be -1. Note that size is not necessarily the size of the
collection of items returned from the query, as the request may have specified to return only a
subset of the total set of items through the use of the start and count parameters.
The *onItem* parameter.
function(item, request);
If an onItem callback function is provided, the callback function
will be called as each item in the result is received. The callback
function will be passed two arguments: the item itself, and the
Request object.
The *onComplete* parameter.
function(items, request);
If an onComplete callback function is provided, the callback function
will be called just once, after the last onItem callback is called.
Note that if the onItem callback is not present, then onComplete will be passed
an array containing all items which matched the query and the request object.
If the onItem callback is present, then onComplete is called as:
onComplete(null, request).
The *onError* parameter.
function(errorData, request);
If an onError callback function is provided, the callback function
will be called if there is any sort of error while attempting to
execute the query.
The onError callback function will be passed two arguments:
an Error object and the Request object.
The *scope* parameter.
If a scope object is provided, all of the callback functions (onItem,
onComplete, onError, etc) will be invoked in the context of the scope
object. In the body of the callback function, the value of the "this"
keyword will be the scope object. If no scope object is provided,
the callback functions will be called in the context of dojo.global().
For example, onItem.call(scope, item, request) vs.
onItem.call(dojo.global(), item, request)
The *start* parameter.
If a start parameter is specified, this is a indication to the datastore to
only start returning items once the start number of items have been located and
skipped. When this parameter is paired withh 'count', the store should be able
to page across queries with millions of hits by only returning subsets of the
hits for each query
The *count* parameter.
If a count parameter is specified, this is a indication to the datastore to
only return up to that many items. This allows a fetch call that may have
millions of item matches to be paired down to something reasonable.
The *sort* parameter.
If a sort parameter is specified, this is a indication to the datastore to
sort the items in some manner before returning the items. The array is an array of
javascript objects that must conform to the following format to be applied to the
fetching of items:
{
attribute: attribute || attribute-name-string,
descending: true|false; // Optional. Default is false.
}
Note that when comparing attributes, if an item contains no value for the attribute
(undefined), then it the default ascending sort logic should push it to the bottom
of the list. In the descending order case, it such items should appear at the top of the list.
The fetch() method will return a javascript object conforming to the API
defined in dojo.data.api.Request. In general, it will be the keywordArgs
object returned with the required functions in Request.js attached.
Its general purpose is to provide a convenient way for a caller to abort an
ongoing fetch.
The Request object may also have additional properties when it is returned
such as request.store property, which is a pointer to the datastore object that
fetch() is a method of.
The close() method is intended for instructing the store to 'close' out
any information associated with a particular request. In general, this API
expects to recieve as a parameter a request object returned from a fetch.
It will then close out anything associated with that request, such as
clearing any internal datastore caches and closing any 'open' connections.
For some store implementations, this call may be a no-op.
var request = store.fetch({onComplete: doSomething});
...
store.close(request);
An instance of a request for the store to use to identify what to close out.
If no request is passed, then the store should clear all internal caches (if any)
and close out all 'open' connections. It does not render the store unusable from
there on, it merely cleans out any current data and resets the store to initial
state.
Method to inspect the item and return a user-readable 'label' for the item
that provides a general/adequate description of what the item is. In general
most labels will be a specific attribute value or collection of the attribute
values that combine to label the item in some manner. For example for an item
that represents a person it may return the label as: "firstname lastlame" where
the firstname and lastname are attributes on the item. If the store is unable
to determine an adequate human readable label, it should return undefined. Users that wish
to customize how a store instance labels items should replace the getLabel() function on
their instance of the store, or extend the store and replace the function in
the extension class.
The item to return the label for.
A user-readable string representing the item or undefined if no user-readable label can
be generated.
Method to inspect the item and return an array of what attributes of the item were used
to generate its label, if any. This function is to assist UI developers in knowing what
attributes can be ignored out of the attributes an item has when displaying it, in cases
where the UI is using the label as an overall identifer should they wish to hide
redundant information.
The item to return the list of label attributes for.
An array of attribute names that were used to generate the label, or null if public attributes
were not used to generate the label.
This function is a hook point for stores to provide as a way for
a fetch to be halted mid-processing. For more details on the fetch() api,
please see dojo.data.api.Read.fetch().
var kermit = store.newItem({name: "Kermit", color:[blue, green]});
A javascript object defining the initial content of the item as a set of JavaScript 'property name: value' pairs.
An optional javascript object defining what item is the parent of this item (in a hierarchical store. Not all stores do hierarchical items),
and what attribute of that parent to assign the new item to. If this is present, and the attribute specified
is a multi-valued attribute, it will append this item into the array of values for that attribute. The structure
of the object is as follows:
{
parent: someItem,
attribute: "attribute-name-string"
}
var success = store.deleteItem(kermit);
The item to delete.
var success = store.set(kermit, "color", "green");
The item to modify.
The attribute of the item to change represented as a string name.
The value to assign to the item.
var success = store.setValues(kermit, "color", ["green", "aqua"]);
success = store.setValues(kermit, "color", []);
if (success) {assert(!store.hasAttribute(kermit, "color"));}
The item to modify.
The attribute of the item to change represented as a string name.
An array of values to assign to the attribute..
var success = store.unsetAttribute(kermit, "color");
if (success) {assert(!store.hasAttribute(kermit, "color"));}
The item to modify.
The attribute of the item to unset represented as a string.
store.save({onComplete: onSave});
store.save({scope: fooObj, onComplete: onSave, onError: saveFailed});
{ onComplete: function
onError: function
scope: object
}
The *onComplete* parameter.
function();
If an onComplete callback function is provided, the callback function
will be called just once, after the save has completed. No parameters
are generally passed to the onComplete.
The *onError* parameter.
function(errorData);
If an onError callback function is provided, the callback function
will be called if there is any sort of error while attempting to
execute the save. The onError function will be based one parameter, the
error.
The *scope* parameter.
If a scope object is provided, all of the callback function (
onComplete, onError, etc) will be invoked in the context of the scope
object. In the body of the callback function, the value of the "this"
keyword will be the scope object. If no scope object is provided,
the callback functions will be called in the context of dojo.global.
For example, onComplete.call(scope) vs.
onComplete.call(dojo.global)
Nothing. Since the saves are generally asynchronous, there is
no need to return anything. All results are passed via callbacks.
Discards any unsaved changes.
var success = store.revert();
var trueOrFalse = store.isDirty(kermit); // true if kermit is dirty
var trueOrFalse = store.isDirty(); // true if any item is dirty
The item to check.
Returns a regular expression object that conforms to the defined conversion rules.
For example:
ca* -> /^ca.*$/
*ca* -> /^.*ca.*$/
*c\*a* -> /^.*c\*a.*$/
*c\*a?* -> /^.*c\*a..*$/
and so on.
string A simple matching pattern to convert that follows basic rules:
* Means match anything, so ca* means match anything starting with ca
? Means match single character. So, b?b will match to bob and bab, and so on.
\ is an escape character. So for example, \* means do not treat * as a match, but literal character *.
To use a \ as a character in the string, it must be escaped. So in the pattern it should be
represented by \\ to be treated as an ordinary \ character instead of an escape.
An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing
By default, it is assumed case sensitive.
returns 1 if a > b, -1 if a < b, 0 if equal.
'null' values (null, undefined) are treated as larger values so that they're pushed to the end of the list.
And compared to each other, null is equivalent to undefined.
The sort function creation will look for a property on the store called 'comparatorMap'. If it exists
it will look in the mapping for comparisons function for the attributes. If one is found, it will
use it instead of the basic comparator, which is typically used for strings, ints, booleans, and dates.
Returns the sorting function for this particular list of attributes and sorting directions.
array A JS object that array that defines out what attribute names to sort on and whether it should be descenting or asending.
The objects should be formatted as follows:
{
attribute: "attributeName-string" || attribute,
descending: true|false; // Default is false.
}
object The datastore object to look up item values from.
the date and/or time being formatted.
Whether to return the timezone string (if true), or the offset (if false)
The options being used for formatting
Create a string from a Date object using a known localized pattern.
By default, this method formats both date and time from dateObject.
Formatting patterns are chosen appropriate to the locale. Different
formatting lengths may be chosen, with "full" used by default.
Custom patterns may be used or registered with translations using
the dojo.date.locale.addCustomFormats method.
Formatting patterns are implemented using [the syntax described at
unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)
the date and/or time to be formatted. If a time only is formatted,
the values in the year, month, and day fields are irrelevant. The
opposite is true when formatting only dates.
Create a Date object from a string using a known localized pattern.
By default, this method parses looking for both date and time in the string.
Formatting patterns are chosen appropriate to the locale. Different
formatting lengths may be chosen, with "full" used by default.
Custom patterns may be used or registered with translations using
the dojo.date.locale.addCustomFormats method.
Formatting patterns are implemented using [the syntax described at
unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)
When two digit years are used, a century is chosen according to a sliding
window of 80 years before and 20 years after present year, for both `yy` and `yyyy` patterns.
year < 100CE requires strict mode.
A string representation of a date
The user may add custom localized formats where the bundle has properties following the
same naming convention used by dojo.cldr: `dateFormat-xxxx` / `timeFormat-xxxx`
The pattern string should match the format used by the CLDR.
See dojo.date.locale.format() for details.
The resources must be loaded by dojo.requireLocalization() prior to use
'months' || 'days'
'wide' || 'narrow' || 'abbr' (e.g. "Monday", "Mon", or "M" respectively, in English)
'standAlone' || 'format' (default)
override locale used to find the names
choice of 'time','date' (default: date and time)
choice of long, short, medium or full (plus any custom additions). Defaults to 'short'
override pattern with this string
override pattern with this string
override strings for am in times
override strings for pm in times
override the locale used to determine formatting rules
(format only) use 4 digit years whenever 2 digit years are called for
(parse only) strict parsing, off by default
Leap years are years with an additional day YYYY-02-29, where the
year number is a multiple of four with the following exception: If
a year is a multiple of 100, then it is only a leap year if it is
also a multiple of 400. For example, 1900 was not a leap year, but
2000 is one.
Try to get time zone info from toString or toLocaleString method of
the Date object -- UTC offset is not a time zone. See
http://www.twinsun.com/tz/tz-link.htm Note: results may be
inconsistent across browsers.
Needed because the timezone may vary with time (daylight savings)
Returns 0 if equal, positive if a > b, else negative.
object
object. If not specified, the current Date is used.
A string indicating the "date" or "time" portion of a Date object.
Compares both "date" and "time" by default. One of the following:
"date", "time", "datetime"
Date object to start with
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "quarter", "week", "weekday"
How much to add to the date.
object
object. If not specified, the current Date is used.
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "quarter", "week", "weekday"
Defaults to "day".
Accepts a string formatted according to a profile of ISO8601 as defined by
[RFC3339](http://www.ietf.org/rfc/rfc3339.txt), except that partial input is allowed.
Can also process dates as specified [by the W3C](http://www.w3.org/TR/NOTE-datetime)
The following combinations are valid:
* dates only
* yyyy
* yyyy-MM
* yyyy-MM-dd
* times only, with an optional time zone appended
* THH:mm
* THH:mm:ss
* THH:mm:ss.SSS
* and "datetimes" which could be any combination of the above
timezones may be specified as Z (for UTC) or +/- followed by a time expression HH:mm
Assumes the local time zone if not specified. Does not validate. Improperly formatted
input may return null. Arguments which are out of bounds will be handled
by the Date constructor (e.g. January 32nd typically gets resolved to February 1st)
Only years between 100 and 9999 are supported.
A string such as 2005-06-30T08:05:00-07:00 or 2005-06-30 or T08:05:00
Used for defaults for fields omitted in the formattedString.
Uses 1970-01-01T00:00:00.0Z by default.
When options.selector is omitted, output follows [RFC3339](http://www.ietf.org/rfc/rfc3339.txt)
The local time zone is included as an offset from GMT, except when selector=='time' (time without a date)
Does not check bounds. Only years between 100 and 9999 are supported.
A Date object
"date" or "time" for partial formatting of the Date object.
Both date and time will be formatted by default.
if true, UTC/GMT is used for a timezone
if true, output milliseconds
a tag name or empty for SPAN
a text for TD
a text for SPAN
a container node
onmousemove event
onmousemove event
don't start the drag operation, if clicked on form elements
node or node's id to use as the parent node for dropped items
(must be underneath the 'node' parameter in the DOM)
skip startup(), which collects children, for deferred initialization
(this is used in the markup mode)
node or node's id to build the container on
a dictionary of parameters
a list of data items, which should be processed by the creator function
insert before the anchor, if true, and after the anchor otherwise
the anchor node to be used as a point of insertion
mouse event
mouse event
mouse event
a name of the state to change
new state
a node
a variable suffix for a class name
a node
a variable suffix for a class name
a mouse event
The DOM node the mouse is currently hovered over
dojo.dnd.Item>
Map from an item's id (which is also the DOMNode's id) to
the dojo.dnd.Item itself.
creator function, dummy at the moment
node or node's id to build the container on
params: dojo.dnd.__ContainerArgs
a dictionary of parameters
Type(s) of this item, by default this is ["text"]
Logical representation of the object being dragged.
If the drag object's type is "text" then data is a String,
if it's another type then data could be a different Object,
perhaps a name/value hash.
the reporter
the reporter
the source which provides items
the list of transferred items
copy items, if true, move items otherwise
mouse event
mouse event
keyboard event
keyboard event
the copy status
A node (or node's id), which is used as a mouse handle.
If omitted, the node itself is used as a handle.
delay move by this number of pixels
skip move of form elements
a constructor of custom Mover
a node (or node's id) to be moved
optional parameters
mouse/touch event
mouse/touch event
mouse event
mouse event
a node (or node's id) to be moved
params: dojo.dnd.__MoveableArgs?
optional parameters
a node (or node's id) to be moved
a mouse event, which started the move;
only pageX and pageY properties are used
object which implements the functionality of the move,
and defines proper events (onMoveStart and onMoveStop)
mouse/touch event
object which implements the functionality of the move,
and defines proper events (onMoveStart and onMoveStop)
allows selection of only one element, if true
autosynchronizes the source with its list of DnD nodes,
node or node's id to build the selector on
a dictionary of parameters
all new nodes will be added to selected items, if true, no selection change otherwise
a list of data items, which should be processed by the creator function
insert before the anchor, if true, and after the anchor otherwise
the anchor node to be used as a point of insertion
mouse event
mouse event
mouse event
The set of id's that are currently selected, such that this.selection[id] == 1
if the node w/that id is selected. Can iterate over selected node's id's like:
for(var id in this.selection)
node or node's id to build the source on
any property of this class may be configured via the params
object which is mixed-in to the <code>dojo.dnd.Source</code> instance
the source which provides items
the list of transferred items
the "copy" key was pressed
optional flag that means that we are about to drop on itself
mouse event
mouse event
mouse event
the source which has the mouse over it
the source which provides items
the list of transferred items
copy items, if true, move items otherwise
the source which provides items
the list of transferred items
copy items, if true, move items otherwise
the target which accepts items
the source which provides items
the list of transferred items
copy items, if true, move items otherwise
the source which provides items
the list of transferred items
copy items, if true, move items otherwise
the list of transferred items
copy items, if true, move items otherwise
insert before, if true, after otherwise
mouse event
can be used as a DnD source. Defaults to true.
list of accepted types (text strings) for a target; defaults to
["text"]
if true refreshes the node list on every operation; false by default
copy items, if true, use a state of Ctrl key otherwise,
see selfCopy and selfAccept for more details
the move delay in pixels before detecting a drag; 0 by default
a horizontal container, if true, vertical otherwise or when omitted
copy items by default when dropping on itself,
false by default, works only if copyOnly is true
accept its own items when copyOnly is true,
true by default, works only if copyOnly is true
allows dragging only by handles, false by default
generate text node for drag and drop, true by default
delay move by this number of ms,
accumulating position changes during the timeout
a node (or node's id) to be moved
object with additional parameters.
restrict move within boundaries.
a node (or node's id) to be moved
an optional object with additional parameters;
the rest is passed to the base class
a constraint box
a node (or node's id) to be moved
an optional object with parameters
attributes (for markup)
A parent's area to restrict the move.
Can be "margin", "border", "padding", or "content".
a node (or node's id) to be moved
an optional object with parameters
attributes (for markup)
Return a `dojo.Animation` which will play all passed
`dojo.Animation` instances in sequence, firing its own
synthesized events simulating a single animation. (eg:
onEnd of this animation means the end of the chain,
not the individual animations within)
Once `node` is faded out, fade in `otherNode`
dojo.fx.chain([
dojo.fadeIn({ node:node }),
dojo.fadeOut({ node:otherNode })
]).play();
Combine an array of `dojo.Animation`s to run in parallel,
providing a new `dojo.Animation` instance encompasing each
animation, firing standard animation events.
Fade out `node` while fading in `otherNode` simultaneously
dojo.fx.combine([
dojo.fadeIn({ node:node }),
dojo.fadeOut({ node:otherNode })
]).play();
When the longest animation ends, execute a function:
var anim = dojo.fx.combine([
dojo.fadeIn({ node: n, duration:700 }),
dojo.fadeOut({ node: otherNode, duration: 300 })
]);
dojo.connect(anim, "onEnd", function(){
// overall animation is done.
});
anim.play(); // play the animation
Returns an animation that will expand the
node defined in 'args' object from it's current height to
it's natural height (with no scrollbar).
Node must have no margin/border/padding.
dojo.fx.wipeIn({
node:"someId"
}).play()
A hash-map of standard <code>dojo.Animation</code> constructor properties
(such as easing: node: duration: and so on)
Returns an animation that will shrink node defined in "args"
from it's current height to 1px, and then hide it.
dojo.fx.wipeOut({ node:"someId" }).play()
A hash-map of standard <code>dojo.Animation</code> constructor properties
(such as easing: node: duration: and so on)
Returns an animation that will slide "node"
defined in args Object from its current position to
the position defined by (args.left, args.top).
dojo.fx.slideTo({ node: node, left:"40", top:"50", units:"px" }).play()
A hash-map of standard <code>dojo.Animation</code> constructor properties
(such as easing: node: duration: and so on). Special args members
are <code>top</code> and <code>left</code>, which indicate the new position to slide to.
class constructor for an animation toggler. It accepts a packed
set of arguments about what type of animation to use in each
direction, duration, etc. All available members are mixed into
these animations from the constructor (for example, `node`,
`showDuration`, `hideDuration`).
Ammount of time to stall playing the show animation
Ammount of time to stall playing the hide animation
the node to target for the showing and hiding animations
in milliseconds to run the show Animation
in milliseconds to run the hide Animation
Easing functions are used to manipulate the iteration through
an `dojo.Animation`s _Line. _Line being the properties of an Animation,
and the easing function progresses through that Line determing
how quickly (or slowly) it should go. Or more accurately: modify
the value of the _Line based on the percentage of animation completed.
All functions follow a simple naming convention of "ease type" + "when".
If the name of the function ends in Out, the easing described appears
towards the end of the animation. "In" means during the beginning,
and InOut means both ranges of the Animation will applied, both
beginning and end.
One does not call the easing function directly, it must be passed to
the `easing` property of an animation.
An easing function that pops past the range briefly, and slowly comes back.
Use caution when the easing will cause values to become negative as some
properties cannot be set to negative values.
An easing function combining the effects of `backIn` and `backOut`.
Use caution when the easing will cause values to become negative
as some properties cannot be set to negative values.
An easing function the elastically snaps from the start value
Use caution when the elasticity will cause values to become negative
as some properties cannot be set to negative values.
An easing function that elasticly snaps around the target value,
near the end of the Animation
Use caution when the elasticity will cause values to become
negative as some properties cannot be set to negative values.
An easing function that elasticly snaps around the value, near
the beginning and end of the Animation.
Use caution when the elasticity will cause values to become
negative as some properties cannot be set to negative values.
True if client is using Google Gears
An html string for insertion into the dom
the parent element
the parent element
content:
the content to be set on the parent element.
This can be an html string, a node reference or a NodeList, dojo.NodeList, Array or other enumerable list of nodes
Unless you need to use the params capabilities of this method, you should use
dojo.place(cont, node, "only"). dojo.place() has more robust support for injecting
an HTML string into the DOM, but it only handles inserting an HTML string as DOM
elements, or inserting a DOM node. dojo.place does not handle NodeList insertions
or the other capabilities as defined by the params object for this method.
A safe string/node/nodelist content replacement/injection with hooks for extension
Example Usage:
dojo.html.set(node, "some string");
dojo.html.set(node, contentNode, {options});
dojo.html.set(node, myNode.childNodes, {options});
the parent element that will receive the content
the content to be set on the parent element.
This can be an html string, a node reference or a NodeList, dojo.NodeList, Array or other enumerable list of nodes
Optional flags/properties to configure the content-setting. See dojo.html._ContentSetter
An html string, node or enumerable list of nodes for insertion into the dom
If not provided, the object's content property will be used
An node which will be the parent element that we set content into
The content to be placed in the node. Can be an HTML string, a node reference, or a enumerable list of nodes
Usually only used internally, and auto-generated with each instance
Should the content be treated as a full html document,
and the real content stripped of <html>, <body> wrapper before injection
Should the content be treated as a full html document, and the real content stripped of <html>, <body> wrapper before injection
Should the node by passed to the parser after the new content is set
Flag passed to parser. Root for attribute names to search for. If scopeName is dojo,
will search for data-dojo-type (or dojoType). For backwards compatibility
reasons defaults to dojo._scopeName (which is "dojo" except when
multi-version support is used, when it will be something like dojo16, dojo20, etc.)
Start the child widgets after parsing them. Only obeyed if parseContent is true.
All variants are case-insensitive and are separated by '-' as specified in [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
If no locale is specified, the dojo.locale is returned. dojo.locale is defined by
the user agent's locale unless overridden by djConfig.
Called by the bootstrap, but factored out so that it is only
included in the build when needed.
The name of the iframe. Used for the name attribute on the
iframe.
A string of JavaScript that will be executed when the content
in the iframe loads.
The value of the src attribute on the iframe element. If a
value is not given, then dojo/resources/blank.html will be
used.
The HTTP method to use. "GET" or "POST" are the only supported
values. It will try to read the value from the form node's
method, then try this argument. If neither one exists, then it
defaults to POST.
Specifies what format the result data should be given to the
load/handle callback. Valid values are: text, html, xml, json,
javascript. IMPORTANT: For all values EXCEPT html and xml, The
server response should be an HTML file with a textarea element.
The response data should be inside the textarea element. Using an
HTML document the only reliable, cross-browser way this
transport can know when the response has loaded. For the html
handleAs value, just return a normal HTML document. NOTE: xml
is now supported with this transport (as of 1.1+); a known issue
is if the XML document in question is malformed, Internet Explorer
will throw an uncatchable error.
If "form" is one of the other args properties, then the content
object properties become hidden form form elements. For
instance, a content object of {name1 : "value1"} is converted
to a hidden form element with a name of "name1" and a value of
"value1". If there is not a "form" property, then the content
object is converted into a name=value&name=value string, by
using dojo.objectToQuery().
Attaches the script element to the DOM. Use this method if you
just want to attach a script to the DOM and do not care when or
if it loads.
Deprecated as of Dojo 1.4 in favor of "jsonp", but still supported for
legacy code. See notes for jsonp property.
A string of JavaScript that when evaluated like so:
"typeof(" + checkString + ") != 'undefined'"
being true means that the script fetched has been loaded.
Do not use this if doing a JSONP type of call (use callbackParamName instead).
The Document object for a child iframe. If this is passed in, the script
will be attached to that document. This can be helpful in some comet long-polling
scenarios with Firefox and Opera.
Create a string from a Number using a known localized pattern.
Formatting patterns appropriate to the locale are chosen from the
[Common Locale Data Repository](http://unicode.org/cldr) as well as the appropriate symbols and
delimiters.
If value is Infinity, -Infinity, or is not a valid JavaScript number, return null.
the number to be formatted
the number to be formatted.
a pattern string as described by
[unicode.org TR35](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
_applyPattern is usually called via <code>dojo.number.format()</code> which
populates an extra property in the options parameter, "customs".
The customs object specifies group and decimal parameters if set.
Rounds to the nearest value with the given number of decimal places, away from zero if equal.
Similar to Number.toFixed(), but compensates for browser quirks. Rounding can be done by
fractional increments also, such as the nearest quarter.
NOTE: Subject to floating point errors. See dojox.math.round for experimental workaround.
>>> dojo.number.round(-0.5)
-1
>>> dojo.number.round(162.295, 2)
162.29 // note floating point error. Should be 162.3
>>> dojo.number.round(10.71, 0, 2.5)
10.75
The number to round
The number of decimal places where rounding takes place. Defaults to 0 for whole rounding.
Must be non-negative.
Rounds next place to nearest value of increment/10. 10 by default.
the number to be formatted, ignores sign
the number portion of a pattern (e.g. <code>#,##0.00</code>)
Returns regular expression with positive and negative match, group
and decimal separators
Create a Number from a string using a known localized pattern.
Formatting patterns are chosen appropriate to the locale
and follow the syntax described by
[unicode.org TR35](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
Note that literal characters in patterns are not supported.
A string representation of a Number
override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
with this string. Default value is based on locale. Overriding this property will defeat
localization. Literal characters in patterns are not supported.
choose a format type based on the locale from the following:
decimal, scientific (not yet supported), percent, currency. decimal by default.
fixed number of decimal places to show. This overrides any
information in the provided pattern.
5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
means do not round.
override the locale used to determine formatting rules
If false, show no decimal places, overriding places and pattern settings.
the decimal separator
the group separator
number of decimal places. the range "n,m" will format to m places.
5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
means don't round.
override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
with this string. Default value is based on locale. Overriding this property will defeat
localization.
choose a format type based on the locale from the following:
decimal, scientific (not yet supported), percent, currency. decimal by default.
override the locale used to determine formatting rules
strict parsing, false by default. Strict parsing requires input as produced by the format() method.
Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
number of decimal places to accept: Infinity, a positive number, or
a range "n,m". Defined by pattern or Infinity if pattern not provided.
override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
with this string. Default value is based on locale. Overriding this property will defeat
localization. Literal characters in patterns are not supported.
choose a format type based on the locale from the following:
decimal, scientific (not yet supported), percent, currency. decimal by default.
override the locale used to determine formatting rules
strict parsing, false by default. Strict parsing requires input as produced by the format() method.
Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
Whether to include the fractional portion, where the number of decimal places are implied by pattern
or explicit 'places' parameter. The value [true,false] makes the fractional portion optional.
The integer number of decimal places or a range given as "n,m". If
not given, the decimal part is optional and the number of places is
unlimited.
A string for the character used as the decimal point. Default
is ".".
Whether decimal places are used. Can be true, false, or [true,
false]. Default is [true, false] which means optional.
Express in exponential notation. Can be true, false, or [true,
false]. Default is [true, false], (i.e. will match if the
exponential part is present are not).
The leading plus-or-minus sign on the exponent. Can be true,
false, or [true, false]. Default is [true, false], (i.e. will
match if it is signed or unsigned). flags in regexp.integer can be
applied.
The leading plus-or-minus sign. Can be true, false, or <code>[true,false]</code>.
Default is <code>[true, false]</code>, (i.e. will match if it is signed
or unsigned).
The character used as the thousands separator. Default is no
separator. For more than one symbol use an array, e.g. <code>[",", ""]</code>,
makes ',' optional.
group size between separators
second grouping, where separators 2..n have a different interval than the first separator (for India)
a String with special characters to be left unescaped
A utility function used by some of the RE generators. The
subexpressions are constructed by the function, re, in the second
parameter. re builds one subexpression for each elem in the array
a, in the first parameter. Returns a string for a regular
expression that groups all the subexpressions.
A single value or an array of values.
A function. Takes one parameter and converts it to a regular
expression.
If true, uses non-capturing match, otherwise matches are retained
by regular expression. Defaults to false
If true, uses non-capturing match, otherwise matches are retained
by regular expression.
the name of the remote method you want to call.
array of parameters to pass to method
The name of the method we are calling
The parameters we are passing off to the method
The Deferred object for this particular request
The name of the method we are creating the requst for
The array of parameters for this request;
Object Object containing envelope of data we recieve from the server
The name of the method we are calling
The parameters we are passing off to the method
The Deferred object for this particular request
Takes a number of properties as kwArgs for defining the service. It also
accepts a string. When passed a string, it is treated as a url from
which it should synchronously retrieve an smd file. Otherwise it is a kwArgs
object. It accepts serviceUrl, to manually define a url for the rpc service
allowing the rpc system to be used without an smd definition. strictArgChecks
forces the system to verify that the # of arguments provided in a call
matches those defined in the smd. smdString allows a developer to pass
a jsonString directly, which will be converted into an object or alternatively
smdObject is accepts an smdObject directly.
Object that is the return results from an rpc request
Deferred The deferred object handling a request.
Deferred The deferred object handling a request.
The name of the method we are generating
the array of parameters for this call.
the service url for this call
object defining this service.
Observable wraps an existing store so that notifications can be made when a query
is performed.
Create a Memory store that returns an observable query, and then log some
information about that query.
var store = dojo.store.Observable(new dojo.store.Memory({
data: [
{id: 1, name: "one", prime: false},
{id: 2, name: "two", even: true, prime: true},
{id: 3, name: "three", prime: true},
{id: 4, name: "four", even: true, prime: false},
{id: 5, name: "five", prime: true}
]
}));
var changes = [], results = store.query({ prime: true });
var observer = results.observe(function(object, previousIndex, newIndex){
changes.push({previousIndex:previousIndex, newIndex:newIndex, object:object});
});
See the Observable tests for more information.
The object or string containing query information. Dependent on the query engine used.
An optional keyword arguments object with additional parameters describing the query.
dojo.store.util.QueryResults
A QueryResults object that can be used to iterate over.
The identifier for the object in question.
Any additional parameters needed to describe how the get should be performed.
dojo.store.util.QueryResults
A QueryResults object.
The object to add to the store.
Any additional parameters needed to describe how the add should be performed.
Number
The new id for the object.
The object to put to the store.
Any additional parameters needed to describe how the put should be performed.
Number
The new id for the object.
The identifier for the object in question.
Any additional parameters needed to describe how the remove should be performed.
The identifier for the object in question.
This provides any configuration information that will be mixed into the store,
including a reference to the Dojo data store under the property "store".
The identity to use to lookup the object
The object to store.
Additional metadata for storing the data. Includes a reference to an id
that the object may be stored with (i.e. { id: "foo" }).
The identity to use to delete the object
The query to use for retrieving objects from the store
Optional options object as used by the underlying dojo.data Store.
dojo.store.util.QueryResults
A query results object that can be used to iterate over results.
The data object to get the identity from.
Number
The id of the given object.
This provides any configuration information that will be mixed into the store
The identity to use to lookup the object
Object
The object in the store that matches the given id.
The object to get the identity from
Number
The object to store.
Additional metadata for storing the data. Includes an "id"
property if a specific id is to be used.
Number
The object to store.
Additional metadata for storing the data. Includes an "id"
property if a specific id is to be used.
The identity to use to delete the object
The query to use for retrieving objects from the store.
The optional arguments to apply to the resultset.
dojo.store.util.QueryResults
The results of the query, extended with iterative methods.
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
Indicates the property to use as the identity property. The values of this
property should be unique.
This provides any configuration information that will be mixed into the store.
This should generally include the data property to provide the starting set of data.
The identity to use to lookup the object
Object
The object in the store that matches the given id.
The object to get the identity from
Number
The object to store.
Additional metadata for storing the data. Includes an "id"
property if a specific id is to be used.
Number
The object to store.
Additional metadata for storing the data. Includes an "id"
property if a specific id is to be used.
Number
The identity to use to delete the object
Given the following store:
var store = new dojo.store.Memory({
data: [
{id: 1, name: "one", prime: false },
{id: 2, name: "two", even: true, prime: true},
{id: 3, name: "three", prime: true},
{id: 4, name: "four", even: true, prime: false},
{id: 5, name: "five", prime: true}
]
});
...find all items where "prime" is true:
var results = store.query({ prime: true });
...or find all items where "even" is true:
var results = store.query({ even: true });
The query to use for retrieving objects from the store.
The optional arguments to apply to the resultset.
dojo.store.util.QueryResults
The results of the query, extended with iterative methods.
An array of objects to use as the source of data.
Indicates the property to use as the identity property. The values of this
property should be unique.
An index of data by id
QueryResults is a basic wrapper that allows for array-like iteration
over any kind of returned data from a query. While the simplest store
will return a plain array of data, other stores may return deferreds or
promises; this wrapper makes sure that *all* results can be treated
the same.
Additional methods include `forEach`, `filter` and `map`.
Query a store and iterate over the results.
store.query({ prime: true }).forEach(function(item){
// do something
});
Object
An array-like object that can be used for iterating over.
The SimpleQueryEngine provides a way of getting a QueryResults through
the use of a simple object hash as a filter. The hash will be used to
match properties on data objects with the corresponding value given. In
other words, only exact matches will be returned.
This function can be used as a template for more complex query engines;
for example, an engine can be created that accepts an object hash that
contains filtering functions, or a string that gets evaluated, etc.
When creating a new dojo.store, simply set the store's queryEngine
field as a reference to this function.
The name of the attribute to sort on.
The direction of the sort. Default is false.
A list of attributes to sort on, as well as direction
The first result to begin iteration on
The number of how many results should be returned.
the string to replicate
number of times to replicate the string
// Fill the string to length 10 with "+" characters on the right. Yields "Dojo++++++".
dojo.string.pad("Dojo", 10, "+", true);
the string to pad
length to provide padding
character to pad, defaults to '0'
adds padding at the end if true, otherwise pads at start
Substitutes two expressions in a string from an Array or Object
// returns "File 'foo.html' is not found in directory '/temp'."
// by providing substitution data in an Array
dojo.string.substitute(
"File '${0}' is not found in directory '${1}'.",
["foo.html","/temp"]
);
// also returns "File 'foo.html' is not found in directory '/temp'."
// but provides substitution data in an Object structure. Dotted
// notation may be used to traverse the structure.
dojo.string.substitute(
"File '${name}' is not found in directory '${info.dir}'.",
{ name: "foo.html", info: { dir: "/temp" } }
);
Use a transform function to modify the values:
// returns "file 'foo.html' is not found in directory '/temp'."
dojo.string.substitute(
"${0} is not found in ${1}.",
["foo.html","/temp"],
function(str){
// try to figure out the type
var prefix = (str.charAt(0) == "/") ? "directory": "file";
return prefix + " '" + str + "'";
}
);
Use a formatter
// returns "thinger -- howdy"
dojo.string.substitute(
"${0:postfix}", ["thinger"], null, {
postfix: function(value, key){
return value + " -- howdy";
}
}
);
a string with expressions in the form <code>${key}</code> to be replaced or
<code>${key:format}</code> which specifies a format function. keys are case-sensitive.
hash to search for substitutions
a function to process all parameters before substitution takes
place, e.g. mylib.encodeXML
where to look for optional format function; default to the global
namespace
This version of trim() was taken from [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript).
The short yet performant version of this function is dojo.trim(),
which is part of Dojo base. Uses String.prototype.trim instead, if available.
String to be trimmed
String
Returns the trimmed string
Refer to dojo.doc rather
than referring to 'window.document' to ensure your code runs
correctly in managed contexts.
DojoX is a collection of subprojects provided by Dojo committers and subject to
the generous licensing and policies of the [Dojo CLA](http://dojotoolkit.org/cla)
Each subproject in DojoX has its own top-level directory and a README file with
status information and project status and a stability rating (experimental, beta, stable)
Projects may or may not depend on other top-level Dojo projects, like Dojo or Dijit.
Unlike Dojo and Dijit, code is not subject to i18n and a11y restrictions and may vary
in quality (experimental code is encouraged in DojoX, but currently prohibited in Dojo
and Dijit)
DojoX projects may mature to a stable state and stay in DojoX, or on occasion
after proving themselves may migrate to Dojo Core or Dijit. Dojo and Dijit projects
are constrained both by development resources as well as design goals, so DojoX is
a natural place to provide enhanced behavior or extend Dojo Core or Dijit primitives.
DojoX can also be an incubator for entirely new projects.
A JQuery compatibility layer
Used by <code>dojox.analytics.Urchin</code> as the default UA-123456-7 account
number used when being created. Alternately, you can pass an acct:""
parameter to the constructor a la: new dojox.analytics.Urchin({ acct:"UA-123456-7" });
An optional array of urls to preload immediately upon
page load. Uses <code>dojox.image</code>, and is unused if not present.
A small class object will allows for lazy-loading the Google Analytics API
at any point during a page lifecycle. Most commonly, Google-Analytics is loaded
via a synchronous script tag in the body, which causes `dojo.addOnLoad` to
stall until the external API has been completely loaded. The Urchin helper
will load the API on the fly, and provide a convenient API to use, wrapping
Analytics for Ajaxy or single page applications.
The class can be instantiated two ways: Programatically, by passing an
`acct:` parameter, or via Markup / dojoType and defining a djConfig
parameter `urchin:`
IMPORTANT:
This module will not work simultaneously with the core dojox.analytics
package. If you need the ability to run Google Analytics AND your own local
analytics system, you MUST include dojox.analytics._base BEFORE dojox.analytics.Urchin
This function is executed when the tracker variable is
complete and initialized. The initial trackPageView (with
no arguments) is called here as well, so remeber to call
manually if overloading this method.
Create an Urchin tracker that will track a specific page on init
after page load (or parsing, if parseOnLoad is true)
dojo.addOnLoad(function(){
new dojox.ananlytics.Urchin({
acct:"UA-12345-67",
GAonLoad: function(){
this.trackPageView("/custom-page");
}
});
});
Track clicks from a container of anchors and populate a `ContentPane`
// 'tracker' is our `Urchin` instance, pane is the `ContentPane` ref.
dojo.connect(container, "onclick", function(e){
var ref = dojo.attr(e.target, "href");
tracker.trackPageView(ref);
pane.attr("href", ref);
});
String A location to tell the tracker to track, eg: "/my-ajaxy-endpoint"
your GA urchin tracker account number. Overrides <code>djConfig.urchin</code>
This object implements a transport layer for working with ATOM feeds and ATOM publishing protocols.
Specifically, it provides a mechanism by which feeds can be fetched and entries can be fetched, created
deleted, and modified. It also provides access to the introspection data.
This function takes the URL for a specific ATOM feed and returns
the data from that feed to the caller through the use of a callback
handler.
The URL of the ATOM feed to fetch.
A function reference that will handle the feed when it has been retrieved.
The callback should accept two parameters: The feed object and the original complete DOM object.
The scope to use for all callbacks.
Nothing. The return is handled through the callback handler.
This function takes the URL for an ATOM item and feed and returns
the introspection document.
The URL of the ATOM document to obtain the introspection document of.
A function reference that will handle the introspection document when it has been retrieved.
The callback should accept two parameters: The introspection document object and the original complete DOM object.
Nothing. The return is handled through the callback handler.
This function takes the URL for an ATOM entry and returns the constructed dojox.atom.io.model.Entry object through
the specified callback.
The URL of the ATOM Entry document to parse.
A function reference that will handle the Entry object obtained.
The callback should accept two parameters, the dojox.atom.io.model.Entry object and the original dom.
Nothing. The return is handled through the callback handler.
This internal function takes the URL for an XML document and and passes the
parsed contents to a specified callback.
The URL of the XML document to retrieve
A function reference that will handle the retrieved XML data.
The callback should accept one parameter, the DOM of the parsed XML document.
Nothing. The return is handled through the callback handler.
This function takes a specific dojox.atom.io.model.Entry object and pushes the
changes back to the provider of the Entry.
The entry MUST have a link tag with rel="edit" for this to work.
The dojox.atom.io.model.Entry object to update.
A function reference that will handle the results from the entry update.
The callback should accept two parameters: The first is an Entry object, and the second is the URL of that Entry
Either can be null, depending on the value of retrieveUpdated.
A boolean flag denoting if the entry that was updated should then be
retrieved and returned to the caller via the callback.
Whether to use POST for PUT/DELETE items and send the X-Method-Override header.
The scope to use for all callbacks.
Nothing. The return is handled through the callback handler.
This function takes a specific dojox.atom.io.model.Entry object and pushes the
changes back to the provider of the Entry.
The dojox.atom.io.model.Entry object to publish.
A function reference that will handle the results from the entry publish.
The callback should accept two parameters: The first is an dojox.atom.io.model.Entry object, and the second is the location of the entry
Either can be null, depending on the value of retrieveUpdated.
A boolean flag denoting if the entry that was created should then be
retrieved and returned to the caller via the callback.
The scope to use for all callbacks.
Nothing. The return is handled through the callback handler.
This function takes a specific dojox.atom.io.model.Entry object and calls for a delete on the
service housing the ATOM Entry database.
The entry MUST have a link tag with rel="edit" for this to work.
The dojox.atom.io.model.Entry object to delete.
A function reference that will handle the results from the entry delete.
The callback is called only if the delete is successful.
Nothing. The return is handled through the callback handler.
Class container for generic Atom items.
child objects can override this if they want to be called after a Dom build
Function to add in an author to the list of authors.
The author's name.
The author's e-mail address.
A URI associated with the author.
Function to add in an author to the list of authors.
The author's name.
The author's e-mail address.
A URI associated with the author.
Function to add in a link to the list of links.
The href.
A title to associate with the link.
The type of link is is.
Function to remove a link from the list of links.
The href.
Function to remove all basic link from the list of links.
Function to add in a category to the list of categories.
Function to get all categories that match a particular scheme.
The scheme to filter on.
Function to remove all categories that match a particular scheme and term.
The scheme to filter on.
The term to filter on.
Function to set the title of the item.
The title to set.
The type of title format, text, xml, xhtml, etc.
Function to add in an extension namespace into the item.
The namespace of the extension.
The name of the extension
The attributes associated with the extension.
The content of the extension.
Function to get extensions that match a namespace and name.
The namespace of the extension.
The name of the extension
Function to remove extensions that match a namespace and name.
The namespace of the extension.
The name of the extension
Class container for 'Category' types.
Function to construct string form of the category tag, which is an XML structure.
Function to do construction of the Category data from the DOM node containing it.
The DOM node to process for content.
Class container for 'Content' types. Such as summary, content, username, and so on types of data.
Function to do construction of the Content data from the DOM node containing it.
The DOM node to process for content.
Handle checking for XML content as the content type
Function to construct string form of the content tag, which is an XML structure.
Class container for 'link' types.
Function to do construction of the link data from the DOM node containing it.
DOM node to process for link data.
Function to construct string form of the link tag, which is an XML structure.
Class container for 'person' types, such as Author, controbutors, and so on.
Function to do construction of the person data from the DOM node containing it.
DOM node to process for person data.
Function to construct string form of the Person tag, which is an XML structure.
Class container for 'Generator' types.
Function to do construction of the generator data from the DOM node containing it.
DOM node to process for link data.
Function to construct string form of the Generator tag, which is an XML structure.
Class container for 'Entry' types.
Function to construct string form of the entry tag, which is an XML structure.
Function to get the href that allows editing of this feed entry.
The href that specifies edit capability.
Class container for 'Feed' types.
Function to add an entry to this feed.
The entry object to add.
Function to get the first entry of the feed.
The first entry in the feed.
Function to get an entry by its id.
The entry desired, or null if none.
Function to remove an entry from the list of links.
The entry.
Function to get an entry by its id.
An array of entry objects to add to the feed.
Function to construct string form of the feed tag, which is an XML structure.
Function to Create a new entry object in the feed.
An empty entry object in the feed.
Function to get the href that refers to this feed.
The href that refers to this feed or null if none.
Class container for 'Feed' types.
builds a Service document. each element of this, except for the namespace, is the href of
a service that the server supports. Some of the common services are:
"create-entry" , "user-prefs" , "search-entries" , "edit-template" , "categories"
Function to do construction of the Service data from the DOM node containing it.
The DOM node to process for content.
Function to collections that match a specific url.
e URL to match collections against.
Class container for 'Workspace' types.
Function to do construction of the Workspace data from the DOM node containing it.
The DOM node to process for content.
Class container for 'Collection' types.
Function to do construction of the Collection data from the DOM node containing it.
The DOM node to process for content.
Container for general constants.
Container for tag handling functions. Each child of this container is
a handler function for the given type of node. Each accepts two parameters:
obj: Object.
The object to insert data into.
node: DOM Node.
The dom node containing the data
Google news
Google news
Utility function to create a date from a DOM node's text content.
The DOM node to inspect.
Date object from a DOM Node containing a ISO-8610 string.
Utility function to escape XML special characters in an HTML string.
The string to escape
HTML String with special characters (<,>,&, ", etc,) escaped.
Utility function to un-escape XML special characters in an HTML string.
The string to un-escape.
HTML String converted back to the normal text (unescaped) characters (<,>,&, ", etc,).
Utility function to get a node name and deal with IE's bad handling of namespaces
on tag names.
The DOM node whose name to retrieve.
String
The name without namespace prefixes.
An ATOM feed entry editor that allows viewing of the individual attributes of an entry.
Flag denoting if the current entry is editable or not.
Function to set the current entry that is being edited.
Instance of dojox.atom.io.model.Entry to display for reading/editing.
Internal function for toggling/enabling the display of edit mode
Nothing.
Internal function for listening to a topic that will handle entry notification.
The topic message containing the entry that was selected for view.
Nothing.
Internal function for determining of a particular entry is editable.
This is used for determining if the delete action should be displayed or not.
The dojox.atom.io.model.Entry object to examine
Boolean denoting if the entry seems editable or not..
Function to set the contents of the title node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the title data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the author node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the author data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the contributor node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the contributor data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the ID node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the ID data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the updated node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the udpated data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the summary node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the summary data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the content node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
summaryAnchorNode:
The DOM node to attach the content data to.
node
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to create an appropriate text editor widget based on the given parameters.
The DOM node to attach the editor widget to.
An object containing the value to be put into the editor. This ranges from an anonymous object
with a value parameter to a dojox.atom.io.model.Content object.
A boolean indicating whether the content should be multiline (such as a textarea) instead of a
single line (such as a textbox).
A boolean indicating whether the content should be a rich text editor widget.
Either a widget (for textarea or textbox widgets) or an anonymous object to be used to create a
rich text area widget.
Function to switch between a rich text editor and a textarea widget. Used for title, summary,
And content when switching between text and html/xhtml content.
The event generated by the change in the select box on the page.
Creates a People Editor widget, sets its value, and returns it.
The node to attach the editor to.
An object containing the value to be put into the editor. Typically, this is an
dojox.atom.io.model.Person object.
A new People Editor object.
Saves edits submitted when the 'save' button is pressed. Distinguishes between new and existing
entries and saves appropriately. Fetches the values of the editors, and, if existing, compares them to
the existing values and submits the updates, otherwise creates a new entry and posts it as a new entry.
Nothing.
Function for handling the save of an entry, cleaning up the display after the edit is completed.
dojox.atom.io.model.Entry object
The entry that was saved.
Location: String
A URL to be used, not used here, but part of the call back from the AtomIO
Nothing.
Close the editor and revert out.
Cancels edits and reverts the editor to its previous state (display mode)
Nothing.
Clears the editor, destorys all editors, leaving the editor completely clear
Function for cleaning up/enforcing the XHTML standard in HTML returned from the editor2 widget.
HTML string to be enforced as xhtml.
string of cleaned up HTML.
Function for closing tags in a text of HTML/XHTML
String XHTML string which needs the closing tag.
The tag to close.
string of cleaned up HTML.
NOTE: Probably should redo this function in a more efficient way. This could get expensive.
Function to put the editor into a state to create a new entry.
Function to display the appropriate sections based on validity.
An editor for dojox.atom.io.model.Person objects. Displays multiple rows for the respective arrays
of people. Can add/remove rows on the fly.
creates editor boxes (textbox widgets) for the individual values of a Person.
The name of this Person.
The email of this Person.
The Person's URI.
The row index to use for this Person.
Creates an individual editor widget (textbox) for a value.
The initial value of the textbox
The id the textbox should have.
The text to put in the label element for this textbox.
The node to attach the label to.
The node to attach the editor rows to.
Editor widget.
Removes a Person from our list of editors by removing the block of editors that
make up that Person.
The event generated when the remove button is pressed on the page.
Adds a new block of blank editors to represent a Person.
Gets the values of this editor in an array, with each Person as an object within the array.
An array of anonymous objects representing dojox.atom.io.model.Persons.
An ATOM feed entry editor for publishing updated ATOM entries, or viewing non-editable entries.
The topic to listen on for entries to edit.
Function to clear the state of the widget.
Function to clear all the display nodes for the ATOM entry from the viewer.
Function to set the current entry that is being edited.
Instance of dojox.atom.io.model.Entry to display for reading/editing.
Function to set the contents of the title header node in the template to some value.
This exists specifically so users can over-ride how the title data is filled out from an entry.
titleAchorNode:
The DOM node to attach the title data to.
editMode:
Boolean to indicate if the display should be in edit mode or not.
node
The Feed Entry to work with.
Function to set the contents of the title node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
titleAchorNode:
The DOM node to attach the title data to.
to indicate if the display should be in edit mode or not.
Feed Entry to work with.
Function to set the title format for the authors section of the author row in the template to some value from the entry.
This exists specifically so users can over-ride how the author data is filled out from an entry.
The DOM node to attach the author section header data to.
The Feed Entry to work with.
Function to set the contents of the author node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
authorsAchorNode:
The DOM node to attach the author data to.
node
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the contributor header node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the contributor title to.
The Feed Entry to work with.
Function to set the contents of the contributor node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the contributor data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the ID node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
idAnchorNode:
The DOM node to attach the ID data to.
node
The Feed Entry to work with.
Function to set the contents of the ID node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the ID data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the updated header node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the updated header data to.
The Feed Entry to work with.
Function to set the contents of the updated node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the udpated data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the summary node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the summary title to.
The Feed Entry to work with.
Function to set the contents of the summary node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the summary data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Function to set the contents of the content node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the content data to.
The Feed Entry to work with.
Function to set the contents of the content node in the template to some value from the entry.
This exists specifically so users can over-ride how the title data is filled out from an entry.
The DOM node to attach the content data to.
Boolean to indicate if the display should be in edit mode or not.
The Feed Entry to work with.
Internal function for determining which sections of the view to actually display.
Nothing.
Function for setting which sections of the entry should be displayed.
Array of string names that indicate which sections to display.
Nothing.
Internal function for setting which checkboxes on the display are selected.
Nothing.
Internal function for reading what is currently checked for display and generating the display list from it.
Nothing.
Internal function for determining of a particular entry is editable.
This is used for determining if the delete action should be displayed or not.
The checkbox object to toggle the selection on.
Nothing
Internal function for determining of a particular entry is editable.
This is used for determining if the delete action should be displayed or not.
The checkbox object to toggle the selection on.
Nothing
Internal function for listening to a topic that will handle entry notification.
The topic message containing the entry that was selected for view.
Nothing.
Function to set whether a field in the view is valid and displayable.
This is needed for over-riding of the set* functions and customization of how data is displayed in the attach point.
So if custom implementations use their own display logic, they can still enable the field.
The field name to set the valid parameter on. Such as 'content', 'id', etc.
Flag denoting if the field is valid or not.
Nothing.
Function to return if a displayable field is valid or not
The field name to get the valid parameter of. Such as 'content', 'id', etc.
boolean denoting if the field is valid and set.
Widget representing a header in a FeedEntryViewer/Editor
An ATOM feed viewer that allows for viewing a feed, deleting entries, and editing entries.
The body of the feed viewer table so we can access it and populate it. Will be assigned via template.
The overal table container which contains the feed viewer table. Will be assigned via template.
The topic to broadcast when any entry is clicked so that a listener can pick up it and display it.
The URL to which to connect to initially on creation.
The postCreate function. Creates our AtomIO object for future interactions and subscribes to the
event given in markup/creation.
The startup function. Parses the filters and sets the feed based on the given url.
Function clearing all current entries in the feed view.
Nothing.
Function setting the dojox.atom.io.model.Feed data into the view.
The URL to the feed to load.
Nothing.
Function setting the dojox.atom.io.model.Feed data into the view.
entry:
The dojox.atom.io.model.Feed object to process
Nothing.
Internal function for determining of a particular entry is editable.
The dojox.atom.io.model.Entry object to examine.
An appropriate date for the feed viewer display.
Function for appending a grouping of entries to the feed view.
entry:
The title of the new grouping to create on the view.
Nothing.
Function for appending an entry to the feed view.
The dojox.atom.io.model.Entry object to append
Nothing.
Function for deleting a row from the view
callback for when an entry is deleted from a feed.
Internal function for handling the selection of feed entries.
The click event that triggered a selection.
Nothing.
Internal function for unselecting the current selection.
Nothing.
Internal function for determining of a particular entry is editable.
This is used for determining if the delete action should be displayed or not.
The dojox.atom.io.model.Entry object to examine
Boolean denoting if the entry seems editable or not..
Function intended for over0-riding/replacement as an attachpoint to for other items to recieve
selection notification.
The dojox.atom.io.model.Entry object selected.
Nothing.
Method to determine if the URL is relative or absolute. Basic assumption is if it doesn't start
with http:// or file://, it's relative to the current document.
The URL to inspect.
boolean indicating whether it's a relative url or not.
Internal function to calculate a baseline URL from the provided full URL.
The full URL as a string.
Flag to denote of the base URL should be calculated as just the server base, or relative to the current page/location in the URL.
String of the baseline URL
Internal function to do matching of category filters to widgets.
boolean denoting if this entry matched one of the accept filters.
Function to add a filter for entry inclusion in the feed view.
The basic items to filter on and the values.
Should be of format: {scheme: <some text or null>, term: <some text or null>, label: <some text or null>}
Nothing.
Function to remove a filter for entry inclusion in the feed view.
The basic items to identify the filter that is present.
Should be of format: {scheme: <some text or null>, term: <some text or null>, label: <some text or null>}
Nothing.
Internal function for listening to a topic that will handle entry notification.
The topic message containing the entry that was selected for view.
Nothing.
callback function used when adding an entry to the feed. After the entry has been posted to the feed,
we add it to our feed representation (to show it on the page) and publish an event to update any entry viewers.
Destroys this widget, including all descendants and subscriptions.
Widget for handling the display of an entry and specific events associated with it.
Function to set the title of the entry.
The title.
Nothing.
Function to set the time of the entry.
The string form of the date.
Nothing.
Function to enable the delete action on this entry.
Nothing.
Function to disable the delete action on this entry.
Nothing.
Function to handle the delete event and delete the entry.
Nothing.
Attach point for when a row is clicked on.
The event generated by the click.
Grouping of feed entries.
Sets the text to be shown above this grouping.
text to show.
A filter to be applied to the list of entries.
The initializer function.
The initializer function.
Function to determine if this category filter matches against a category on an atom entry
boolean denoting if this category filter matched to this entry.
This class is brand new, so there is a lot of
functionality not yet available. The initial
purpose is for playing "event" sounds like button
clicks, and for loading and controlling multiple
sounds at once. As of yet, streaming is not supported
and polling the sounds for events during playback
may still be missing information. Markup is not
supported, as it may not be needed.
TODO:
Streaming, playback events, crossdomain, CDN support,
(alternate SWF location), global volume, ID3 tag,
factor out doLater, onLoadStatus needs work,
play(position) / seek()
url: String
(required) path to MP3 media
url must be absolute or relative to SWF,
not dojo or the html. An effort will be made
to fix incorrect paths.
id: String
(optional) an identifier to later determine
which media to control.
The normalized url, which can be used to identify the
audio.
volume: Number
Sets the volume
pan: Number
Sets left/right pan
index:Number OR id:String OR url:String
Choose one of the above to indentify
the media you wish to control. id is
set by you. index is the order in which
media was added (zero based)
NOTE: lack of an identifier will default
to first (or only) item.
NOTE: Can't name this method "play()" as it causes
an IE error.
index:Number OR id:String OR url:String
See doPlay()
index:Number OR id:String OR url:String
See doPlay()
volume: Number
0 to 1
index:Number OR id:String OR url:String
See doPlay()
pan:Number -1 to 1
index:Number OR id:String OR url:String
See doPlay()
index:Number OR id:String OR url:String
See doPlay()
index:Number OR id:String OR url:String
See doPlay()
index:Number OR id:String OR url:String
See doPlay()
The id of this widget and the id of the SWF movie.
From 0-1
Sets volume for all files unless changed with doPlay
or setVolume
From -1 to 1 (-1 is left, 1 is right, 0 is middle)
Sets pan for all files unless changed with play
or setPan
autoPlay: Boolean
If true, all files will play upon load. If false,
they load and wait for doPlay() command.
Setting to true tells the SWF to output log messages to Firebug.
How often in milliseconds that the status of the
player is checked - both load and play
The path to the video player SWF resource
Whether the SWF can access the container JS
Whether SWF is restricted to a domain
console.warn("ERROR-"+data.type.toUpperCase()+":",
data.info.code, " - URL:", url);
The path to the video player SWF resource
Calculates the current status of the playing media and fires
the appropriate events.
console.warn("ERROR-"+data.type.toUpperCase()+":",
data.info.code, " - URL:", url);
The initial volume setting of the player. Acccepts between 0 and 1.
Whether the video automatically plays on load or not.
Time in milliseconds that the video should be loaded before it will
play. May pause and resume to build up buffer. Prevents stuttering.
Note:
Older FLVs, without a duration, cannot be buffered.
Time in milliseconds bwteen the playhead time and loaded time that
will trigger the buffer. When buffer is triggered, video will pause
until the bufferTime amount is buffered.
Note: Should be a small number, greater than zero.
How often, in milliseconds to get an update of the video position.
The id of this widget and the id of the SWF movie.
Setting to true tells the SWF to output log messages to Firebug.
The percentage the media has downloaded; from 0-100
The dojox.embed object
The SWF object. Methods are passed to this.
Whether the SWF can access the container JS
Whether SWF is restricted to a domain
The render type of the SWF
Whether to allow the SWF to go to fullscreen
Currently for markup only. All controls should reside as child
nodes within the Player node. 'controlType' is used to determine
the placement of the control. If no type or an unrecoginized type
is used, it will be left-aligned in the same row as the volume.
Note:
Be sure to use 'controlType' as a node attribute. It is not a
property of the widget.
or String
Sets the width of the player (not the video size)
Number will be converted to pixels
String will be used literally. EX: "320px" or "100%"
TODO:
playerHeight
videoWidth: 320,
videoHeight: 240,
Displays the current playhead position of the media. Has two
progress bars: one for playhead position, and one for download
progress.
Displays the name of the media file, and it's current status
(playing, paused, buffering, etc.) in the middle. Displays
the playhead time on the left and the duration on the right.
Controls and displays the volume of the media. This widget
opens a slider on click that is used to adjust the volume.
The icon changes according to the volume level.
argument is simply a String that represents the name of the function being evaluated. It can be undefined, but in that case the function is a one time use.
function arguments (a String)
function body, also a String
dojox.charting.Chart is the primary object used for any kind of charts. It
is simple to create--just pass it a node reference, which is used as the
container for the chart--and a set of optional keyword arguments and go.
Note that like most of dojox.gfx, most of dojox.charting.Chart's methods are
designed to return a reference to the chart itself, to allow for functional
chaining. This makes defining everything on a Chart very easy to do.
dojox.charting.Chart
The newly created chart.
void
Object
The resulting coordinates of the chart. See dojo.coords for details.
The theme to be used for visual rendering.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name of the axis.
An optional keyword arguments object for use in defining details of an axis.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name the axis was defined by.
dojox.charting.axis2d.Default
The axis as stored in the chart's axis map.
The axis name, as defined in addAxis.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name of the plot to be added to the chart. If you only plan on using one plot, call it "default".
An object with optional parameters for the plot in question.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name of the plot as defined using addPlot.
dojox.charting.Chart
A reference to the current chart for functional chaining.
Array
Array of plot names compatible with getPlotOrder().
dojox.charting.Chart
A reference to the current chart for functional chaining.
Plot's name to move.
dojox.charting.Chart
A reference to the current chart for functional chaining.
Plot's name to move.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name of the data series to be plotted.
The array of data points (either numbers or objects) that
represents the data to be drawn. Or it can be an object. In
the latter case, it should have a property "data" (an array),
destroy(), and setSeriesObject().
An optional keyword arguments object that will be mixed into
the resultant series object.
dojox.charting.Chart:
A reference to the current chart for functional chaining.
The name of the series as defined by addSeries.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name of the series as defined in addSeries.
The array of data points (either numbers or objects) that
represents the data to be drawn. Or it can be an object. In
the latter case, it should have a property "data" (an array),
destroy(), and setSeriesObject().
dojox.charting.Chart
A reference to the current chart for functional chaining.
Plot's name.
Array
Array of series names compatible with getPlotOrder(). All
series should belong to the same plot.
dojox.charting.Chart
A reference to the current chart for functional chaining.
Series' name to move.
dojox.charting.Chart
A reference to the current chart for functional chaining.
Series' name to move.
dojox.charting.Chart
A reference to the current chart for functional chaining.
Resize the chart and its surface to the width and height dimensions.
If no width/height or box is provided, resize the surface to the marginBox of the chart.
The new width of the chart.
The new height of the chart.
dojox.charting.Chart
A reference to the current chart for functional chaining.
Object
An map of geometry objects, a one-to-one mapping of axes.
The name of the axis as defined by addAxis.
The scale on the target axis.
Any offest, as measured by axis tick
The chart zooming animation trigger. This is null by default,
e.g. {duration: 1200}, or just set true.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The scale for the x axis.
The scale for the y axis.
The pixel offset on the x axis.
The pixel offset on the y axis.
The chart zooming animation trigger. This is null by default,
e.g. {duration: 1200}, or just set true.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name of the axis as defined by addAxis.
The end points of the zoom range, measured in axis ticks.
dojox.charting.Chart
A reference to the current chart for functional chaining.
dojox.charting.Chart
A reference to the current chart for functional chaining.
dojox.charting.Chart
A reference to the current chart for functional chaining.
dojox.charting.Chart
A reference to the current chart for functional chaining.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The name of the plot as defined by addPlot.
The object to be connected.
The function to be executed.
Array
A handle to the connection, as defined by dojo.connect (see dojo.connect).
Series name.
Event name to simulate: onmouseover, onmouseout, onclick.
Valid data value index for the event.
dojox.charting.Chart
A reference to the current chart for functional chaining.
The object to be wrapped and monitored for property access and modification
See dojox.lang.makeObservable.onRead
See dojox.lang.makeObservable.onWrite
See dojox.lang.makeObservable.onInvoke
The following could be used to create a wrapper that would
prevent functions from being accessed on an object:
function onRead(obj,prop){
return typeof obj[prop] == 'function' ? null : obj[prop];
}
var observable = dojox.lang.makeObservable(onRead,onWrite);
var obj = {foo:1,bar:function(){}};
obj = observable(obj);
obj.foo -> 1
obj.bar -> null
This is called whenever one of the wrapper objects created
from the constructor has a property that is accessed. onRead
will be called with two arguments, the first being the wrapped object,
and the second is the name of property that is being accessed.
The value that onRead returns will be used as the value returned
by the property access
This is called whenever one of the wrapper objects created
from the constructor has a property that is modified. onWrite
will be called with three arguments, the first being the wrapped object,
the second is the name of property that is being modified, and the
third is the value that is being set on the property.
This is called when a method on the object is invoked. The first
argument is the wrapper object, the second is the original wrapped object,
the third is the method name, and the fourth is the arguments.
allows you to define functions that should be delegated
but may not be enumerable on the wrapped objects, so they must be
explicitly included
color model
defines visual properties
center of the cylinder's bottom
radius of the cylinder
from position in radians
from position in radians
the cumulative transformation matrix
tolerance: Number: tolerable diffirence in colors between gradient steps
dojox.gfx is an advanced API providing normalized vector drawing
in a variety of browsers. It has individual renderers for SVG, VML,
Canvas, and Silverlight.
a length, e.g., "12pc"
the "target" object to be updated
the "update" object, whose properties will be used to update
the existed object
the object to be cloned before updating
the object, which properties are to be cloned during updating
number to be converted
if it is true, add a space before a positive number
font object (see dojox.gfx.defaultFont)
Converts a CSS font string to a gfx font object. The CSS font
string components should follow the W3C specified order
(see http://www.w3.org/TR/CSS2/fonts.html#font-shorthand):
style, variant, weight, size, optional line height (will be
ignored), and family.
a CSS font string
a value in points
a value in pixels
this function decompose a matrix into four logical components:
translation, rotation, scaling, and one more rotation using SVD.
The components should be applied in following order:
[translate, rotate(angle2), scale, rotate(angle1)]
a 2D matrix-like object
This code should be considered very experimental and the APIs subject
to change. This is currently an alpha version and will need some testing
and review.
The main reason for this extension is to create animated charts, generally
available with scroll=true, and a property field that gets continually updated.
The previous property settings are kept in memory and displayed until scrolled
off the chart.
Although great effort was made to maintain the integrity of the current
charting APIs, some things have been added or modified in order to get
the store to connect and also to get the data to scroll/animate.
"displayRange" in particular is used to force the xaxis to a specific
size and keep the chart from stretching or squashing to fit the data.
Currently, plot lines can only be set at initialization. Setting
a new store query will have no effect (although using setStore
may work but its untested).
The node to attach the chart to.
String
String
Object
Whether live data updates and changes display, like columns moving
up and down, or whether it scrolls to the left as data is added
If false, all items are each their own series.
If true, the items are combined into one series
so that their charted properties can be compared.
Used for fetching items. Will vary depending upon store.
Option used for fetching items
The field in the store item that is getting charted
The theme to style the chart. Defaults to PlotKit.blue.
The number of major ticks to show on the xaxis
If true, chart is sized to data. If false, chart is a
fixed size. Note, is overridden by displayRange.
TODO: Stretch for the y-axis?
The the smallest the chart width can be
The the smallest the chart height can be
Whether the chart is showing (default) on
initialization or hidden.
The name field of the store item
DO NOT SET: Set from store.labelAttribute
A dojo.data store object.
A store-specific keyword parameters used for fetching items.
See dojo.data.api.Read.fetch().
Function, which takes a store, and an object handle, and
produces an output possibly inspecting the store's item. Or
a dictionary object, which tells what names to extract from
an object and how to map them to an output. Or a string, which
is a numeric field name to use for plotting. If undefined, null
or empty string (the default), "value" field is extracted.
Our interface to the chart.
A dojo.data store object.
A store-specific keyword parameters used for fetching items.
See dojo.data.api.Read.fetch().
Function, which takes a store, and an object handle, and
produces an output possibly inspecting the store's item. Or
a dictionary object, which tells what names to extract from
an object and how to map them to an output. Or a string, which
is a numeric field name to use for plotting. If undefined, null
or empty string (the default), "value" field is extracted.
The chart that this element belongs to.
An optional surface in which to create this group.
dojox.charting.Element
A reference to this object for functional chaining.
dojox.charting.Element
A reference to this object for functional chaining.
An optional surface to work with.
dojox.charting.Element
A reference to this object for functional chaining.
candidate text.
text's font style.
text limited width in px.
text has been truncated
}
Object
{
text: processed text, maybe truncated or not
candidate text.
text's font style.
text limited character count.
text has been truncated
}
Object
{
text: processed text, maybe truncated or not
The visual GFX group representing this element.
htmlElement: Array
Any DOMNodes used as a part of this element (such as HTML-based labels).
A flag indicating whether or not this element needs to be rendered.
The chart that this series belongs to.
The array of data points (either numbers or objects) that
represents the data to be drawn. Or it can be an object. In
the latter case, it should have a property "data" (an array),
destroy(), and setSeriesObject().
An optional keyword arguments object to set details for this series.
The array of data points (either numbers or objects) that
represents the data to be drawn. Or it can be an object. In
the latter case, it should have a property "data" (an array),
destroy(), and setSeriesObject().
The plot (by name) that this series belongs to.
A dojo object store.
A store-specific keyword parameters used for querying objects.
See dojo.store docs
Function, which takes an object handle, and
produces an output possibly inspecting the store's item. Or
a dictionary object, which tells what names to extract from
an object and how to map them to an output. Or a string, which
is a numeric field name to use for plotting. If undefined, null
or empty string (the default), "value" field is extracted.
Our interface to the chart.
A dojo object store.
A store-specific keyword parameters used for querying objects.
See dojo.store docs
Function, which takes an object handle, and
produces an output possibly inspecting the store's item. Or
a dictionary object, which tells what names to extract from
an object and how to map them to an output. Or a string, which
is a numeric field name to use for plotting. If undefined, null
or empty string (the default), "value" field is extracted.
While you can set up style definitions on a chart directly (usually through the various add methods
on a dojox.charting.Chart2D object), a Theme simplifies this manual setup by allowing you to
pre-define all of the various visual parameters of each element in a chart.
Most of the properties of a Theme are straight-forward; if something is line-based (such as
an axis or the ticks on an axis), they will be defined using basic stroke parameters. Likewise,
if an element is primarily block-based (such as the background of a chart), it will be primarily
fill-based.
In addition (for convenience), a Theme definition does not have to contain the entire JSON-based
structure. Each theme is built on top of a default theme (which serves as the basis for the theme
"GreySkies"), and is mixed into the default theme object. This allows you to create a theme based,
say, solely on colors for data series.
Defining a new theme is relatively easy; see any of the themes in dojox.charting.themes for examples
on how to define your own.
When you set a theme on a chart, the theme itself is deep-cloned. This means that you cannot alter
the theme itself after setting the theme value on a chart, and expect it to change your chart. If you
are looking to make alterations to a theme for a chart, the suggestion would be to create your own
theme, based on the one you want to use, that makes those alterations before it is applied to a chart.
Finally, a Theme contains a number of functions to facilitate rendering operations on a chart--the main
helper of which is the ~next~ method, in which a chart asks for the information for the next data series
to be rendered.
A note on colors:
The Theme constructor was on the use of dojox.color.Palette (in general) for creating a visually distinct
set of colors for usage in a chart. A palette is usually comprised of 5 different color definitions, and
no more. If you have a need to render a chart with more than 5 data elements, you can simply "push"
new color definitions into the theme's .color array. Make sure that you do that with the actual
theme object from a Chart, and not in the theme itself (i.e. either do that before using .setTheme
on a chart).
var colors = dojox.charting.Theme.defineColors({
base: "#369",
generator: "compound"
});
var colors = dojox.charting.Theme.defineColors({
hue: 60,
saturation: 90,
low: 30,
high: 80
});
The arguments object used to define colors.
dojo.Color[]
An array of colors for use in a theme.
dojox.charting.Theme
The cloned theme; any alterations made will not affect the original.
An optional element type (for use with series themes)
An optional object to mix into the theme.
A flag to post-process the results.
Object
An object of the structure { series, marker, symbol }
The theme to mixin to.
The type of element in question. Can be "line", "bar" or "circle"
The object or objects to mix into the theme.
If true, run the new theme through the post-processor.
dojox.charting.Theme
The new theme.
The theme to post process with.
The type of element being filled. Can be "bar" or "circle".
dojox.charting.Theme
The post-processed theme.
Tick name, can be "major", "minor", or "micro".
Optional object to mix in to the tick.
myTheme.addMarker("Ellipse", foo);
myTheme.setMarkers({ "CIRCLE": foo });
1, dy: 1, width: 2, color: [0, 0, 0, 0.3]},
no shadow
fill, if appropriate
if there's a label
color of labels
connect marker and target data item(slice, column, bar...)
1, dy: 1, width: 2, color: [0, 0, 0, 0.3]},
no shadow
fill if needed
label
The number of colors to generate. Defaults to 5.
A pre-defined set of colors; this is passed through to the Theme directly.
A hue to base the generated colors from (a number from 0 - 359).
If a hue is passed, this is used for the saturation value (0 - 100).
An optional value to determine the lowest value used to generate a color (HSV model)
An optional value to determine the highest value used to generate a color (HSV model)
A base color to use if we are defining colors using dojox.color.Palette
The generator function name from dojox.color.Palette.
The chart this action applies to.
The name of the plot this action belongs to. If none is passed "default" is assumed.
Optional arguments for the action.
The chart this action applies to.
The name of the plot this action belongs to. If none is passed "default" is assumed.
kwargs: dojox.charting.action2d.__BaseCtorArgs?
Optional arguments for the action.
Either a color or a function that creates a color when highlighting happens.
The chart this action belongs to.
The plot this action is attached to. If not passed, "default" is assumed.
Optional keyword arguments object for setting parameters.
The object on which to process the highlighting action.
The amount to magnify the given object to. Default is 2.
The chart this action belongs to.
The plot to apply the action to. If not passed, "default" is assumed.
Optional keyword arguments for this action.
The object on which to process the magnifying action.
The amount to scale the pie slice. Default is 1.05.
The amount in pixels to shift the pie slice. Default is 7.
The chart this action belongs to.
The plot this action is attached to. If not passed, "default" is assumed.
Optional keyword arguments object for setting parameters.
The object on which to process the slice moving action.
The amount in pixels to shift the pie slice. Default is 3.
The chart this action belongs to.
The plot this action is attached to. If not passed, "default" is assumed.
Optional keyword arguments object for setting parameters.
The object on which to process the slice moving action.
The chart this action belongs to.
The plot this action is attached to. If not passed, "default" is assumed.
Optional keyword arguments object for setting parameters.
The object on which to process the highlighting action.
The chart this axis belongs to.
An optional arguments object to define the axis parameters.
dojox.charting.axis2d.Base
A reference to the axis for functional chaining.
Boolean
If the axis is initialized or not.
dojox.charting.axis2d.Base
A reference to the axis for functional chaining.
Object
The scaler object (see dojox.charting.scaler.linear for more information)
Object
The ticks object.
Object
An object of the form { l, r, t, b }.
dojox.charting.axis2d.Base
A reference to the axis for functional chaining.
The chart the axis belongs to.
Any optional keyword arguments to be used to define this axis.
Object
The calculated offsets in the form of { l, r, t, b } (left, right, top, bottom).
An object of the form { width, height}.
An object of the form { l, r, t, b }.
dojox.charting.axis2d.Default
The reference to the axis for functional chaining.
The chart the axis belongs to.
Any optional keyword arguments to be used to define this axis.
dojox.charting.axis2d.Default
The reference to the axis for functional chaining.
Boolean
Whether a scaler has been calculated and if the axis is not dirty.
The new scale for the axis.
The new offset for the axis.
dojox.charting.axis2d.Default
The reference to the axis for functional chaining.
The smallest value represented on this axis.
The largest value represented on this axis.
The span in pixels over which axis calculations are made.
Optional list of labels.
dojox.charting.axis2d.Default
The reference to the axis for functional chaining.
original object.
additional object, which properties will override object's properties.
object, which typeof result is used to coerce "source" object.
object, which will be forced to change type.
the "target" object to be updated
the "source" object, whose properties will be used to source the existed object.
force conversion to the original type
the "target" object to be updated
the "source" object, whose properties will be used to source the existed object.
object, whose properties will be used to pull values from the "source"
force conversion to the original type
The chart to create the text into.
The graphics surface to use for creating the text.
Where to create the text along the x axis (CSS left).
Where to create the text along the y axis (CSS top).
How to align the text. Can be "left", "right", "center".
The text to render.
The font definition, a la CSS "font".
The color of the resultant text.
dojox.gfx.Text
The resultant GFX object.
The chart to create the text into.
The graphics surface to use for creating the text.
Where to create the text along the x axis (CSS left).
Where to create the text along the y axis (CSS top).
How to align the text. Can be "left", "right", "center".
The text to render.
The font definition, a la CSS "font".
The color of the resultant text.
The maximum width of the resultant DOM node.
DOMNode
The resultant DOMNode (a "div" element).
The minimum size for a bar in pixels. Default is 1.
The maximum size for a bar in pixels. Default is 1.
The chart this plot belongs to.
An optional keyword arguments object to help define the plot.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.Bars
A reference to this plot for functional chaining.
The chart this plot belongs to.
An optional arguments object to help define the plot.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
The axis to set.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
The series to be added.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object of the form { width, height }
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
Boolean
The state of the plot.
Boolean
Flag indicating if any of this plot's series are invalid and need rendering.
An object of the form { width, height }.
An object of the form { l, r, t, b }.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
An object of the form { width, height }.
An object of the form { l, r, t, b }.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
Number
The number of colors needed.
Size of a plot area in pixels as {width, height}.
Min/max of data in both directions as {hmin, hmax, vmin, vmax}.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
The chart this plot belongs to.
Optional keyword arguments object to help define plot parameters.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.Bubble
A reference to this plot for functional chaining.
The chart this plot belongs to.
An optional keyword arguments object to help define the plot.
The data series array to be drawn on this plot.
Object
Returns an object in the form of { hmin, hmax, vmin, vmax }.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.Candlesticks
A reference to this plot for functional chaining.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.ClusteredBars
A reference to this plot for functional chaining.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.ClusteredColumns
A reference to this plot for functional chaining.
The chart this plot belongs to.
An optional keyword arguments object to help define the plot.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.Columns
A reference to this plot for functional chaining.
The horizontal axis name.
The vertical axis name
Whether or not to draw lines on this plot. Defaults to true.
Whether or not to draw areas on this plot. Defaults to false.
Whether or not to draw markers at data points on this plot. Default is false.
Whether or not to apply 'tensioning' to the lines on this chart.
Options include a number, "X", "x", or "S"; if a number is used, the
simpler bezier curve calculations are used to draw the lines. If X, x or S
is used, the more accurate smoothing algorithm is used.
Whether or not to animate the chart to place.
An optional stroke to use for any series on the plot.
An optional stroke used to outline any series on the plot.
An optional stroke to use to draw any shadows for a series on a plot.
Any fill to be used for elements on the plot (such as areas).
A font definition to be used for labels and other text-based elements on the plot.
The color to be used for any text-based elements on the plot.
An optional stroke to use for any markers on the plot.
An optional outline to use for any markers on the plot.
An optional shadow to use for any markers on the plot.
An optional fill to use for any markers on the plot.
An optional font definition to use for any markers on the plot.
An optional color to use for any marker text on the plot.
The chart this plot belongs to.
An optional arguments object to help define this plot.
An object of the form { width, height }
An object of the form { l, r, t, b }
dojox.charting.plot2d.Default
A reference to this plot for functional chaining.
Whether to show lines at the major ticks along the horizontal axis. Default is true.
Whether to show lines at the minor ticks along the horizontal axis. Default is false.
Whether to show lines at the major ticks along the vertical axis. Default is true.
Whether to show lines at the major ticks along the vertical axis. Default is false.
Whether or not to show stripes (alternating fills) along the horizontal axis. Default is "none".
Whether or not to show stripes (alternating fills) along the vertical axis. Default is "none".
The chart this plot belongs to.
An optional keyword arguments object to help define the parameters of the underlying grid.
dojox.charting.plot2d.Grid
The reference to this plot for functional chaining.
dojox.charting.plot2d.Grid
The reference to this plot for functional chaining.
dojox.charting.plot2d.Grid
The reference to this plot for functional chaining.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
Boolean
If this plot needs to be rendered, this will return true.
An object of the form { width, height }.
An object of the form { l, r, t, b }.
dojox.charting.plot2d.Grid
A reference to this plot for functional chaining.
Number
Returns 0, since there are no series associated with this plot type.
An object of the form { width, height }.
An object of the form { l, r, t, b }.
dojox.charting.plot2d.Grid
A reference to this plot for functional chaining.
The chart this plot belongs to.
An optional keyword arguments object to help define the plot.
The data series array to be drawn on this plot.
Object
Returns an object in the form of { hmin, hmax, vmin, vmax }.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.OHLC
A reference to this plot for functional chaining.
Whether or not to draw labels within each pie slice. Default is true.
Whether or not to draw ticks to labels within each slice. Default is false.
TODO
The precision at which to sum/add data values. Default is 1.
The amount in pixels by which to offset labels. Default is 20.
Options as to where to draw labels. Values include "default", "rows", and "auto". Default is "default".
default/rows/auto
Whether or not to use HTML to render slice labels. Default is true.
The type of radial gradient to use in rendering. Default is "native".
The amount for a radial gradient. Default is 5.
Where to being rendering gradients in slices, in degrees. Default is 0.
The size of the radial gradient. Default is 0.
dojox.charting.plot2d.Pie
A reference to this plot for functional chaining.
dojox.charting.plot2d.Pie
The reference to this plot for functional chaining.
dojox.charting.plot2d.Pie
The reference to this plot for functional chaining.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object of the form { width, height }.
An object of the form { l, r, t, b }.
dojox.charting.plot2d.Pie
A reference to this plot for functional chaining.
The chart this plot belongs to.
An optional keyword arguments object to help define this plot's parameters.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.Scatter
A reference to this plot for functional chaining.
dojox.charting.plot2d.Spider
A reference to this plot for functional chaining.
dojox.charting.plot2d.Spider
The reference to this plot for functional chaining.
The series to be added.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object of the form { width, height }
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
Number
The number of colors needed.
Size of a plot area in pixels as {width, height}.
Min/max of data in both directions as {hmin, hmax, vmin, vmax}.
dojox.charting.plot2d.Base
A reference to this plot for functional chaining.
An object of the form { width, height }.
An object of the form { l, r, t, b }.
dojox.charting.plot2d.Spider
A reference to this plot for functional chaining.
An object intended to represent event parameters.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.Stacked
A reference to this plot for functional chaining.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.StackedBars
A reference to this plot for functional chaining.
Object
{hmin, hmax, vmin, vmax} min/max in both directions.
An object in the form of { width, height }
An object of the form { l, r, t, b}.
dojox.charting.plot2d.StackedColumns
A reference to this plot for functional chaining.
An object intended to represent event parameters.
An object intended to represent event parameters.
The object to connect to.
The method to fire when our plotEvent is fired.
Array
The handle as returned from dojo.connect (see dojo.connect).
Boolean
A flag indicating that there are handlers attached.
Series name.
Event name to emulate.
Valid data value index used to raise an event.
Optional event object. Especially useful for synthetic events.
Default: null.
Color to use to generate gradients.
Array of tuples {o, i}, where o is a gradient offset (0-1),
and i is an intensity (0-255).
Array of colors to generate gradients for each.
Gradient fill descriptor which colors list will be generated.
Initial luminance value (0-100).
Final luminance value (0-100).
Array of mini-themes (usually series themes or marker themes), which fill will be transformed.
Gradient fill descriptor which colors list will be generated.
Initial luminance value (0-100).
Final luminance value (0-100).
Array of colors to generate gradients for each.
Gradient fill descriptor which colors list will be generated.
Initial luminance value (0-100).
Final luminance value (0-100).
Stroke luminance value (0-100).
Resize the domNode and the widget surface to the dimensions of a box of the following form:
`{ l: 50, t: 200, w: 300: h: 150 }`
If no box is provided, resize the surface to the marginBox of the domNode.
passed, denotes the new size of the widget.
Rounds to the nearest value with the given number of decimal places, away from zero if equal,
similar to Number.toFixed(). Rounding can be done by fractional increments also.
Makes minor adjustments to accommodate for precision errors due to binary floating point representation
of Javascript Numbers. See http://speleotrove.com/decimal/decifaq.html for more information.
Because of this adjustment, the rounding may not be mathematically correct for full precision
floating point values. The calculations assume 14 significant figures, so the accuracy will
be limited to a certain number of decimal places preserved will vary with the magnitude of
the input. This is not a substitute for decimal arithmetic.
>>> 4.8-(1.1+2.2)
1.4999999999999996
>>> Math.round(4.8-(1.1+2.2))
1
>>> dojox.math.round(4.8-(1.1+2.2))
2
>>> ((4.8-(1.1+2.2))/100)
0.014999999999999996
>>> ((4.8-(1.1+2.2))/100).toFixed(2)
"0.01"
>>> dojox.math.round((4.8-(1.1+2.2))/100,2)
0.02
>>> dojox.math.round(10.71, 0, 2.5)
10.75
>>> dojo.number.round(162.295, 2)
162.29
>>> dojox.math.round(162.295, 2)
162.3
The number to round
The number of decimal places where rounding takes place. Defaults to 0 for whole rounding.
Must be non-negative.
Rounds next place to nearest value of increment/10. 10 by default.
A Palette is a representation of a set of colors. While the standard
number of colors contained in a palette is 5, it can really handle any
number of colors.
A palette is useful for the ability to transform all the colors in it
using a simple object-based approach. In addition, you can generate
palettes using dojox.color.Palette.generate; these generated palettes
are based on the palette generators at http://kuler.adobe.com.
{palette}.transform is a simple way to uniformly transform
all of the colors in a palette using any of 5 formulae:
RGBA, HSL, HSV, CMYK or CMY.
Once the forumula to be used is determined, you can pass any
number of parameters based on the formula "d"[param]; for instance,
{ use: "rgba", dr: 20, dg: -50 } will take all of the colors in
palette, add 20 to the R value and subtract 50 from the G value.
Unlike other types of transformations, transform does *not* alter
the original palette but will instead return a new one.
The actual color references in this palette.
Specify the color model to use for the transformation. Can be "rgb", "rgba", "hsv", "hsl", "cmy", "cmyk".
The delta to be applied to the red aspect of the RGB/RGBA color model.
The delta to be applied to the green aspect of the RGB/RGBA color model.
The delta to be applied to the blue aspect of the RGB/RGBA color model.
The delta to be applied to the alpha aspect of the RGBA color model.
The delta to be applied to the cyan aspect of the CMY/CMYK color model.
The delta to be applied to the magenta aspect of the CMY/CMYK color model.
The delta to be applied to the yellow aspect of the CMY/CMYK color model.
The delta to be applied to the black aspect of the CMYK color model.
The delta to be applied to the hue aspect of the HSL/HSV color model.
The delta to be applied to the saturation aspect of the HSL/HSV color model.
The delta to be applied to the luminosity aspect of the HSL color model.
The delta to be applied to the value aspect of the HSV color model.
The base color to be used to generate the palette.
The base color to be used to generate the palette.
The difference between the hue of the base color and the highest hue. In degrees, default is 60.
The difference between the hue of the base color and the lowest hue. In degrees, default is 18.
The base color to be used to generate the palette.
The delta angle to be used to determine where the split for the complementary rules happen.
In degrees, the default is 30.
arguments:
The *autoSubscribeRoot* parameter:
When this is set, all REST service requests that have this
prefix will be auto-subscribed. The default is '/' (all REST requests).
The *url* parameter:
This is the url to connect to for server-sent messages. The default
is "/channels".
The *autoReconnectTime* parameter:
This is amount time to wait to reconnect with a connection is broken
The *reloadDataOnReconnect* parameter:
This indicates whether RestChannels should re-download data when a connection
is restored (value of true), or if it should re-subscribe with retroactive subscriptions
(Subscribe-Since header) using HEAD requests (value of false). The
default is true.
Note that if there is no connection open, this is automatically called when you do a subscription,
it is often not necessary to call this
the uri for the resource you want to monitor
See dojo.xhr
headers:
These are the headers to be applied to the channel subscription request
callback:
This will be called when a event occurs for the channel
The callback will be called with a single argument:
callback(message)
where message is an object that follows the XHR API:
status : Http status
statusText : Http status text
getAllResponseHeaders() : The response headers
getResponseHeaders(headerName) : Retrieve a header by name
responseText : The response body as text
with the following additional Bayeux properties
data : The response body as JSON
channel : The channel/url of the response
This does a simple POST operation to the provided URL,
POST is the semantic equivalent of publishing a message within REST/Channels
path to publish to
to publish
cometd/XHR message
Initialize the cometd implementation of the Bayeux protocol by
sending a handshake message. The cometd state will be changed to CONNECTING
until a handshake response is received and the first successful connect message
has returned.
The protocol state changes may be monitored
by subscribing to the dojo topic "/prefix/meta" (typically "/cometd/meta") where
events are published in the form
{cometd:this,action:"handshake",successful:true,state:this.state()}
dojox.cometd.init("/cometd");
dojox.cometd.init("http://xdHost/cometd",{ext:{user:"fred",pwd:"secret"}});
The URL of the cometd server. If the root is absolute, the host
is examined to determine if xd transport is needed. Otherwise the
same domain is assumed.
An optional object that is used as the basis of the handshake message
An optional object of bind args mixed in with the send of the handshake
the destination channel for the message
a JSON object containing the message "payload"
properties:
Optional. Other meta-data to be mixed into the top-level of the
message
`dojox.cometd.subscribe()` handles all the hard work of telling
the server that we want to be notified when events are
published on a particular topic. `subscribe` accepts a function
to handle messages and returns a `dojo.Deferred` object which
has an extra property added to it which makes it suitable for
passing to `dojox.cometd.unsubscribe()` as a "subscription
handle" (much like the handle object that `dojo.connect()`
produces and which `dojo.disconnect()` expects).
Note that of a subscription is registered before a connection
with the server is established, events sent before the
connection is established will not be delivered to this client.
The deferred object which `subscribe` returns will callback
when the server successfuly acknolwedges receipt of our
"subscribe" request.
Simple subscribe use-case
dojox.cometd.init("http://myserver.com:8080/cometd");
// log out all incoming messages on /foo/bar
dojox.cometd.subscribe("/foo/bar", console, "debug");
Subscribe before connection is initialized
dojox.cometd.subscribe("/foo/bar", console, "debug");
dojox.cometd.init("http://myserver.com:8080/cometd");
Subscribe an unsubscribe
dojox.cometd.init("http://myserver.com:8080/cometd");
var h = dojox.cometd.subscribe("/foo/bar", console, "debug");
dojox.cometd.unsubscribe(h);
Listen for successful subscription:
dojox.cometd.init("http://myserver.com:8080/cometd");
var h = dojox.cometd.subscribe("/foo/bar", console, "debug");
h.addCallback(function(){
console.debug("subscription to /foo/bar established");
});
name of the cometd channel to subscribe to
an object scope for funcName or the name or reference to a
function to be called when messages are delivered to the
channel
the second half of the objOrFunc/funcName pair for identifying
a callback function to notifiy upon channel message delivery
name of the cometd channel to unsubscribe from
an object scope for funcName or the name or reference to a
function to be called when messages are delivered to the
channel. If null then all subscribers to the channel are unsubscribed.
the second half of the objOrFunc/funcName pair for identifying
a callback function to notifiy upon channel message delivery
Disconnect from the server by sending a disconnect message
dojox.cometd.disconnect();
the function to call when the timeout occurs
atTimeOrTime:
a long timestamp or a Date representing the server time at
which the timeout should occur.
Look for ext:{timesync:{}} field and calculate offset if present.
The incoming bayeux message
Look for handshake and connect messages and add the ext:{timesync:{}} fields
outgoing bayeux message
Fades out an element and scales it to args.endScale
Scales an element to args.endScale
Shrinks an element, same as expand({ node: node, endScale: .01 });
Rotates an element from args.startAngle to args.endAngle
Flips an element around his y axis. The default is a 360deg flip
but it's possible to run a partial flip using args.whichAnims
// half flip
dojox.css3.fx.flip({
node: domNode,
whichAnim: [0, 1]
}).play();
Vertical bounce animation, the scaleX, scaleY deformation and the
jump height (args.jumpHeight) can be specified
Example:
dojo.connect(window,"onMessage",null,function(event) {
var data = dojo.fromJson(event.data);
dojox.restListener(data);
});
typeMap: object)
The structure of the typeMap object is as follows:
{
type0: function || object,
type1: function || object,
...
typeN: function || object
}
Where if it is a function, it is assumed to be an object constructor that takes the
value of _value as the initialization parameters. If it is an object, then it is assumed
to be an object of general form:
{
type: function, //constructor.
deserialize: function(value) //The function that parses the value and constructs the object defined by type appropriately.
}
The item to test for being contained by the store.
The attribute to test for being contained by the store.
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
The query options parameter, if any.
|| keywordArgs || null
Function to parse the loaded data into item format and build the internal items array.
The JS data object containing the raw data to convery into item format.
array
Array of items in store item format.
Method to add an reference map entry for an item and attribute. //
The item that is referenced.
The item that holds the new reference to refItem.
The attribute on parentItem that contains the new reference.
typeMap: object)
The structure of the typeMap object is as follows:
{
type0: function || object,
type1: function || object,
...
typeN: function || object
}
Where if it is a function, it is assumed to be an object constructor that takes the
value of _value as the initialization parameters. It is serialized assuming object.toString()
serialization. If it is an object, then it is assumed
to be an object of general form:
{
type: function, //constructor.
deserialize: function(value) //The function that parses the value and constructs the object defined by type appropriately.
serialize: function(object) //The function that converts the object back into the proper file format form.
}
anything
Method to add an reference map entry for an item and attribute. //
The item that is referenced.
The item that holds the new reference to refItem.
The attribute on parentItem that contains the new reference.
Method to remove an reference map entry for an item and attribute. This will
also perform cleanup on the map such that if there are no more references at all to
the item, its reference object and entry are removed.
The item that is referenced.
The item holding a reference to refItem.
The attribute on parentItem that contains the reference.
Function to dump the reverse reference map of all items in the store for debug purposes.
array or object to examine.
| array
| array
Over-ride of base close function of ItemFileReadStore to add in check for store state.
If the store is still dirty (unsaved changes), then an error will be thrown instead of
clearing the internal state for reload from the url.
The APP Store is instantiated either in markup or programmatically by supplying a
url of the Collection to be used.
The APP Store is instantiated either in markup or programmatically by supplying a
url of the Collection to be used.
An anonymous object to initialize properties. It expects the following values:
Sets the internal feed using a dojox.atom.io.model.Feed object. Also adds
a property to the entries to track that they belong to this store. It
also parses stored requests (since we were waiting on a callback) and
executes those as well.
object
The Feed to use for this data store.
Signature for this function is defined by AtomIO.getFeed, since this is a callback.
Function to return all entries in the Feed as an array of items.
Array of all entries in the feed.
This function tests whether the item passed in is indeed an item
in the store.
The item to test for being contained by the store.
This function tests whether the item passed in is indeed a valid
'attribute' like type for the store.
The attribute to test for being contained by the store.
Returns a boolean indicating whether this is a valid attribute.
Internal function to add an updated entry to our updates array
dojox.atom.io.model.Entry object
The updated Entry we've changed.
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
Fetch items (Atom entries) that match to a query
request object
function to call for fetched items
function to call on error
Internal function for finishing a fetch request. Needed since the feed
might not have been loaded, so we finish the fetch in a callback.
request object
function to call for fetched items
function to call on error
|| keywordArgs || null
anything
{ onComplete: function
onError: function
scope: object
}
string So the parser can instantiate the store via markup.
boolean Whether or not to pass the preventCache parameter to the connection
Whether to use X-Method-Override for PUT/DELETE.
A data store for Atom XML based services or documents. This store is still under development
and doesn't support wildcard filtering yet. Attribute filtering is limited to category or id.
An anonymous object to initialize properties. It expects the following values:
'item' must be an instance of an object created by the AtomReadStore instance.
Accepted attributes are id, subtitle, title, summary, content, author, updated,
published, category, link and alternate
An item returned by a call to the 'fetch' method.
A attribute of the Atom Entry
A default value
An attribute value found, otherwise 'defaultValue'
'item' must be an instance of an object created by the AtomReadStore instance.
Accepted attributes are id, subtitle, title, summary, content, author, updated,
published, category, link and alternate
An item returned by a call to the 'fetch' method.
A attribute of the Atom Entry
An array of values for the attribute value found, otherwise 'defaultValue'
'item' must be have been created by the AtomReadStore instance.
tag names of child elements and XML attribute names of attributes
specified to the element are returned along with special attribute
names applicable to the element including "tagName", "childNodes"
if the element has child elements, "text()" if the element has
child text nodes, and attribute names in '_attributeMap' that match
the tag name of the element.
An XML element
An array of attributes found
'item' must be created by the AtomReadStore instance.
An attribute of an Atom Entry item.
True if the element has the attribute, otherwise false
'item' must be an instance of a dojox.data.XmlItem from the store instance.
A tag name of a child element, An XML attribute name or one of
special names
True if the attribute values contain the value, otherwise false
True if the object is an XML element, otherwise false
True if the object is an XML element, otherwise false
containing the args for loadItem. See dojo.data.api.Read.loadItem()
"dojo.data.api.Read" and "dojo.data.api.Write"
|| keywordArgs || null
The item to test for being contained by the store.
The attribute to test for being contained by the store.
url to a service or an XML document that represents the store
boolean indicate to add a query string to the service URL
boolean to specify whether or not to unescape HTML text
The store always loads all items, so if it's an item, then it's loaded.
Returns an Array of items based on the request arguments.
If the store is in ASYNC mode, the items should be expected in an onComplete
method passed in the request object. If store is in SYNC mode, the items will
be return directly as well as within the onComplete method.
note:
The mode can be set on store initialization or during a fetch as one of the
parameters.
query: String
The items in the store are treated as objects, but this is reading an XML
document. Further, the actual querying of the items takes place in Tibco GI's
jsx3.xml.Entity. Therefore, we are using their syntax which is xpath.
Note:
As conforming to a CDF document, most, if not all nodes are considered "records"
and their tagNames are as such. The root node is named "data".
examples:
All items:
store.fetch({query:"*"});
Item with a jsxid attribute equal to "1" (note you could use byId for this)
store.fetch({query:"//record[@jsxid='1']"});
All items with any jsxid attribute:
"//record[@jsxid='*']"
The items with a jsxid of '1' or '4':
"//record[@jsxid='4' or @jsxid='1']"
All children within a "group" node (could be multiple group nodes):
"//group/record"
All children within a specific group node:
"//group[@name='mySecondGroup']/record"
Any record, anywhere in the document:
"//record"
Only the records beneath the root (data) node:
"//data/record"
See:
http://www.tibco.com/devnet/resources/gi/3_7/api/html/jsx3/xml/Entity.html#method:selectNodes
http://www.w3.org/TR/xpath
http://msdn.microsoft.com/en-us/library/ms256086.aspx
See dojo.data.Read.fetch():
onBegin
onComplete
onItem
onError
scope
start
count
sort
|| keywordArgs || null
|| String?
anything
?
|| String
|| String
The unique identifier for each item. Defaults to "jsxid" which is standard for a CDF
document. Should not be changed.
url : String
The location from which to fetch the XML (CDF) document.
A string that can be parsed into an XML document and should be formatted according
to the CDF spec.
A object that will be converted into the xmlStr property, and then parsed into a CDF.
The property within each item used to define the item.
mode [const]: dojox.data.ASYNC_MODE | dojox.data.SYNC_MODE
This store supports syncronous fetches if this property is set to dojox.data.SYNC_MODE.
To a update a result set after a notification (onNew, onSet, and onDelete),
widgets can call the updateResultSet method. Widgets can use the updated
result sets to determine how to react to notifications, and how to update their displayed results
based on changes.
This module will use the best available information to update result sets, using query attribute
objects to determine if items are in a result set, and using the sort arrays to maintain sort
information. However, queries can be opaque strings, and this module can not update
results by itself in this case. In this situations, data stores can provide a isUpdateable(request) function
and matchesQuery(item,request) function. If a data store can handle a query, it can return true from
isUpdateable and if an item matches a query, it can return true from matchesQuery. Here is
definition of isUpdateable and matchesQuery
isUpdateable(request) - request is the keywords arguments as is passed to the fetch function.
matchesQuery(item,request) - item is the item to test, and request is the value arguments object
for the fetch function.
You can define a property on this object instance "cacheByDefault" to a value of true that will
cause all queries to be cached by default unless the cache queryOption is explicitly set to false.
This can be defined in the constructor options for ServiceStore/JsonRestStore and subtypes.
To a update a result set after a notification (onNew, onSet, and onDelete),
widgets can call the updateResultSet method. Widgets can use the updated
result sets to determine how to react to notifications, and how to update their displayed results
based on changes.
This module will use the best available information to update result sets, using query attribute
objects to determine if items are in a result set, and using the sort arrays to maintain sort
information. However, queries can be opaque strings, and this module can not update
results by itself in this case. In this situations, data stores can provide a isUpdateable(request) function
and matchesQuery(item,request) function. If a data store can handle a query, it can return true from
isUpdateable and if an item matches a query, it can return true from matchesQuery. Here is
definition of isUpdateable and matchesQuery
isUpdateable(request) - request is the keywords arguments as is passed to the fetch function.
matchesQuery(item,request) - item is the item to test, and request is the value arguments object
for the fetch function.
You can define a property on this object instance "cacheByDefault" to a value of true that will
cause all queries to be cached by default unless the cache queryOption is explicitly set to false.
This can be defined in the constructor options for ServiceStore/JsonRestStore and subtypes.
to make a updated-result-set data store from an existing data store:
dojo.declare("dojox.data.MyLiveDataStore",
dojox.data.MyDataStore,dojox.data.ClientFilter], // subclass LiveResultSets if available
{}
);
This will attempt to update the provide result based on previous notification, adding new items
from onNew calls, removing deleted items, and updating modified items, and properly removing
and adding items as required by the query and sort parameters. This function will return:
0: Indicates it could not successfully update the result set
1: Indicates it could successfully handle all the notifications, but no changes were made to the result set
2: Indicates it successfully handled all the notifications and result set has been updated.
The result set array that should be updated
This object follows the same meaning as the keywordArgs passed to a dojo.data.api.Read.fetch.
Data Fetch arguments
Data Fetch arguments
See dojo.data.api.Read.fetch request
See dojo.data.api.Read.fetch request
This provides the result set to start with for client side querying
dojox.data.api.Read.fetch
The CssClassStore allows users to get information about active Css classes in the page running the CssClassStore.
It can also filter out classes from specific stylesheets. The attributes it exposes on classes are as follows:
class: The classname, including the '.'.
classSans: The classname without the '.'.
The CssRuleStore allows users to get information about active CSS rules in the page running the CssRuleStore.
It can also filter out rules from specific stylesheets. The attributes it exposes on rules are as follows:
selector: The selector text.
classes: An array of classes present in this selector.
rule: The actual DOM Rule object.
style: The actual DOM CSSStyleDeclaration object.
cssText: The cssText string provided on the rule object.
styleSheet: The originating DOM Stylesheet object.
parentStyleSheet: The parent stylesheet to the sheet this rule originates from.
parentStyleSheetHref: The href of the parent stylesheet.
AND every style attribute denoted as style.*, such as style.textAlign or style.backgroundColor
- Array of CSS string paths to execute queries within
The item to test for being contained by the store.
The attribute to test for being contained by the store.
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
identifier: String} The column label for the column to use for the identity. Optional. If not set, the identity is the row number.
The item to test for being contained by the store.
idem handle to get the index for.
|| attribute-name-string
|| attribute-name-string
|| attribute-name-string
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
The CsvStore always loads all items, so if it's an item, then it's loaded.
From the dojo.data.api.Read.loadItem docs:
If a call to isItemLoaded() returns true before loadItem() is even called,
then loadItem() need not do any work at all and will not even invoke
the callback handlers.
|| keywordArgs || null
The CSV data.
The identity
Declarative hook for setting Csv source url.
Declarative hook for setting the label attribute.
Declarative hook for setting the identifier.
Parameter to allow specifying if preventCache should be passed to
the xhrGet call or not when loading data from a url.
Note this does not mean the store calls the server on each fetch,
only that the data load has preventCache set as an option.
A simple store that provides a datastore interface to a filesystem. It takes a few parameters
for initialization:
A simple store that provides a datastore interface to a filesystem. It takes a few parameters
for initialization:
options="expand,dirsOnly,showHiddenFiles"
The item to test for being contained by the store.
The attribute to test for being contained by the store.
request object
string The URL to the file path service.
Internal variable used to denote an item came from this store instance.
string Default attribute to use to represent the item as a user-readable
string. Public, so users can change it.
Default attribute to use to represent the item's identifier.
Path should always be unique in the store instance.
Internal variable of attributes all file items should have.
The path separator to use when chaining requests for children
Can be overriden by the server on initial load
Array of options to always send when doing requests.
Back end service controls this, like 'dirsOnly', 'showHiddenFiles', 'expandChildren', etc.
Flag to pass on to xhr functions to check if we are OK to fail the call silently
Flag to dennote if preventCache should be passed to xhrGet.
Function to switch between REST style URL lookups and passing the path to specific items as a query param: 'path'.
The FlickrRestStore is a Datastore interface to one of the basic services
of the Flickr service, the public photo feed. This does not provide
access to all the services of Flickr.
This store cannot do * and ? filtering as the flickr service
provides no interface for wildcards.
The FlickrRestStore is a Datastore interface to one of the basic services
of the Flickr service, the public photo feed. This does not provide
access to all the services of Flickr.
This store cannot do * and ? filtering as the flickr service
provides no interface for wildcards.
A request object
A function to call for fetched items
A function to call on error
Data returned from Flickr
The original dojo.data.Request object passed in by the user.
A unique identifier for this store.
A counter for the number of requests made. This is used to define
the callback function that Flickr will use.
The URL to the Flickr REST services.
The users API key to be used when accessing Flickr REST services.
A key used to mark an data store item as belonging to this store.
An Array of all previously downloaded picture info.
A HashMap used to record the signature of a request to prevent duplicate
request being made.
A HashMap used to record the handlers registered for a single remote request. Multiple
requests may be made for the same information before the first request has finished.
Each element of this Object is an array of handlers to call back when the request finishes.
This prevents multiple requests being made for the same information.
The FlickrStore is a Datastore interface to one of the basic services
of the Flickr service, the public photo feed. This does not provide
access to all the services of Flickr.
This store cannot do * and ? filtering as the flickr service
provides no interface for wildcards.
The FlickrStore is a Datastore interface to one of the basic services
of the Flickr service, the public photo feed. This does not provide
access to all the services of Flickr.
This store cannot do * and ? filtering as the flickr service
provides no interface for wildcards.
The item to test for being contained by the store.
The attribute to test for being contained by the store.
request object
function to call for fetched items
function to call on error
String. The string to un-escape
HTML String converted back to the normal text (unescaped)
characters (<,>,&, ", etc,).
The GoogleSearchStore is a Datastore interface to
the Google search service. The constructor accepts the following arguments:
<ul>
<li>label - the label attribute to use. Defaults to titleNoFormatting</li>
<li>key - The API key to use. This is optional</li>
<li>lang - The language locale to use. Defaults to the browser locale</li>
</ul>
The GoogleSearchStore is a Datastore interface to
the Google search service. The constructor accepts the following arguments:
<ul>
<li>label - the label attribute to use. Defaults to titleNoFormatting</li>
<li>key - The API key to use. This is optional</li>
<li>lang - The language locale to use. Defaults to the browser locale</li>
</ul>
The item to test for being contained by the store.
The attribute to test for being contained by the store.
request object
fetchHandler:
A function to call for fetched items
errorHandler:
A function to call on error
A unique identifier for this store.
A counter for the number of requests made. This is used to define
the callback function that GoogleSearchStore will use.
The URL to Googles search web service.
The internal reference added to each item pointing at the store which owns it.
The list of attributes that this store supports
The default attribute which acts as a label for each item.
Sets whether or not to pass preventCache to dojo.io.script.
The HtmlStore can be created in one of two ways: a) by parsing an existing
table or list DOM node on the current page or b) by referencing an external url and giving
the id of the table or list in that page. The remote url will be parsed as an html page.
The HTML table or list should be of the following form:
<table id="myTable">
<thead>
<tr>
<th>Attribute1</th>
<th>Attribute2</th>
</tr>
</thead>
<tbody>
<tr>
<td>Value1.1</td>
<td>Value1.2</td>
</tr>
<tr>
<td>Value2.1</td>
<td>Value2.2</td>
</tr>
</tbody>
</table>
-or-
<ul id="myUnorderedList">
<li>Value.1</li>
<li>Value.2</li>
</ul>
-or-
<ol id="myOrderedList">
<li>Value.1</li>
<li>Value.2</li>
</ol>
The HtmlStore can be created in one of two ways: a) by parsing an existing
table or list DOM node on the current page or b) by referencing an external url and giving
the id of the table or list in that page. The remote url will be parsed as an html page.
The HTML table or list should be of the following form:
<table id="myTable">
<thead>
<tr>
<th>Attribute1</th>
<th>Attribute2</th>
</tr>
</thead>
<tbody>
<tr>
<td>Value1.1</td>
<td>Value1.2</td>
</tr>
<tr>
<td>Value2.1</td>
<td>Value2.2</td>
</tr>
</tbody>
</table>
-or-
<ul id="myUnorderedList">
<li>Value.1</li>
<li>Value.2</li>
</ul>
-or-
<ol id="myOrderedList">
<li>Value.1</li>
<li>Value.2</li>
</ol>
An anonymous object to initialize properties. It expects the following values:
The item to test for being contained by the store.
The attribute to test for being contained by the store.
Returns the index (column) that the attribute resides in the row.
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
If '_fetchUrl' is specified, it is used to load an XML document
with a query string.
Otherwise and if 'url' is specified, the XML document is
loaded and list XML elements that match to a query (set of element
names and their text attribute values that the items to contain).
A wildcard, "*" can be used to query values to match all
occurrences.
If '_rootItem' is specified, it is used to fetch items.
request object
function to call for fetched items
function to call on error
|| keywordArgs || null
string The URL from which to load an HTML document for data loading
string The id in the document for an element from which to get the data.
off any surrounding whitespace from the headers (attribute
names) and text content of the items in question. Default is false for
backwards compatibility.
Flag to denote if peventCache should be used on xhrGet calls.
Flag to denote if it should try to load from a data id (nested in the page)
The moment the store is created, instead of waiting for first
fetch call.
The item to test for being contained by the store.
The attribute to test for being contained by the store.
Returns the index (column) that the attribute resides in the row.
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
If '_fetchUrl' is specified, it is used to load an XML document
with a query string.
Otherwise and if 'url' is specified, the XML document is
loaded and list XML elements that match to a query (set of element
names and their text attribute values that the items to contain).
A wildcard, "*" can be used to query values to match all
occurrences.
If '_rootItem' is specified, it is used to fetch items.
request object
function to call for fetched items
function to call on error
|| keywordArgs || null
The URL from which to load an HTML document for data loading
The id of the table to load as store contents.
The JsonRestStore will cause all saved modifications to be sent to the server using Rest commands (PUT, POST, or DELETE).
When using a Rest store on a public network, it is important to implement proper security measures to
control access to resources.
On the server side implementing a REST interface means providing GET, PUT, POST, and DELETE handlers.
GET - Retrieve an object or array/result set, this can be by id (like /table/1) or with a
query (like /table/?name=foo).
PUT - This should modify a object, the URL will correspond to the id (like /table/1), and the body will
provide the modified object
POST - This should create a new object. The URL will correspond to the target store (like /table/)
and the body should be the properties of the new object. The server's response should include a
Location header that indicates the id of the newly created object. This id will be used for subsequent
PUT and DELETE requests. JsonRestStore also includes a Content-Location header that indicates
the temporary randomly generated id used by client, and this location is used for subsequent
PUT/DELETEs if no Location header is provided by the server or if a modification is sent prior
to receiving a response from the server.
DELETE - This should delete an object by id.
These articles include more detailed information on using the JsonRestStore:
http://www.sitepen.com/blog/2008/06/13/restful-json-dojo-data/
http://blog.medryx.org/2008/07/24/jsonreststore-overview/
The JsonRestStore will cause all saved modifications to be sent to the server using Rest commands (PUT, POST, or DELETE).
When using a Rest store on a public network, it is important to implement proper security measures to
control access to resources.
On the server side implementing a REST interface means providing GET, PUT, POST, and DELETE handlers.
GET - Retrieve an object or array/result set, this can be by id (like /table/1) or with a
query (like /table/?name=foo).
PUT - This should modify a object, the URL will correspond to the id (like /table/1), and the body will
provide the modified object
POST - This should create a new object. The URL will correspond to the target store (like /table/)
and the body should be the properties of the new object. The server's response should include a
Location header that indicates the id of the newly created object. This id will be used for subsequent
PUT and DELETE requests. JsonRestStore also includes a Content-Location header that indicates
the temporary randomly generated id used by client, and this location is used for subsequent
PUT/DELETEs if no Location header is provided by the server or if a modification is sent prior
to receiving a response from the server.
DELETE - This should delete an object by id.
These articles include more detailed information on using the JsonRestStore:
http://www.sitepen.com/blog/2008/06/13/restful-json-dojo-data/
http://blog.medryx.org/2008/07/24/jsonreststore-overview/
A JsonRestStore takes a REST service or a URL and uses it the remote communication for a
read/write dojo.data implementation. A JsonRestStore can be created with a simple URL like:
new JsonRestStore({target:"/MyData/"});
To use a JsonRestStore with a service, you should create a
service with a REST transport. This can be configured with an SMD:
{
services: {
jsonRestStore: {
transport: "REST",
envelope: "URL",
target: "store.php",
contentType:"application/json",
parameters: [
{name: "location", type: "string", optional: true}
]
}
}
}
The SMD can then be used to create service, and the service can be passed to a JsonRestStore. For example:
var myServices = new dojox.rpc.Service(dojo.moduleUrl("dojox.rpc.tests.resources", "test.smd"));
var jsonStore = new dojox.data.JsonRestStore({service:myServices.jsonRestStore});
The JsonRestStore also supports lazy loading. References can be made to objects that have not been loaded.
For example if a service returned:
{"name":"Example","lazyLoadedObject":{"$ref":"obj2"}}
And this object has accessed using the dojo.data API:
var obj = jsonStore.getValue(myObject,"lazyLoadedObject");
The object would automatically be requested from the server (with an object id of "obj2").
arguments
The *schema* parameter
This is a schema object for this store. This should be JSON Schema format.
The *service* parameter
This is the service object that is used to retrieve lazy data and save results
The function should be directly callable with a single parameter of an object id to be loaded
The function should also have the following methods:
put(id,value) - puts the value at the given id
post(id,value) - posts (appends) the value at the given id
delete(id) - deletes the value corresponding to the given id
Note that it is critical that the service parses responses as JSON.
If you are using dojox.rpc.Service, the easiest way to make sure this
happens is to make the responses have a content type of
application/json. If you are creating your own service, make sure you
use handleAs: "json" with your XHR requests.
The *target* parameter
This is the target URL for this Service store. This may be used in place
of a service parameter to connect directly to RESTful URL without
using a dojox.rpc.Service object.
The *idAttribute* parameter
Defaults to 'id'. The name of the attribute that holds an objects id.
This can be a preexisting id provided by the server.
If an ID isn't already provided when an object
is fetched or added to the store, the autoIdentity system
will generate an id for it and add it to the index.
The *syncMode* parameter
Setting this to true will set the store to using synchronous calls by default.
Sync calls return their data immediately from the calling function, so
callbacks are unnecessary
The data to be added in as an item.
to delete
The value to test for being an item
If true, this will return true if the value is an item for any JsonRestStore,
not just this instance
item to find the parent of
the JsonRestStore constructor
to use (for creating stores from JsonRestStore subclasses).
This is optional and defaults to JsonRestStore.
a string literal of a JSON item, for instance:
'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'
See resolveJson
return:
An object, the result of the evaluation
This indicates what property is the reference property. This acts like the idAttribute
except that this is used to indicate the current object is a reference or only partially
loaded. This defaults to "$ref".
dataVar: jsonObject}
The item to test for being contained by the store.
The attribute to test for being contained by the store.
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
The KeyValueStore always loads all items, so if it's an item, then it's loaded.
From the dojo.data.api.Read.loadItem docs:
If a call to isItemLoaded() returns true before loadItem() is even called,
then loadItem() need not do any work at all and will not even invoke
the callback handlers.
|| keywordArgs || null
Controls if urlPreventCache should be used with underlying xhrGet.
The OpenSearchStore is a Datastore interface to any search
engine that implements the open search specifications.
The OpenSearchStore is a Datastore interface to any search
engine that implements the open search specifications.
The item to test for being contained by the store.
The attribute to test for being contained by the store.
request object
function to call for fetched items
function to call on error
Flag denoting if xhrGet calls should use the preventCache option.
url: String, label: String} Where label is optional and configures what should be used as the return from getLabel()
The attribute to test for being contained by the store.
Internal function to recurse over all child nodes from the store and add them
As non-toplevel items
The child node to walk.
The query options parameter, if any.
|| attribute-name-string
|| attribute-name-string
|| attribute-name-string
|| attribute-name-string
Internal function for looking at the values contained by the item. This
function allows for denoting if the comparison should be case sensitive for
strings or not (for handling filtering cases where string case should not matter)
The data item to examine for attribute values.
The attribute to inspect.
The value to match.
Optional regular expression generated off value if value was of string type to handle wildcarding.
If present and attribute values are string, then it can be used for comparison instead of 'value'
Four things are verified to ensure that "something" is an item:
something can not be null, the nodeType must be an XML Element,
the tagName must be "outline", and the node must be a member of
XML document for this datastore.
The OpmlStore always loads all items, so if it's an item, then it's loaded.
From the dojo.data.api.Read.loadItem docs:
If a call to isItemLoaded() returns true before loadItem() is even called,
then loadItem() need not do any work at all and will not even invoke the callback handlers.
|| keywordArgs || null
The attribute of the Opml item to act as a label.
The location from which to fetch the Opml document.
Flag to denote if the underlying xhrGet call should set preventCache.
URL of the Persevere server's root, this normally just "/"
which is the default value if the target is not provided
Indicates that the operation should happen synchronously.
return:
A map/object of datastores will be returned if it is performed asynchronously,
otherwise it will return a Deferred object that will provide the map/object.
The name of each property is a the name of a store,
and the value is the actual data store object.
The PicasaStore is a Datastore interface to one of the basic services
of the Picasa service, the public photo feed. This does not provide
access to all the services of Picasa.
This store cannot do * and ? filtering as the picasa service
provides no interface for wildcards.
The PicasaStore is a Datastore interface to one of the basic services
of the Picasa service, the public photo feed. This does not provide
access to all the services of Picasa.
This store cannot do * and ? filtering as the picasa service
provides no interface for wildcards.
The item to test for being contained by the store.
The attribute to test for being contained by the store.
request object
function to call for fetched items
function to call on error
Utility function to un-escape XML special characters in an HTML string.
The string to un-escape
HTML String converted back to the normal text (unescaped) characters (<,>,&, ", etc,).
TODO: Check to see if theres already compatible escape() in dojo.string or dojo.html
The attribute to use from the picasa item as its label.
Flag denoting if preventCache should be passed to dojo.io.script.
out how many results to return for a fetch.
|| keywordArgs || null
data received from server
The item to test for being contained by the store.
The attribute to test for being contained by the store.
ServiceStore can do client side caching and result set updating if
dojox.data.ClientFilter is loaded. Do this add:
dojo.require("dojox.data.ClientFilter")
prior to loading the ServiceStore (ClientFilter must be loaded before ServiceStore).
To utilize client side filtering with a subclass, you can break queries into
client side and server side components by putting client side actions in
clientFilter property in fetch calls. For example you could override fetch:
fetch: function(args){
// do the sorting and paging on the client side
args.clientFilter = {start:args.start, count: args.count, sort: args.sort};
// args.query will be passed to the service object for the server side handling
return this.inherited(arguments);
}
When extending this class, if you would like to create lazy objects, you can follow
the example from dojox.data.tests.stores.ServiceStore:
var lazyItem = {
_loadObject: function(callback){
this.name="loaded";
delete this._loadObject;
callback(this);
}
};
setup a byId alias to the api call
ServiceStore can do client side caching and result set updating if
dojox.data.ClientFilter is loaded. Do this add:
dojo.require("dojox.data.ClientFilter")
prior to loading the ServiceStore (ClientFilter must be loaded before ServiceStore).
To utilize client side filtering with a subclass, you can break queries into
client side and server side components by putting client side actions in
clientFilter property in fetch calls. For example you could override fetch:
fetch: function(args){
// do the sorting and paging on the client side
args.clientFilter = {start:args.start, count: args.count, sort: args.sort};
// args.query will be passed to the service object for the server side handling
return this.inherited(arguments);
}
When extending this class, if you would like to create lazy objects, you can follow
the example from dojox.data.tests.stores.ServiceStore:
var lazyItem = {
_loadObject: function(callback){
this.name="loaded";
delete this._loadObject;
callback(this);
}
};
setup a byId alias to the api call
arguments
The *schema* parameter
This is a schema object for this store. This should be JSON Schema format.
The *service* parameter
This is the service object that is used to retrieve lazy data and save results
The function should be directly callable with a single parameter of an object id to be loaded
The *idAttribute* parameter
Defaults to 'id'. The name of the attribute that holds an objects id.
This can be a preexisting id provided by the server.
If an ID isn't already provided when an object
is fetched or added to the store, the autoIdentity system
will generate an id for it and add it to the index.
The *estimateCountFactor* parameter
This parameter is used by the ServiceStore to estimate the total count. When
paging is indicated in a fetch and the response includes the full number of items
requested by the fetch's count parameter, then the total count will be estimated
to be estimateCountFactor multiplied by the provided count. If this is 1, then it is assumed that the server
does not support paging, and the response is the full set of items, where the
total count is equal to the numer of items returned. If the server does support
paging, an estimateCountFactor of 2 is a good value for estimating the total count
It is also possible to override _processResults if the server can provide an exact
total count.
The *syncMode* parameter
Setting this to true will set the store to using synchronous calls by default.
Sync calls return their data immediately from the calling function, so
callbacks are unnecessary. This will only work with a synchronous capable service.
The item to get the value from
property to look up value for
the default value
property to look up value for
attribute: /* string
store.loadItem({
item: item, // this item may or may not be loaded
onItem: function(item){
// do something with the item
}
});
An object that contains properties for initializing the new data store object. The
following properties are understood:
The item to test for being contained by the store.
The attribute to test for being contained by the store.
The request/handle object used with the original fetch() call.
A value indicating which request this handler call is for (this.Parts).
Response received from the underlying IO transport.
See dojo.data.api.Read.close() for generic interface.
In addition to the standard Read API fetch support, this store supports an optimization for
for retrieving the total count of records in the Pipeline without retrieving the data. To
use this optimization, simply provide an onBegin handler without an onItem or onComplete handler.
URL to the SnapLogic pipeline's output routed through PipeToHttp. Typically, this
will look like "http://<server-host>:<port>/pipe/<pipeline-url>/<pipeline-output-view>".
parameters:
An object whose properties define parameters to the pipeline. The values of these
properties will be sent to the pipeline as parameters when it run.
The WikipediaStore is a data store interface to Wikipedia, using the
Wikipedia SMD spec from dojox.rpc. It currently is useful only for
finding articles that contain some particular text or grabbing single
articles by full name; no wildcards or other filtering are supported.
Loading a page:
store.fetch({
query: {title:"Dojo Toolkit"},
// define your handlers here
});
Searching for pages containing "dojo":
store.fetch({
query: {
action: "query",
text: "dojo"
},
// define your handlers here
});
Searching for the next 50 pages containing "dojo":
store.fetch({
query: {
action: "query",
text: "dojo",
start: 10,
count: 50 // max 500; will be capped if necessary
},
// define your handlers here
});
A data store for XML based services or documents
An anonymous object to initialize properties. It expects the following values:
'item' must be an instance of a dojox.data.XmlItem from the store instance.
If 'attribute' specifies "tagName", the tag name of the element is
returned.
If 'attribute' specifies "childNodes", the first element child is
returned.
If 'attribute' specifies "text()", the value of the first text
child is returned.
For generic attributes, if '_attributeMap' is specified,
an actual attribute name is looked up with the tag name of
the element and 'attribute' (concatenated with '.').
Then, if 'attribute' starts with "@", the value of the XML
attribute is returned.
Otherwise, the first child element of the tag name specified with
'attribute' is returned.
An XML element that holds the attribute
A tag name of a child element, An XML attribute name or one of
special names
A default value
An attribute value found, otherwise 'defaultValue'
'item' must be an instance of a dojox.data.XmlItem from the store instance.
If 'attribute' specifies "tagName", the tag name of the element is
returned.
If 'attribute' specifies "childNodes", child elements are returned.
If 'attribute' specifies "text()", the values of child text nodes
are returned.
For generic attributes, if 'attributeMap' is specified,
an actual attribute name is looked up with the tag name of
the element and 'attribute' (concatenated with '.').
Then, if 'attribute' starts with "@", the value of the XML
attribute is returned.
Otherwise, child elements of the tag name specified with
'attribute' are returned.
An XML element that holds the attribute
A tag name of child elements, An XML attribute name or one of
special names
An array of attribute values found, otherwise an empty array
'item' must be an instance of a dojox.data.XmlItem from the store instance.
tag names of child elements and XML attribute names of attributes
specified to the element are returned along with special attribute
names applicable to the element including "tagName", "childNodes"
if the element has child elements, "text()" if the element has
child text nodes, and attribute names in '_attributeMap' that match
the tag name of the element.
An XML element
An array of attributes found
'item' must be an instance of a dojox.data.XmlItem from the store instance.
A tag name of a child element, An XML attribute name or one of
special names
True if the element has the attribute, otherwise false
'item' must be an instance of a dojox.data.XmlItem from the store instance.
A tag name of a child element, An XML attribute name or one of
special names
True if the attribute values contain the value, otherwise false
True if the object is an XML element, otherwise false
True if the object is an XML element, otherwise false
containing the args for loadItem. See dojo.data.api.Read.loadItem()
"dojo.data.api.Read" and "dojo.data.api.Write"
If 'sendQuery' is true, an XML document is loaded from
'url' with a query string.
Otherwise, an XML document is loaded and list XML elements that
match to a query (set of element names and their text attribute
values that the items to contain).
A wildcard, "*" can be used to query values to match all
occurrences.
If 'rootItem' is specified, it is used to fetch items.
request object
function to call for fetched items
function to call on error
This default implementation generates a query string in the form of
"?name1=value1&name2=value2..." off properties of 'query' object
specified in 'request' and appends it to 'url', if 'sendQuery'
is set to false.
Otherwise, 'url' is returned as is.
Sub-classes may override this method for the custom URL generation.
request object
A fetch URL
This default implementation walks through child elements of
the document element to see if all properties of 'query' object
match corresponding attributes of the element (item).
If 'request' is not specified, all child elements are returned.
Sub-classes may override this method for the custom search in
an XML document.
XML document
request object
An array of items
|| keywordArgs || null
At least, 'keywordArgs' must contain "tagName" to be used for
the new element.
Other attributes in 'keywordArgs' are set to the new element,
including "text()", but excluding "childNodes".
An object containing initial attributes
An XML element
An XML element to delete
True
'item' must be an instance of a dojox.data.XmlItem from the store instance.
If 'attribute' specifies "tagName", nothing is set and false is
returned.
If 'attribute' specifies "childNodes", the value (XML element) is
added to the element.
If 'attribute' specifies "text()", a text node is created with
the value and set it to the element as a child.
For generic attributes, if '_attributeMap' is specified,
an actual attribute name is looked up with the tag name of
the element and 'attribute' (concatenated with '.').
Then, if 'attribute' starts with "@", the value is set to the XML
attribute.
Otherwise, a text node is created with the value and set it to
the first child element of the tag name specified with 'attribute'.
If the child element does not exist, it is created.
An XML element that holds the attribute
A tag name of a child element, An XML attribute name or one of
special names
A attribute value to set
False for "tagName", otherwise true
'item' must be an instance of a dojox.data.XmlItem from the store instance.
If 'attribute' specifies "tagName", nothing is set and false is
returned.
If 'attribute' specifies "childNodes", the value (array of XML
elements) is set to the element's childNodes.
If 'attribute' specifies "text()", a text node is created with
the values and set it to the element as a child.
For generic attributes, if '_attributeMap' is specified,
an actual attribute name is looked up with the tag name of
the element and 'attribute' (concatenated with '.').
Then, if 'attribute' starts with "@", the first value is set to
the XML attribute.
Otherwise, child elements of the tag name specified with
'attribute' are replaced with new child elements and their
child text nodes of values.
An XML element that holds the attribute
A tag name of child elements, an XML attribute name or one of
special names
value:
A attribute value to set
notify:
A non-API optional argument, used to indicate if notification API should be called
or not.
False for "tagName", otherwise true
'item' must be an instance of a dojox.data.XmlItem from the store instance.
'attribute' can be an XML attribute name of the element or one of
special names described below.
If 'attribute' specifies "tagName", nothing is removed and false is
returned.
If 'attribute' specifies "childNodes" or "text()", all child nodes
are removed.
For generic attributes, if '_attributeMap' is specified,
an actual attribute name is looked up with the tag name of
the element and 'attribute' (concatenated with '.').
Then, if 'attribute' starts with "@", the XML attribute is removed.
Otherwise, child elements of the tag name specified with
'attribute' are removed.
An XML element that holds the attribute
A tag name of child elements, an XML attribute name or one of
special names
False for "tagName", otherwise true
'url' is used to save XML documents for new, modified and/or
deleted XML elements.
An object for callbacks
True
If 'item' is specified, true is returned if the item is new,
modified or deleted.
Otherwise, true is returned if there are any new, modified
or deleted items.
An item (XML element) to check
True if an item or items are new, modified or deleted, otherwise
false
This default implementation just returns 'url'.
Sub-classes may override this method for the custom URL.
item to save
A post URL
This default implementation just returns 'url'.
Sub-classes may override this method for the custom URL.
item to save
A put URL
This default implementation returns 'url' with 'keyAttribute'
as a query string.
Sub-classes may override this method for the custom URL based on
changes (new, deleted, or modified).
item to delete
A delete URL
This default implementation generates an XML document for one
(the first only) new or modified element.
Sub-classes may override this method for the custom post content
generation.
item to save
A post content
This default implementation generates an XML document for one
(the first only) new or modified element.
Sub-classes may override this method for the custom put content
generation.
item to save
A post content
A function to compute the xpath of a node in a DOM document. Used for
Client side query handling and identity.
The XML Item from the store from which to obtain its identifier.
For XmlStore, if sendQuery is false and no keyAttribute was set, then this function
returns null, as xpath is used for the identity, which is not a public attribute of
the item. If sendQuery is true and keyAttribute is set, then this function
returns an array of one attribute name: keyAttribute. This means the server side
implementation must apply a keyAttribute to a returned node that always allows
it to be looked up again.
The item from the store from which to obtain the array of public attributes that
compose the identifier, if any.
url to a service or an XML document that represents the store
tag name for root items
attribute name for a key or an identity (unique identifier)
Required for serverside fetchByIdentity, etc. Not required for
client side fetchItemBIdentity, as it will use an XPath-like
structure if keyAttribute was not specified. Recommended to always
set this, though, for consistent identity behavior.
attributeMap: An anonymous object contains properties for attribute mapping,
{"tag_name.item_attribute_name": "@xml_attribute_name", ...}
boolean indicate to add a query string to the service URL.
Default is false.
to indicate whether or not URL calls should apply
the preventCache option to the xhr request.
This class represents an item of 'XmlStore' holding an XML element.
'element'
element:
An XML element
XML element
containing store, if any.
query to use to look up a specific element.
Usually an XPath or dojo.query statement.
a value of the first text child of the element
XML element
containing store, if any.
query:
The query to use to look up a specific element.
Usually an XPath or dojo.query statement.
Optional text to create the document from. If not provided, an empty XML document will be created.
If str is empty string "", then a new empty document will be created.
Optional mimetype of the text. Typically, this is text/xml. Will be defaulted to text/xml if not provided.
Implementation of the DOM Level 3 attribute; scan node for text
This function can also update the text of a node by replacing all child
content of the node.
The node to get the text off of or set the text on.
Optional argument of the text to apply to the node.
Removes all children of node and appends newChild. All the existing
children will be destroyed.
The node to modify the children on
The children to add to the node. It can either be a single Node or an
array of Nodes.
The node to remove all the children from.
The node from which to generate the XML text representation.
buddhist.Date Date object to start with
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "week", "weekday"
How much to add to the date.
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "week", "weekday"
Defaults to "day".
This fucntion initialize the date object values
This fucntion initialize the date object values
var date1 = new dojox.date.buddhist.Date();
var date2 = new dojox.date.buddhist.Date(date1);
var date3 = new dojox.date.buddhist.Date(2552,2,12);
var date1 = new dojox.date.buddhist.Date();
console.log(date1.getDate());
var date1 = new dojox.date.buddhist.Date();
console.log(date1.getMonth()+1);
var date1 = new dojox.date.buddhist.Date();
console.log(date1.getFullYear());
var date1 = new dojox.date.buddhist.Date();
date1.setDate(2);
var date1 = new dojox.date.buddhist.Date();
date1.setFullYear(2552);
date1.setFullYear(2552, 1, 1);
var date1 = new dojox.date.buddhist.Date();
date1.setMonth(0); //first month
Date Object?
Returns 0 if equal, positive if a > b, else negative.
date1:
hebrew.Date object
date2:
hebrew.Date object. If not specified, the current hebrew.Date is used.
A string indicating the "date" or "time" portion of a Date object.
Compares both "date" and "time" by default. One of the following:
"date", "time", "datetime"
hebrew.Date Date object to start with
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "week", "weekday"
How much to add to the date.
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "week", "weekday"
Defaults to "day".
A Date-like object which implements the Hebrew Calendar. Because this object
implements many of the same methods as the native JavaScript Date object, which
implements the Gregorian calendar, it can often be used its place. Note that
this object does not extend Date or use its prototype.
var date1 = new dojox.date.hebrew.Date();
var date2 = new dojox.date.hebrew.Date(date1);
var date3 = new dojox.date.hebrew.Date(5768,2,12);
var date1 = new dojox.date.hebrew.Date();
console.log(date1.getDate());
var date1 = new dojox.date.hebrew.Date();
console.log(date1.getDate());
the result is the index in the month array:
0. Tishri
1. Heshvan
2. Kislev
3. Tevet
4. Shevat
5. Adar I (leap years only)
6. Adar
7. Nisan
8. Iyar
9. Sivan
10. Tammuz
11. Av
12. Elul - 12
For non leap years, for months after Shevat, the actual position of
the month in the year (used for short format) is less than
the "absolute" index by 1.
var date1 = new dojox.date.hebrew.Date(5769, 6, 1);
console.log(date1.getMonth()+1);
>> 7
var date1 = new dojox.date.hebrew.Date(5769, 6, 1);
console.log(date1.getFullYear());
>> 5769
var date1 = new dojox.date.hebrew.Date(5769, 6, 1);
date1.setDate(2);
var date1 = new dojox.date.hebrew.Date();
date1.setFullYear(5768);
date1.setFullYear(5768, 1, 1);
var date1 = new dojox.date.hebrew.Date();
date1.setMonth(0); //first month
Sets the hour and optionally minutes, seconds, milliseconds also.
var date1 = new dojox.date.hebrew.Date();
date1.setHours(12, 30, 0, 0);
returns a string representation of the date in "dd, MM, yyyy HH:mm:ss" format (all numeric)
For user presentation, use dojox.date.hebrew.locale.format which will present in the appropriate language
and format. toString() language- and culturally-specific conventions to keep this module free of
dependencies on dojox.date.locale and dojo.cldr.
var date1 = new dojox.date.hebrew.Date(5769, 6, 1);
console.log(date1.toString());
>>> "1, 6, 5769 0:0:0"
The Leap year contains additional month adar sheni
return (year * 12 + 17) % 19 >= 12;
var dateHebrew = new dojox.date.hebrew.Date();
var dateGregorian = new Date(2008,10,12);
dateHebrew.fromGregorian(dateGregorian);
var dateHebrew = new dojox.date.hebrew.Date(5768,11,20);
var dateGregorian = dateHebrew.toGregorian();
var date1 = new dojox.date.hebrew.Date();
console.log(date1.getDay());
Create a string from a hebrew.Date object using a known pattern.
By default, this method formats both date and time from dateObject.
Default formatting lengths is 'short'
the date and/or time to be formatted. If a time only is formatted,
the values in the year, month, and day fields are irrelevant. The
opposite is true when formatting only dates.
var dateHebrew = dojox.date.hebrew.locale.parse('11/10/5740', {datePattern:'dd/MM/yy', selector:'date'});
in Hebrew locale string for parsing contains Hebrew Numerals
options = {datePattern:'dd MMMM yy', selector:'date'};
y - year
M, MM - short month
MMM, MMMM - long month
d - date
a - am, pm
E, EE, EEE, EEEE - week day
h, H, k, K, m, s, S, - time format
The user may add custom localized formats where the bundle has properties following the
same naming convention used by dojo.cldr: `dateFormat-xxxx` / `timeFormat-xxxx`
The pattern string should match the format used by the CLDR.
See dojo.date.locale.format() for details.
The resources must be loaded by dojo.requireLocalization() prior to use
'months' || 'days'
'wide' || 'narrow' || 'abbr' (e.g. "Monday", "Mon", or "M" respectively, in English)
use:
'standAlone' || 'format' (default)
override locale used to find the names
required for item=months to determine leap month name
using var monthNames = dojox.date.hebrew.locale.getNames('months', 'wide', 'format', 'he', new dojox.date.hebrew.Date(5768, 2, 12));
var date1 = new dojox.date.hebrew.Date();
document.writeln(dojox.date.hebrew.numerals.getYearHebrewLetters(date1.getFullYear());
var date = new dojox.date.hebrew.Date();
date.setFullYear(dojox.date.hebrew.numerals.parseYearHebrewLetters('\u05ea\u05e9\u05e1\u05f4\u05d7'));
hebrew year
var date1 = new dojox.date.hebrew.Date();
document.writeln(dojox.date.hebrew.numerals.getDayHebrewLetters(date1.getDay());
var date1 = new dojox.date.hebrew.Date();
date1.setDate(dojox.date.hebrew.numerals.parseDayHebrewLetters('\u05d0')); // ALEPH
hebrew
var date1 = new dojox.date.hebrew.Date();
document.writeln(dojox.date.hebrew.numerals.getMonthHebrewLetters(date1.getMonth());
var date = new dojox.date.hebrew.Date();
var number = dojox.date.hebrew.numerals.parseMonthHebrewLetters("\u05ea\u05de\u05d5\u05d6"); // Tammuz
date.setMonth(number);
Returns 0 if equal, positive if a > b, else negative.
object
object. If not specified, the current islamic.Date is used.
A string indicating the "date" or "time" portion of a Date object.
Compares both "date" and "time" by default. One of the following:
"date", "time", "datetime"
islamic.Date Date object to start with
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "week", "weekday"
How much to add to the date.
A string representing the interval. One of the following:
"year", "month", "day", "hour", "minute", "second",
"millisecond", "week", "weekday"
Defaults to "day".
This module is similar to the Date() object provided by JavaScript
This function initialize the date object values
var date1 = new dojox.date.islamic.Date();
var date2 = new dojox.date.islamic.Date("12\2\1429");
var date3 = new dojox.date.islamic.Date(date2);
var date4 = new dojox.date.islamic.Date(1429,2,12);
var date1 = new dojox.date.islamic.Date();
document.writeln(date1.getDate);
var date1 = new dojox.date.islamic.Date();
document.writeln(date1.getMonth()+1);
var date1 = new dojox.date.islamic.Date();
document.writeln(date1.getFullYear());
var date1 = new dojox.date.islamic.Date();
document.writeln(date1.getDay());
var date1 = new dojox.date.islamic.Date();
date1.setDate(2);
var date1 = new dojox.date.islamic.Date();
date1.setYear(1429);
var date1 = new dojox.date.islamic.Date();
date1.setMonth(2);
var date1 = new dojox.date.islamic.Date();
document.writeln(date1.toString());
var dateIslamic = new dojox.date.islamic.Date(1429,11,20);
var dateGregorian = dateIslamic.toGregorian();
var dateIslamic = new dojox.date.islamic.Date();
var dateGregorian = new Date(2008,10,12);
dateIslamic.fromGregorian(dateGregorian);
dojox.date.islamic.Date
Date Object?
see http://www.opengroup.org/onlinepubs/007908799/xsh/strftime.html
can be positive or negative: -1 is the year's last week.
Create a string from a Date object using the most significant information
and a known localized pattern. This method formats both the date and
time from dateObject. Formatting patterns are chosen appropriate to
the locale.
If the day portion of the date falls within the current date (or the
relativeDate option, if present), then the time will be all that
is displayed
If the day portion of the date falls within the past week (or the
week preceeding relativeDate, if present), then the display will show
day of week and time. This functionality can be turned off by setting
weekCheck to false.
If the year portion of the date falls within the current year (or the
year portion of relativeDate, if present), then the display will show
month and day.
Otherwise, this function is equivalent to calling dojo.date.format with
formatLength of "medium"
the date and time to be formatted.
override the locale used to determine formatting rules
Date to calculate relation to (defaults to new Date())
Whether or not to display the day of week (defaults true)
mix-in to dojo.date to provide timezones based on
the Olson timezone data.
If you pass "timezone" as a parameter to your format options,
then you get the date formatted (and offset) for that timezone
The Date - a "proxyDate"
String representation of the timezone you want to get info
for date
The data to load - contains "zones" and "rules" parameters
an array of dojox.dnd.Selectors which need to be aware of
the positioning of the bounding box.
the DOM node or id which represents the bounding box on the page.
the mouse event which caused this callback to fire.
the mouse event which caused this callback to fire.
the mouse event which caused this callback to fire.
the DOM node or id which represents the bounding box on the page.
Node to check (id or DOM Node)
Node to select (id or DOM Node)
If true, node is added to selection, otherwise current
selection is removed, and node will be the only selection.
Node to deselect (id or DOM Node)
Left coordinate of the bounding box
Top coordinate of the bounding box
Right coordinate of the bounding box
Bottom coordinate of the bounding box
If true, node is added to selection, otherwise current
selection is removed, and node will be the only selection.
Node to check (id or DOM Node)
Left coordinate of the bounding box
Top coordinate of the bounding box
Right coordinate of the bounding box
Bottom coordinate of the bounding box
If true, we select the next node, otherwise the previous one.
If true, add to selection, otherwise current selection is
removed before adding any nodes.
the id of the node to use as the base node
If true, we select the next node, otherwise the previous one.
Drawing is similar to DojoX Sketch, but is designed to be more versatile
extendable and customizable.
Drawing currently only initiates from HTML although it's technically not
a Dijit to keep the file size light. But if Dijit is available, Drawing
will register itself with it and can be accessed dijit.byId('myDrawing')
NOTES:
Although not Drawing and Toolbar, all other objects are created with a custom
declare. See dojox.drawing.util.oo
The files are laid out as such:
- Drawing
The master class. More than one instance of a Drawing can be placed
on a page at one time (although this has not yet been tested). Plugins
can be added in markup.
- Toolbar
Like Drawing, Toolbar is a psudeo Dijit that does not need Dijit. It is
optional. It can be oriented horizontal or vertical by placing one of
those params in the class (at least one is required). Plugins
can be added in markup. A drawingId is required to point toolbar to
the drawing.
- defaults
Contains the default styles and dimensions for Stencils. An individual
Stencil can be changed by calling stencil.att({color obj}); To change
all styles, a custom defaults file should be used.
-Stencils
Drawing uses a concept of 'Stencils' to avoid confusion between a
Dojox Shape and a Drawing Shape. The classes in the 'stencils' package
are display only, they are not used for actually drawing (see 'tools').
This package contains _Base from which stencils inherit most of their
methods.(Path and Image are display only and not found in Tools)
- Tools
The Tools package contains Stencils that are attached to mouse events
and can be used for drawing. Items in this package can also be selected
and modified.
- Tools / Custom
Holds tools that do not directly extend Stencil base classes and often
have very custom code.
- Library (not implemented)
The Library package, which is not yet implemented, will be the place to
hold stencils that have very specific data points that result in a picture.
Flag-like-banners, fancy borders, or other complex shapes would go here.
- Annotations
Annotations 'decorate' and attach to other Stencils, such as a 'Label'
that can show text on a stencil, or an 'Angle' that shows while dragging
or modifying a Vector, or an Arrow head that is attached to the beginning
or end of a line.
- Manager
Contains classes that control functionality of a Drawing.
- Plugins
Contains optional classes that are 'plugged into' a Drawing. There are two
types: 'drawing' plugins that modify the canvas, and 'tools' which would
show in the toolbar.
- Util
A collection of common tasks.
Object The parameters used to draw the object. See stencil._Base and each
tool for specific parameters of teh data or points objects.
Object The parameters used to draw the object. See stencil._Base and each
tool for specific parameters of teh data or points objects.
myDrawing.toSelected('attr', {x:10})
myDrawing.changeDefaults({
norm:{
fill:"#0000ff",
width:5,
color:"#ffff00"
}
});
console.log("----->>> changeDefault: ",newStyle, " value?: ",value);
An object that represents one of the objects in
drawing.style that will be mixed in. Not all
properties are necessary. Only one object may
be changed at a time. The object boolean parameter
is not required and if not set objects will automatically
be changed.
Changing non-objects like angleSnap requires value
to be true.
Whether or not the canvas has been created and Stencils can be added
Changes the functionality of the drawing
Width of the canvas
Height of the canvas
defaults : Object
Optional replacements for native defaults.
plugins: Object
Key values of plugins that apply to canvas.
This object contains defaults for objects used in Drawing.
To change one item's style, use item.attr();
To change all these styles, create a copy of this file
and point to it in the Drawing properties:
<div dojoType="dojox.drawing.Drawing" id="drawing" defaults="MyCustom.defaults"></div>
See:
Drawing.changeDefaults
Determines whether in draw or edit mode (whether stencils
are clickable. If clickMode is false, the original
functionality of silently switching between select modes
is enabled. If clickMode is true, it allows powerpoint-
like functionality. Clickable is used by powerpoint to
distinguish when things can be selected and when they can't
current will point to either null or selected
currentHit will point to either hitNorm or hitSelected
Line, arrows, vector and axes will all snap to this angle on mouse up
shown angle also reflects the snap
currently cannot accept less than 1 degree
If true, draw current object in z-direction.
If true, render axes with Z-axis included, allow objects drawn in z-direction.
If false the z-axis button will not show up.
If true, renders a second, larger layer for lines to make
them more easily clickable.
true, renders a second layer for each Stencil, one
acting as a 'hit' object for a wider mouse-click area.
It also doubles as a hilight. If true, overrides
renderHitLines setting.
true, the label text color will be the same as the
Stencil's line color.
These are used to convert between the character and
the written version of greek letters. Any character
can be included here and it will automatically be added
to the palette and converted by typesetter
Each icon name coresponds to a Stencil or a Plugin. One can be inserted
into a button by adding the property: 'icon', which points to one of
these Stencil objects.
The amount, in pixels, a selected Stencil will
move on an arrow key event
The amount, in pixels, a selected Stencil will
move on an arrow key + SHIFT event
Indicates whether the Shift key is currently pressed
Indicates whether the Control key is currently pressed
Indicates whether the Alt or Option key is currently pressed
Indicates whether the Apple Command key is currently pressed
apple key
Indicates whether any 'meta' key is currently pressed:
shift || ctrl || cmmd || alt
any meta key
Grid showing all available entity options which the
user can pick from. The library loaded for use by the picker
is found in dojox.drawing.library.greek. Adding characters
there will automatically add them to the palette.
This works as a popup and as such its onChange and onCancel
close it. TextBlock manages it, since it's what uses the assist
so opening it happens there. In order to activate the plugin
add it to the dojox.drawing.Drawing node as shown below:
event.
The event.
At any point in time there's exactly one
cell with tabIndex != -1. If focus is inside the palette then
focus is on that cell.
After calling this method, arrow key handlers and mouse click handlers
should focus the cell in a setTimeout().
id's for each cell of the palette, used to create Dye JS object for each cell
Localized tooltip for each cell
The template of this widget. Using dojoxEntityPalette classes
in order to allow easy transfer of css
Whether the preview pane will be displayed, to show details about the selected entity.
Center point x
Center point y
Horizontal radius
Vertical radius
The parent shape that contains all
shapes used in a Stencil
Optionally blank or 'group'. 'group' tells
an anchor point that it must constrain
itself to other anchor points.
Whether this is a text object or not
(either stencil.text or tools.TextBlock)
The type of stencil that corresponds with the types and
constructors used in Drawing.registerTool
A Stencil used within a Stencil. An annotation
is not selectable or clickable. A Label would
be one example.
A Stencil used within a Stencil. A subShape
is clickable. An arrow head would be an example.
An instance of the styles and defaults used within
the Stencil.
Pointer to util.common
Pointer to the mouse instance
Pointer to the keys class
Points is an array of objects that make up the
description of a Stencil. The points to a Rect
that is 100x100 and at x:10 and y:10 would look like:
[{x:10,y:10}, {x:110, y:10}, {x:110, y:110}, {x:10, y:110}]
Points go clockwise from the top left. In the case of Paths,
they would go in the order that the Stencil would be drawn.
Always when the points Array is set, a data Object is created
as well. So never set points directly, always use setPoints().
See:
setPoints()
A data object typically (but not always) resembles the data
that is used to create the dojox.gfx Shape. The same Rect
example shown in points above would look like:
{x:10, y:10, width:100, height:100}
And an Ellipse with the same coordinates:
{cx:55, cy:55, rx:50, ry:50}
The only Stencil that does not support data (at this time)
is the Path. While x1,x2,x3... culd be used in a data object
it doesn't provide much benefit.
Always when a data object is set, a set of points is created
as well. So never set data directly, always use setData().
See:
setData()
marginZero [readonly] Number
How closely shape can get to y:0 or x:0. Less than zero has
bugs in VML. This is set with defaults, and should be equal
to half the size of an anchor point (5 px)
created [readonly] Boolean
Whether the Stencil has been rendered for the first time or
not.
highlighted [readonly] Boolean
Whether the Stencil is highlighted or not.
selected [readonly] Boolean
Whether the Stencil is selected or not.
draws [readonly] Boolean
Whether the Stencil can draw with a mouse drag or can just
be created programmtically. If the Stencil comes from the
stencil package, it should be draw:false. If it comes from
the tools package it should be draw:true.
See Toolbar.js makeButtons function. The toolbar
checks Vector.setup for a secondary tool and requires
name, label, and funct. Currently it doesn't accept icon
and only uses text from label for the button. Funct is the
function that fires when the button is clicked.
Setup and postSetup are optional
and allow tool specific functions to be added to the
Toolbar object as if they were written there.
Creates a GFX-based toobar that holds GFX-based buttons. Can be either created
within the actual drawing or within a seperate DOM element. When within the
drawing, the toolbar will cover a portion of the drawing; hence the option.
A Toolbar can be created programmtically or in markup. Currently markup is as
a separate DOM element and programmtic is within the drawing.
examples:
dojo.connect(myDrawing, "onSurfaceReady", function(){
new dojox.drawing.ui.Toolbar({
drawing:myDrawing,
tools:"all",
plugs:"all",
selected:"ellipse"
});
});
<div dojoType="dojox.drawing.ui.Toolbar" id="gfxToolbarNode" drawingId="drawingNode"
class="gfxToolbar" tools="all" plugs="all" selected="ellipse" orient="H"></div>
| Node
The amount of spce between the top and left of the toolbar and the buttons.
The space between each button.
The width and height of the button
The size of the button's rounded corner
The distnce between the tool buttons and plug buttons
Currently works in markup only. A class is required with
either horizontal or vertical as a class (IE prevented using
either as a default). Assign an attribute of 'drawingId' with
the id of the DojoX Drawing to which this is assigned.
The node children will be assigned as the Tools in the toolbar.
Plugins can also be assigned.
The Toolbar is largely self contained and has no real public
methods or events. the Drawing object should be used.
The button node.
Function Optional. If not supplied, an icon is not created.
Information for each icon is derived from
the ToolsSetup object defined at the end
of each tool. See: stencil._Base
The button node.
Fully qualified name of class. ex:
dojox.drawing.tools.Ellipse
The CSS style to apply to the toolbar node
The CSS style to apply to each button node
The CSS style to apply to each button icon node
Manager.Mouse event.
Float Returns nearest angle within snap limits
obj = this.argsToObj.apply(this, arguments);
x1,y1,x2,y2 represents the Line. 'amt' represents the amount
to subtract from it.
Mouse object (see dojox.drawing.Mouse)
Fractional amount to snap to
A decimal number fraction of a half circle
.5 would snap to 90 degrees
.25 would snap to 45 degrees
.125 would snap to 22.5 degrees, etc.
String If provided, kept in a map, incremented
and used in the id. Otherwise 'shape' is used.
value
Inheritance utilities used in DojoX Drawing.
There were designed in a effort to make Drawing as
fast as possible - especially in a case where thousands
of objects are being loaded. Drawing declare performs
about 3 times faster than Dojo declare and 2 times
faster than Dojox declare. This is not to say Drawing
declare is wthout limitations. It doesn't have the same
syntatic sugar and extensibility of the other two. You
can't inhert methods. It won't work with Dijit. But it
is simple and effective.
Similar in look and feel to Dojo declare as
far as order and number of arguments, although
constructed a little closer to prototypical
inheritance. All arguments passed into the
constructor are passed into all sub constructors.
arguments:
Function, [Object|Function....]
The first argument is always the base
constructor. The last argument is always
an object of methods (or empty object) to
be mixed in (in the future would like to
make that object optional). Remaining
arguments are other constructors mixed in
using extend() (See below).
MyFunction = dojox.drawing.util.oo.declare(
MyOtherFunction,
YetAnotherFunction,
function(options){
// This is my constructor. It will fire last.
// The other constructors will fire before this.
},
{
customType:"equation", // mixed in property
doThing: function(){ // mixed in method
}
}
);
var f = new MyFunction();
Typically not used by itself - it's used as
part of declare(). Could be used by itself
however, to mix together two or more
constructors.
arguments:
Function, [ Function...]
Any number of arguments, all must be
function constructors. The first is
considered the base object and its
constructor will fire first.
var A = function(){};
var B = function(){};
var C = function(){};
var D = dojox.drawing.util.oo.extend(A, B, C);
var e = new D();
`contextItems` and `contextStore` should be an item list
and a data store that get assigned to `newVariable`
{% bind_data contextItems to contextStore as newVariable %}
You can only use this with data stores that work in a synchronous
way (meaning that `onComplete` is fired during the `fetch` call).
A `sync` flag is sent to the fetch call so that stores that usually
work asynchronously make themselves syncrhonous if possible.
{% bind_query contextQuery to contextStore as newVariable %}
When using DomTemplate, wrap any content
that you expect to change often during
re-rendering. It will then remove its parent
from the main document while it re-renders that
section of code. It will only remove it from
the main document if a mainpulation of somes sort
happens. ie It won't swap out if it diesn't have to.
By default, it considers only node addition/removal
to be "changing"
{% buffer %}{% for item in items %}<li>{{ item }}</li>{% endfor %}{% endbuffer %}
You can explicitly declare options:
* node: Watch node removal/addition
* class: Watch for a classname to be changed
* text: Watch for any text to be changed
{% buffer node class %}{% for item in items %}<li>{{ item }}</li>{% endfor %}{% endbuffer %}
Django throws a compile error, but JS can't do arg checks
so we're left with run time errors, which aren't wise for something
as trivial here as an empty arg.
Uses the same syntax as Python's list slicing; see
http://diveintopython.org/native_data_types/lists.html#odbchelper.list.slice
for an introduction.
Also uses the optional third value to denote every X item.
The list is assumed to be in the proper format. For example, if ``var`` contains
``['States', [['Kansas', [['Lawrence', []], ['Topeka', []]]], ['Illinois', []]]]``,
then ``{{ var|unordered_list }}`` would return::
<li>States
<ul>
<li>Kansas
<ul>
<li>Lawrence</li>
<li>Topeka</li>
</ul>
</li>
<li>Illinois</li>
</ul>
</li>
By default, 's' is used as a suffix; if an argument is provided, that string
is used instead. If the provided argument contains a comma, the text before
the comma is used for the singular case.
If called without an argument, displays a floating point
number as 34.2 -- but only if there's a point to be displayed.
With a positive numeric argument, it displays that many decimal places
always.
With a negative numeric argument, it will display that many decimal
places -- but only if there's places to be displayed.
Number of words to truncate after
Adapted from http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
Examples: '1', '1:30', '2:05', '2'
Proprietary extension.
Examples: '1 a.m.', '1:30 p.m.', 'midnight', 'noon', '12:30 p.m.'
Proprietary extension.
The invertal value
interval value.
The editor to configure for this plugin to use.
response from the server, if any, in text format.
The editor it belongs to.
keypress event object.
The node to be examed.
The current node that the cursor is at.
The editor to configure for this plugin to use.
list of nodes.
node to look at.
node to start at.
node to check.
node to check.
tag to examine
The CSS class name for the button node icon.
The editor to configure for this plugin to use.
popup menu that is displayed.
toolbar containing the breadcrumb.
The editor to configure for this plugin to use.
click event.
click event.
Container for widgets I allocate that will need to be destroyed.
Grid showing various entities, so the user can pick a certain entity.
Can be used standalone, or as a popup.
event.
Removes highlight of the old entity, and highlights
the new entity.
The basic template used to render the palette.
Should generally be over-ridden to define different classes.
Whether the preview pane will be displayed, to show details about the selected entity.
Show the character code for the entity.
The symbol pallete to display. The only current one is 'latin'.
The boolean value to indicate if the textbox should be disabled or not
object passed to this handler
The id of the enhanced textbox
The label of the enhanced textbox
The flag that indicates if the checkbox is disabled or not.
The id of the enhanced checkbox
The label of the enhanced checkbox
The tooltip of the enhanced checkbox when the mouse is hovering it
The Event object
tages:
private
Indicate if the toolbar is shown or not
Indicate if the status should be ignored or not
blurEditor:
Indicate if the focus should be removed from the editor or not
The current toolbar of the editor
Indicated whether the tooltip is shown or not when the search reaches the end
Boolean indicating if the content was found or not.
Indicate if the prompt message is shown or not when the replacement
reaches the end
Boolean indicating if the content was replaced or not.
Indicate if the prompt message is shown or not when the action is done.
The text to locate in the document.
Whether or ot to search case-sensitively.
Whether or not to search backwards in the document.
Boolean indicating if the content was found or not.
Returns a regular expression object that conforms to the defined conversion rules.
For example:
ca* -> /^ca.*$/
*ca* -> /^.*ca.*$/
*c\*a* -> /^.*c\*a.*$/
*c\*a?* -> /^.*c\*a..*$/
and so on.
string A simple matching pattern to convert that follows basic rules:
* Means match anything, so ca* means match anything starting with ca
? Means match single character. So, b?b will match to bob and bab, and so on.
\ is an escape character. So for example, \* means do not treat * as a match, but literal character *.
To use a \ as a character in the string, it must be escaped. So in the pattern it should be
represented by \\ to be treated as an ordinary \ character instead of an escape.
An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing
By default, it is assumed case sensitive.
the class of button the editor uses.
The CSS class name for the button node is formed from <code>iconClassPrefix</code> and <code>command</code>
toggle button
toolbar that contain all the entries and buttons
close button of the F/R toolbar
Find field of the F/R toolbar
Replace field of the F/R toolbar
Find button of the F/R toolbar
Replace button of the F/R toolbar
ReplaceAll button of the F/R toolbar
case sensitive checkbox
backwards checkbox
prompt message box that shows the user some messages
such as the end of a search, the end of a replacement, etc.
array that contains globalized strings
The command provided by this plugin is:
* insertAnchor
The editor to configure for this plugin to use.
The full url to tear down to the base.
Content being set.
anchor/link to process for data for the dropdown.
The double-click event.
node to search from.
node to search from.
String used for templating the HTML to insert at the desired point.
The CSS class name for the button node icon.
The commands provided by this plugin are:
* insertEntity - inserts the selected HTML entity character
The editor to configure for this plugin to use.
content passed in
content passed in
The CSS class name for the button node is formed from <code>iconClassPrefix</code> and <code>command</code>
The editor to configure for this plugin to use.
command passed in to check enablement.
node who's content to indent.
node who's content to outdent.
list item to indent.
list item to outdent.
node to check.
tag to check
indent amount to convert.
tag to examine
node to look at.
node to start at.
node to check.
The amount to indent by. Valid values are 1+. This is combined with
the indentUnits parameter to determine how much to indent or outdent
by for regular text. It does not affect lists.
The units to apply to the indent amount. Usually 'px', but can also
be em.
The editor to configure for this plugin to use.
The node to process.
node to search from.
The node to process
node (and its children), to process.
tag to examine
HTML string to insert.
The editor to configure for this plugin to use.
The CSS class name for the button node is formed from
<code>iconClassPrefix</code> and <code>command</code>
The nodes that should not allow page breaks to be inserted into them.
The markup used for the pagebreak insert.
The editor to configure for this plugin to use.
The CSS class name for the button node is formed from <code>iconClassPrefix</code>
and <code>command</code>
The width to use for the rich text area in the copy/pate dialog, in px. Default is 400px.
The height to use for the rich text area in the copy/pate dialog, in px. Default is 300px.
The filters is an array of regular expressions to try and strip out a lot
of style data MS Word likes to insert when pasting into a contentEditable.
Prettymuch all of it is junk and not good html. The hander is a place to put a function
for match handling. In most cases, it just handles it as empty string. But the option is
there for more complex handling.
The editor to configure for this plugin to use.
A string of CSS styles to apply to the previewed content, if any.
An array of stylesheets to import into the preview, if any.
The CSS class name for the button node icon.
editor which this plugin belongs to
The editor to configure for this plugin to use.
response from the server, if any, in text format.
The CSS class name for the button node is formed from <code>iconClassPrefix</code>
and <code>command</code>
The editor to configure for this plugin to use.
The full url to tear down to the base.
The CSS class name for the button node is formed from <code>iconClassPrefix</code> and <code>command</code>
The commands provided by this plugin are:
* smiley - inserts the selected emoticon
The editor to configure for this plugin to use.
content passed in
content passed in
The CSS class name for the button node is formed from <code>iconClassPrefix</code> and <code>command</code>
The event object
The event object
The value of the Not Found textbox
The list of the suggestion items
An array of items be added to the select
The text to be sent
The action the service should take. Current support actions are
ACTION_QUERY and ACTION_UPDATE
action token
name
argument
The result of the query
The event object
Indicate whether to update the status of the span list or not
The html value of the editor
html code
The html value of the editor
Indicate if the action is taken immediately or not
idex of the span list
The html value of the editor
The local word cache
index of the span list
index of the span list
text to be replaced with
index of the span list
index of the span list
If this argument is given, skip all the words that have the same text
as the word
index of the span list
If this argument is given, add the word to the dictionary and
skip all the words like it
The text to locate in the document.
Whether or ot to search case-sensitively.
Whether or not to search backwards in the document.
Boolean indicating if the content was found or not.
The html value of the editor
The string to set as the status bar content.
Template for the widget. Currently using table to get the alignment behavior and
bordering I wanted. Would prefer not to use table, though.
The editor to configure for this plugin to use.
The String value to set in the bar.
attribute to set.
value to set it to.
attribute to get.
status bar and resizer.
Flag indicating that a resizer should be shown or not. Default is true.
There are cases (such as using center pane border container to autoresize the editor
That a resizer is not valued.
editor to detach from.
The value to set in the color picker
to indicate whether or not to trigger an onChange event.
The value from the color picker.
The template used to create the ColorPicker.
Flag denoting widgets are contained in the template.
The value to set in the color picker
to indicate whether or not to trigger an onChange event.
The value from the color picker.
The template used to create the ColorPicker.
Flag denoting widgets are contained in the template.
The commands provided by this plugin are:
* foreColor - sets the text color
* hiliteColor - sets the background color
False as we do not use the default editor command/click behavior.
Grid showing various emoticons.
Can be used standalone, or as a popup.
Plain text without html tags
Array holding all the words
Index array
Creates a wrapper object around a Flash movie. Wrapper object will
insert the movie reference in node; when the browser first starts
grabbing the movie, onReady will be fired; when the movie has finished
loading, it will fire onLoad.
If your movie uses ExternalInterface, you should use the onLoad event
to do any kind of proxy setup (see dojox.embed.Flash.proxy); this seems
to be the only consistent time calling EI methods are stable (since the
Flash movie will shoot several methods into the window object before
EI callbacks can be used properly).
*Important note*: this code includes a workaround for the Eolas "fix" from
Microsoft; in order to work around the "click to activate this control" message
on any embedded Flash movie, this code will load a separate, non-dojo.require
javascript file in order to write the Flash movie into the document. As such
it cannot be used with Dojo's scope map techniques for working with multiple
versions of Dojo on the same page.
Create "setMessage" and "getMessage" methods on foo.
var foo = new dojox.embed.Flash(args, someNode);
dojo.connect(foo, "onLoad", dojo.hitch(foo, function(){
dojox.embed.Flash.proxy(this, [ "setMessage", "getMessage" ]);
this.setMessage("dojox.embed.Flash.proxy is pretty cool...");
console.log(this.getMessage());
}));
Probably includes methods for outdated
browsers, but this should catch all cases.
arguments:
var movie = dojox.embed.Flash.byId("myId");
The name of the SWF
The document, if not current window
(not fully supported)
The minimum supported version of the Flash Player, defaults to 8.
Used as both a detection (i.e. if(dojox.embed.Flash.available){ })
and as a variable holding the major version of the player installed.
Whether or not the Flash Player installed is supported by dojox.embed.
The version of the installed Flash Player; takes the form of
{ major, minor, rev }. To get the major version, you'd do this:
var v=dojox.embed.Flash.version.major;
Whether or not the Flash engine is available for use.
A unique key that will be used as the id of the created markup. If you don't
provide this, a unique key will be generated.
The URL of the movie to embed.
The width of the embedded movie; the default value is 320px.
?
The minimum targeted version of the Flash Player (defaults to 9)
The height of the embedded movie; the default value is 240px
Any CSS style information (i.e. style="background-color:transparent") you want
to define on the markup.
A set of key/value pairs that you want to define in the resultant markup.
A set of key/value pairs that the Flash movie will interpret as FlashVars.
Whether or not to include any kind of expressInstall info. Default is false.
A url to redirect the browser to if the current Flash version is not supported.
The width of the movie. If not provided, the width of this.domNode is used.
The height of the movie. If not provided, the height of this.domNode is used.
The URL of the movie to embed.
The eventual reference to the movie embedded. If you are looking to script
control over the movie, you'd access it this way.
A property bag that is created postCreate. Any additional attributes you
define on your domNode will be collected and placed into this, which will
then be passed to the movie constructor.
Expression used on the src property to determine if this is Flash or Quicktime.
Expression used on the src property to determine if this is Flash or Quicktime.
Expression used on the src property to determine if this is Flash or Quicktime.
The minimum supported version of the QuickTime Player, defaults to
6.
Whether or not QuickTime is available.
Whether or not the QuickTime Player installed is supported by
dojox.embed.
The version of the installed QuickTime Player; takes the form of
{ major, minor, rev }. To get the major version, you'd do this:
var v=dojox.embed.Quicktime.version.major;
Whether or not the QuickTime engine is available for use.
A unique key that will be used as the id of the created markup. If you don't
provide this, a unique key will be generated.
The URL of the movie to embed.
The width of the embedded movie; the default value is 320px.
The height of the embedded movie; the default value is 240px
A set of key/value pairs that you want to define in the resultant markup.
A url to redirect the browser to if the current QuickTime version is not supported.
JSON could be done, but Deft does not yet have a JSON parser, and quotes are
very problematic since Flash cannot use eval(); JSON parsing was successful
when it was fully escaped, but that made it very large anyway. flashvar
serialization at most is 200% larger than JSON.
See:
Deft/common/flashVars.as
The name for the object, such as: "button"
The object to serialize
an array of numbers (0-255) to encode
the input string to decode
an even-length hex string
a plain string.
Array: array to be filled in with random numbers, only existing
elements will be filled.
an array of numbers (0-255) to encode
the input string to decode
The goal of dojox.flash is to make it easy to extend Flash's capabilities
into an Ajax/DHTML environment.
dojox.flash provides an easy object for interacting with the Flash plugin.
This object provides methods to determine the current version of the Flash
plugin (dojox.flash.info); write out the necessary markup to
dynamically insert a Flash object into the page (dojox.flash.Embed; and
do dynamic installation and upgrading of the current Flash plugin in
use (dojox.flash.Install). If you want to call methods on the Flash object
embedded into the page it is your responsibility to use Flash's ExternalInterface
API and get a reference to the Flash object yourself.
To use dojox.flash, you must first wait until Flash is finished loading
and initializing before you attempt communication or interaction.
To know when Flash is finished use dojo.connect:
dojo.connect(dojox.flash, "loaded", myInstance, "myCallback");
Then, while the page is still loading provide the file name:
dojox.flash.setSwf(dojo.moduleUrl("dojox", "_storage/storage.swf"));
If no SWF files are specified, then Flash is not initialized.
Your Flash must use Flash's ExternalInterface to expose Flash methods and
to call JavaScript.
setSwf can take an optional 'visible' attribute to control whether
the Flash object is visible or not on the page; the default is visible:
dojox.flash.setSwf(dojo.moduleUrl("dojox", "_storage/storage.swf"),
false);
Once finished, you can query Flash version information:
dojox.flash.info.version
Or can communicate with Flash methods that were exposed:
var f = dojox.flash.get();
var results = f.sayHello("Some Message");
Your Flash files should use DojoExternalInterface.as to register methods;
this file wraps Flash's normal ExternalInterface but correct various
serialization bugs that ExternalInterface has.
Note that dojox.flash is not meant to be a generic Flash embedding
mechanism; it is as generic as necessary to make Dojo Storage's
Flash Storage Provider as clean and modular as possible. If you want
a generic Flash embed mechanism see [SWFObject](http://blog.deconcept.com/swfobject/).
Notes:
Note that dojox.flash can currently only work with one Flash object
on the page; it does not yet support multiple Flash objects on
the same page.
Your code can detect whether the Flash player is installing or having
its version revved in two ways. First, if dojox.flash detects that
Flash installation needs to occur, it sets dojox.flash.info.installing
to true. Second, you can detect if installation is necessary with the
following callback:
dojo.connect(dojox.flash, "installing", myInstance, "myCallback");
You can use this callback to delay further actions that might need Flash;
when installation is finished the full page will be refreshed and the
user will be placed back on your page with Flash installed.
-------------------
Todo/Known Issues
-------------------
* On Internet Explorer, after doing a basic install, the page is
not refreshed or does not detect that Flash is now available. The way
to fix this is to create a custom small Flash file that is pointed to
during installation; when it is finished loading, it does a callback
that says that Flash installation is complete on IE, and we can proceed
to initialize the dojox.flash subsystem.
* Things aren't super tested for sending complex objects to Flash
methods, since Dojo Storage only needs strings
Author- Brad Neuberg, http://codinginparadise.org
A function that will be called when Flash is done loading.
A function that will be called if Flash is being
installed
A callback when the Flash subsystem is finished loading and can be
worked with. To be notified when Flash is finished loading, add a
loaded listener:
dojox.flash.addLoadedListener(loadedListener);
A callback to know if Flash is currently being installed or
having its version revved. To be notified if Flash is installing, connect
your callback to this method using the following:
dojo.event.connect(dojox.flash, "installing", myInstance, "myCallback");
The URL to this Flash file.
visible: boolean?
Whether the Flash file is visible or not. If it is not visible we hide
it off the screen. This defaults to true (i.e. the Flash file is
visible).
A class that helps us determine whether Flash is available,
it's major and minor versions, and what Flash version features should
be used for Flash/JavaScript communication. Parts of this code
are adapted from the automatic Flash plugin detection code autogenerated
by the Macromedia Flash 8 authoring environment.
An instance of this class can be accessed on dojox.flash.info after
the page is finished loading.
Asserts that this environment has the given major, minor, and revision
numbers for the Flash player.
Example- To test for Flash Player 7r14:
dojox.flash.info.isVersionOrAbove(7, 0, 14)
Returns true if the player is equal
or above the given version, false otherwise.
The full version string, such as "8r22".
Whether this platform has Flash already installed.
Set if we are in the middle of a Flash installation session.
Writes out the necessary tags to embed a Flash file into the page. Note that
these tags are written out as the page is loaded using document.write, so
you must call this class before the page has finished loading.
This must be called before the page
is finished loading.
Whether to write out Express Install
information. Optional value; defaults to false.
The width of this Flash applet. The default is the minimal width
necessary to show the Flash settings dialog. Current value is
215 pixels.
The height of this Flash applet. The default is the minimal height
necessary to show the Flash settings dialog. Current value is
138 pixels.
The id of the Flash object. Current value is 'flashObject'.
This class helps mediate Flash and JavaScript communication. Internally
it uses Flash 8's ExternalInterface API, but adds functionality to fix
various encoding bugs that ExternalInterface has.
Figures out the best way to automatically install the Flash plugin
for this browser and platform. Also determines if installation or
revving of the current plugin is needed on this platform.
Whether or not this widget is disabled
Whether or not this widget is readOnly
If null, onChange is not fired.
User is required to check at least one item.
The message to display if value is invalid.
Currently displayed message
See description of <code>dijit.Tooltip.defaultPosition</code> for details on this parameter.
The popup widget to use. In this case, a calendar with Day, Month and Year views.
The popup widget to use. In this case, a calendar with just a Month view.
The popup widget to use. In this case, a calendar with just a Year view.
A input type="file" form widget, with a button for uploading to be styled via css,
a cancel button to clear selection, and FormWidget mixin to provide standard dijit.form.Form
support (FIXME: maybe not fully implemented)
the title text of the "Browse" button
the title of the "Cancel" button
ugh, this should be pulled from this.domNode
An extended version of FileInput - when the user focuses away from the input
the selected file is posted via dojo.io.iframe to the url. example implementation
comes with PHP solution for handling upload, and returning required data.
notes: the return data from the io.iframe is used to populate the input element with
data regarding the results. it will be a JSON object, like:
results = { size: "1024", filename: "file.txt" }
all the parameters allowed to dojox.form.FileInput apply
raw data found in the first [TEXTAREA] tag of the post url
dojo.Deferred data being passed from the handle: callback
widget pointer, so you can set this.overlay to a completed/error message easily
the URL where our background FileUpload will be sent
time in ms before an un-focused widget will wait before uploading the file to the url="" specified
default: 2 seconds
The time in ms to use as the generic timing mechanism for the animations
set to 1 or 0 for "immediate respose"
FIXME: i18n somehow?
Event which triggers the upload. Defaults to onblur, sending the file selected
'blurDelay' milliseconds after losing focus. Set to "onchange" with a low blurDelay
to send files immediately after uploading.
Delay in milliseconds between when user types something and we start
searching based on that value
The item, in our store, of the directory relating to our value
The number of panes to display in our box (if we don't have any
minPaneWidth specified by our constraints)
If the correct version of Flash Player is available (> 9.0) , a SWF
is used. If Flash Player is not installed or is outdated, a typical
html fileInput is used. This process can be overridden with
or String
node ?
postData to be sent to server
The name of the file to be removed. Typically the file name,
such as: picture01.png
Internal. If true don't remove files from list.
or Number
Sacrificing some readbilty for compactness. this.id
will be on the beginning of the topic, so more than
one uploader can be on a page and can have unique calls.
The url targeted for upload. An absolute URL is preferred. Relative URLs are
changed to absolute.
If true, outputs traces from the SWF to console. What exactly gets passed
is very relative, and depends upon what traces have been left in the DEFT SWF.
Re-implemented. devMode increases the logging, adding style tracing from the SWF.
id: String
The object id, just like any other widget in Dojo. However, this id
is also used as a reference for the SWF
id: "",
The name of the class that will style the button in a "normal" state.
If baseClass is not defined, 'class' will be used.
NOTE: By default the uploader will be styled like a dijit buttons and
adhere to the the themes. Tundra, Soria, and Nihilo are supported.
You can cascade the existing style by using 'class' or 'style'. If you
overwrite baseClass, you should overwrite the remaing state classes
that follow) as well.
The name of the class that will style the button in a "hover" state. A specific
class should be made to do this. Do not rely on a target like button:hover{...}
The name of the class that will style the button in a "press" state. A specific
class should be made to do this. Do not rely on a target like button:active{...}
The name of the class that will style the button when its disabled.
Use "flash" to always use Flash (and hopefully force the user to download the plugin
if they don't have it). Use "html" to always use the HTML uploader. An empty string
(default) will check for the right version of Flash and use HTML if not available.
Internal. What type of uploader is being used: "flash" or "html"
(1 - X)
(Flash only) throttles the upload to a certain amount of files at a time.
By default, Flash uploads file one at a time to the server, but in parallel.
Firefox will try to queue all files at once, leading to problems. Set this
to the amount to upload in parallel at a time.
Generally, 1 should work fine, but you can experiment with queuing more than
one at a time.
This is of course ignored if selectMultipleFiles equals false.
The id of a dom node to be used as a container for the pending file list.
If true, uploads imediately after a file has been selected. If false,
waits for upload() to be called.
If true and flash mode, multiple files may be selected from the dialog.
If html mode, files are not uploaded until upload() is called. The references
to each file is incremented:uploadedfile0, uploadedfile1, uploadedfile2... etc.
The name of the field of the fileInput that the server is expecting
The name of the field of the flash uploaded files that the server is expecting
Array[Description, FileTypes], Array[...]...]
(an array, or an array of arrays)
Restrict file selection to certain file types
Empty array defaults to "All Files"
The minimum of version of Flash player to target. 0 would always install Flash, 100
would never install it. The Flash Player has supported multiple uploads since
version 8, so it could go as low as that safely.
The tab order in the DOM. Only supported by Flash. HTML Uploaders have security
protection to prevent you from tabbing to the uploader. Stupid.
If true, the button changes to a progress bar during upload.
The message shown while the button is changed to a progress bar
The background image to use for the button-progress
The background color to use for the button-progress
The widget id of a Dijit Progress bar. The Uploader will bind to it and update it
automatically.
If true, will not verify that the server was sent the correct format.
This can be safely set to true. The purpose of the server side check
is mainly to show the dev if they've implemented the different returns
correctly.
(milliseconds)
The amount of time given to the uploaded file
to wait for a server response. After this amount
of time, the onComplete is fired but with a 'server timeout'
error in the returned item.
you can add value to list with add method.
you can only remove by clicking close button
|| Array
Sets the value of the widget.
If the value has changed, then fire onChange event, unless priorityChange
is specified as null (or false?)
|| String
Class which will be used to create the input box. You can implements yours.
It must be a widget, focusNode or domNode must have "onkeydown" event
It must have .attr("value") to get value
It also must impement an (or more) handler for the "onChange" method
|| Array
The widget will connect on all handler to check input value
You can use comma separated list
If true, only valid value will be submited with form
If true, onBlur event do a validate (like pressing ENTER)
if false, the list will be editable
Can only be set when instanciate
Specify max item the list can have
null = infiny
if true, a close button will be added on valid item
if true, a close button will be added on invalid item
regular expression string used to validate the input
Do not specify both regExp and regExpGen
"[a-zA-Z.-_]+@[a-zA-Z.-_]+.[a-zA-Z]+",
|| Array
delimiter for the string. Every match will be splitted
The string can contain only one delimiter
user-defined object needed to pass parameters to the validator functions
If true, then item will use an anime to show hide itself
Animation duration
function used to easing on fadeIn end
function used to easing on fadeOut end
If true, items can be edited
Can only be set when instanciate
If true, arraow left and right can be used for editing
Can only be set when instanciate
Array of widget.
Contain all reference to _ListInputInputItem
Widget currently in edition
Widget use for input box
Count items
Simple <li> with close button added to ListInputInput when delimiter is found
ref to the close button node
if true, item is editable
value of item
regular expression string used to validate the input
Do not specify both regExp and regExpGen
inline edit box
handle for the keyDown connect
Auto sized textbox based on dijit.form.TextBox
Min width of the input box
Fires onChange for each value change or only on demand
Force to true in order to get onChanged called
regular expression string used to validate the input
Do not specify both regExp and regExpGen
This widget hosts dojox.form.manager mixins.
See dojox.form.manager._Mixin for more info.
The character to use to separate items in the ComboBox input
Our parent (the PasswordValidator)
Don't override this - we are all "password" types
Whether or not the password is valid
Whether or not this widget is required (default: true)
Whether or not it is required for form submission
The name to send our old password as (when form is posted)
or Number
optional
optional
dojo.connect(widget, "onStarClick", function(event){ ... })
The number of stars to show, default is 3.
The current value of the Rating
This widget is the same as a normal NumberSpinner, but for the time component of a date object instead
A bare-bones, stylable file-input button, with optional multi-file selection. The list
of files is not displayed, that is for you to handle by connecting to the onChange
event, or use the dojox.form.uploader.FileList.
Uploader without plugins does not have any ability to upload - it is for use in forms
where you handle the upload either by a standard POST or with Ajax using an iFrame. This
class is for convenience of multiple files only. No progress events are available.
If the browser supports a file-input with the "multiple" attribute, that will be used.
If the browser does not support "multiple" (ergo, IE) multiple inputs are used,
one for each selection.
bytesLoaded: Number
Amount of bytes uploaded so far of entire payload (all files)
bytesTotal: Number
Amount of bytes of entire payload (all files)
type: String
Type of event (progress or load)
timeStamp: Number
Timestamp of when event occurred
or String
?
Node ?
If true, uploads imediately after a file has been selected. If false,
waits for upload() to be called.
The tab order in the DOM.
If true and flash mode, multiple files may be selected from the dialog.
The text used in the button that when clicked, opens a system Browse Dialog.
The url targeted for upload. An absolute URL is preferred. Relative URLs are
changed to absolute.
The name attribute needs to end with square brackets: [] as this is the standard way
of handling an attribute "array". This requires a slightly different technique on the
server.
If set, this will be the name of the field of the flash uploaded files that the server
is expecting. If not set, "Flash" is appended to the "name" property.
[readonly]
The type of uploader being used. As an alternative to determining the upload type on the
server based on the fieldName, this property could be sent to the server to help
determine what type of parsing should be used.
The id of the stack that this widget is supposed to control
A prefix to remove from our stack pane ids when setting our options.
This exists so that we won't run into unique ID constraints. For
example, if stackPrefix is set to "foo_", and there are three panes
in our stack with ids of "foo_a", "foo_b", and "foo_c", then the values
of the options created for the stack controller widget will be "a",
"b", and "c". This allows you to have multiple select stack widgets
with the same values - without having to have the panes require the
same ids.
Function that takes three parameters: a name, an object
(usually node or widget), and a value. This action will
be applied to all elements of array.
Function that takes three parameters: a name, an object
(usually node or widget), and a value.
Form node.
This mixin provides unified way to check/add/remove a class
of controlled elements.
It should be used together with dojox.form.manager.Mixin.
The class name to test for.
If it is an array, it is a list of names to be processed.
If it is an object, dictionary keys are names to be processed.
If it is omitted, all known form elements are to be processed.
Class name to add.
If it is an array, it is a list of names to be processed.
If it is an object, dictionary keys are names to be processed.
If it is omitted, all known form elements are to be processed.
Class name to remove.
If it is an array, it is a list of names to be processed.
If it is an object, dictionary keys are names to be processed.
If it is omitted, all known form elements are to be processed.
This mixin provides unified show/hide functionality for
controlled elements (indicated by dojoAttachPoint attribute).
Essentially it provides a way to change "style.display"
parameter of controlled nodes.
It should be used together with dojox.form.manager.Mixin.
If it is an array, it is a list of names to be processed.
If it is an object, dictionary keys are names to be processed.
If it is omitted, all known attach point nodes are to be processed.
Optional. If a name-value dictionary, the value is true
to show and false to hide. If an array, all names in the
array will be set to defaultState. If omitted, all form
elements will be set to defaultState.
The default state (true, if omitted).
Optional. If a name-value dictionary, the value is true
to show and false to hide. If an array, all names in the
array will be hidden. If omitted, all form elements
will be hidden.
This mixin provides unified enable/disable functionality for
form widgets and form elements. It should be used together
with dojox.form.manager.Mixin.
If it is an array, it is a list of names to be processed.
If it is an object, dictionary keys are names to be processed.
If it is omitted, all known form elements are to be processed.
Optional. If a name-value dictionary, the value is true
to enable and false to disable. If an array, all names in the
array will be set to defaultState. If omitted, all form
elements will be set to defaultState.
The default state (true, if omitted).
Optional. If a name-value dictionary, the value is true
to enable and false to disable. If an array, all names in the
array will be disabled. If omitted, disables all.
This mixin adds automated "onreset", and "onsubmit" event processing
if we are based on a form node, defines onReset(), onSubmit(),
reset(), submit(), and isValid() methods like dijit.form.Form.
It should be used together with dojox.form.manager.Mixin.
This mixin provideas a foundation for an enhanced form
functionality: unified access to individual form elements,
unified "onchange" event processing, general event
processing, I/O orchestration, and common form-related
functionality. See additional mixins in dojox.form.manager
namespace.
A widget, or its widgetId, or its DOM node
Object:
Returns self
Name of the to unregister
Object:
Returns self
A widget, or its widgetId, or its DOM node
Object:
Returns self
A widget, or its widgetId, or its DOM node
Object:
Returns self
Form element's name, widget object, or array or radio widgets.
Optional. The value to set.
Object:
For a getter it returns the value, for a setter it returns
self. If the elem is not valid, null will be returned.
A node.
Optional. The value to set.
Object:
For a getter it returns the value, for a setter it returns
self. If the elem is not valid, null will be returned.
A function to be called on a widget. Takes three arguments: a name, a widget object
or an array of widget objects, and a supplied value. Runs in the context of
the form manager. Returns a value that will be collected and returned as a state.
Optional. If a name-value dictionary --- only listed names will be processed.
If an array, all names in the array will be processed with defaultValue.
If omitted or null, all widgets will be processed with defaultValue.
Optional. The default state (true, if omitted).
A function to be called on a node. Takes three arguments: a name, a node or
an array of nodes, and a supplied value. Runs in the context of the form manager.
Returns a value that will be collected and returned as a state.
Optional. If a name-value dictionary --- only listed names will be processed.
If an array, all names in the array will be processed with defaultValue.
If omitted or null, all attached point nodes will be processed with defaultValue.
Optional. The default state (true, if omitted).
A function to be called on a widget, form element, and an attached node.
Takes three arguments: a name, a node (domNode in the case of widget) or
an array of such objects, and a supplied value. Runs in the context of
the form manager. Returns a value that will be collected and returned as a state.
Optional. If a name-value dictionary --- only listed names will be processed.
If an array, all names in the array will be processed with defaultValue.
If omitted or null, all controlled elements will be processed with defaultValue.
Optional. The default state (true, if omitted).
This mixin provideas a foundation for an enhanced form
functionality: unified access to individual form elements,
unified "onchange" event processing, and general event
processing. It complements dojox.form.manager._Mixin
extending the functionality to DOM nodes.
A node, or its id
Object:
Returns self
Name of the to unregister
Object:
Returns self
A widget, or its widgetId, or its DOM node
Object:
Returns self
A widget, or its widgetId, or its DOM node
Object:
Returns self
Form element's name, DOM node, or array or radio nodes.
Optional. The value to set.
Object:
For a getter it returns the value, for a setter it returns
self. If the elem is not valid, null will be returned.
A function to be called on a form element. Takes three arguments: a name, a node or
an array of nodes, and a supplied value. Runs in the context of the form manager.
Returns a value that will be collected and returned as a state.
Optional. If a name-value dictionary --- only listed names will be processed.
If an array, all names in the array will be processed with defaultValue.
If omitted or null, all form elements will be processed with defaultValue.
Optional. The default state (true, if omitted).
This mixin adds unified access to form widgets and form elements
in terms of name-value regardless of the underlying type of
an element. It should be used together with dojox.form.manager.Mixin.
The name.
Optional. The value to set.
If it is an array, it is a list of names of form elements to be collected.
If it is an object, dictionary keys are names to be collected.
If it is omitted, all known form elements are to be collected.
A dictionary of key-value pairs.
Should not be used as a standalone. To be mixed in with other classes.
There is a required CSS file: resources/UploaderFileList.css.
This is a very simple widget, and not beautifully styled. It is here mainly for test
cases, but could very easily be used, extended, modified, or copied.
The id of the dojox.form.Uploader to connect to.
The dojox.form.Uploader to connect to. Use either this property of unploaderId. This
property is populated if uploaderId is used.
The label for the index column.
The label for the file type column.
The label for the file name column.
The label for the file size column.
Inherits all properties from dojox.form.Uploader and dojox.form.uploader.plugins.HTML5.
All properties and methods listed here are specific to the Flash plugin only.
Sacrificing some readbilty for compactness. this.id
will be on the beginning of the topic, so more than
one uploader can be on a page and can have unique calls.
Path to SWF. Can be overwritten or provided in djConfig.
If true, will not verify that the server was sent the correct format.
This can be safely set to true. The purpose of the server side check
is mainly to show the dev if they've implemented the different returns
correctly.
(milliseconds)
The amount of time given to the uploaded file
to wait for a server response. After this amount
of time, the onComplete is fired but with a 'server timeout'
error in the returned item.
If true, outputs traces from the SWF to console. What exactly gets passed
is very relative, and depends upon what traces have been left in the DEFT SWF.
Re-implemented. devMode increases the logging, adding style tracing from the SWF.
(1 - X)
(Flash only) throttles the upload to a certain amount of files at a time.
By default, Flash uploads file one at a time to the server, but in parallel.
Firefox will try to queue all files at once, leading to problems. Set this
to the amount to upload in parallel at a time.
Generally, 1 should work fine, but you can experiment with queuing more than
one at a time.
This is of course ignored if selectMultipleFiles equals false.
Use "flash" to always use Flash (and hopefully force the user to download the plugin
if they don't have it).
Add this plugin to have HTML5 capabilities in the Uploader. Note that it does not add
these capabilities to browsers that don't support them. For IE or older browsers, add
additional plugins: IFrame or Flash.
?
Node ?
Only supported by IE, due to the specifc iFrame hack used. The
dojox.form.uploader.plugins.HTML5 plugin should be used along with this to add HTML5
capabilities to browsers that support them. Progress events are not supported.
Inherits all properties from dojox.form.Uploader and dojox.form.uploader.plugins.HTML5.
?
A package of animations, and FX-related code, extending Dojo Core fx.
Including this package includes all the Base and Core fx packages.
The Timeline is a replacement for the default dojo._Line.
Instead of _Line.getValue returning a float between 0-1,
_Timeline.getValue returns an object with all properties and
their current values.
A property does not have to appear in every keyframe.
As in the example below, "height" is transitioned from the first
keyframe to the third. "width" is transitioned from the first
to the second to the third.
Each keyframe can accept the following custom properties:
step: String
The start, finish or percentage that this keyframe represents.
Allowed parameters are:
0%-100%
from (same as 0%, used to conform with the Webkit animation spec)
to (same as 100%, used to conform with the Webkit animation spec)
ease: String
The string name of a dojo.fx.easing ease. Defaults to "linear". Use
the suffix name of the ease, like: "quadIn", not: "dojo.fx.quadIn".
var keys = [
{
step:"0px",
ease:"quadInOut",
width:"50px",
height:"50px",
},{
step:"25%",
width:"190px"
},{
step:"100%",
width:"10px",
height:"200px",
}
];
ani = dojox.fx.animateTimeline({keys:keys, duration:2000}, "myDiv").play();
The paramters passed to the timeline animation. Includes:
keys: Array
An array of objects, with style properties and values.
duration:
Duration of the animation in milliseconds.
Defaults to 1000.
DomNode The DomNode or id to be animated.
Returns an animation that will size the target node
defined in args Object about it's center to
a width and height defined by (args.width, args.height),
supporting an optional method: chain||combine mixin
(defaults to chain).
- works best on absolutely or relatively positioned elements
// size #myNode to 400px x 200px over 1 second
dojo.fx.sizeTo({
node:'myNode',
duration: 1000,
width: 400,
height: 200,
method: "combine"
}).play();
Returns an animation that will slide a node (args.node) from it's
current position to it's current posision plus the numbers defined
in args.top and args.left. standard dojo.fx mixin's apply.
// slide domNode 50px down, and 22px left
dojox.fx.slideBy({
node: domNode, duration:400,
top: 50, left: -22
}).play();
args.nodes: Array - two element array of domNodes, or id's
all other standard animation args mixins apply. args.node ignored.
Returns an animation that sets the node background to args.color
then gradually fades back the original node background color
dojox.fx.highlight({ node:"foo" }).play();
Returns an animation that will expand the
node defined in 'args' object from it's current to
the height or width value given by the args object.
default to height:, so leave height null and specify width:
to wipeTo a width. note: this may be deprecated by a
Note that the final value should not include
units and should be an integer. Thus a valid args object
would look something like this:
dojox.fx.wipeTo({ node: "nodeId", height: 200 }).play();
Node must have no margin/border/padding, so put another
node inside your target node for additional styling.
Returns an animation that will flip the
node around a central axis:
if args.dir is "left" or "right" --> y axis
if args.dir is "top" or "bottom" --> x axis
This effect is obtained using a border distorsion applied to a helper node.
The user can specify three background colors for the helper node:
darkColor: the darkest color reached during the animation
lightColor: the brightest color
endColor: the final backgroundColor for the node
depth: Float
0 <= depth <= 1 overrides the computed "depth"
(0: min distorsion, 1: max distorsion)
whichAnim: String
"first" : the first half animation
"last" : the second one
"both" (default) : both
axis: String
"center" (default) : the node is flipped around his center
"shortside" : the node is flipped around his "short" (in perspective) side
"longside" : the node is flipped around his "long" (in perspective) side
"cube" : the node flips around the central axis of the cube
shift: Integer
node translation, perpendicular to the rotation axis
var anim = dojox.fx.flip({
node: dojo.byId("nodeId"),
dir: "top",
darkColor: "#555555",
lightColor: "#dddddd",
endColor: "#666666",
depth: .5,
shift: 50,
duration:300
});
An extension to `dojox.fx.flip` providing a more 3d-like rotation.
Behaves the same as `dojox.fx.flip`, using the same attributes and
other standard `dojo.Animation` properties.
See `dojox.fx.flip`
An extension to `dojox.fx.flip` providing a page flip effect.
Behaves the same as `dojox.fx.flip`, using the same attributes and
other standard `dojo.Animation` properties.
See `dojox.fx.flip`
An extension to `dojox.fx.flip` providing a page flip effect.
Behaves the same as `dojox.fx.flip`, using the same attributes and
other standard `dojo.Animation` properties and
cols: Integer columns
rows: Integer rows
duration: the single flip duration
See `dojox.fx.flip`
This implementation support either horizontal or vertical scroll, as well as
both. In addition, element in iframe can be scrolled to correctly.
offset: {x: int, y: int} this will be added to the target position
duration: Duration of the animation in milliseconds.
win: a node or window object to scroll
Returns an animation that will split the node into a grid
of pieces that move independently.
args.crop: Boolean - If true, pieces will only be visible inside node's boundries
args.rows: Integer - The number of horizontal pieces (default is 3)
args.columns: Integer - The number of vertical pieces (default is 3)
args.pieceAnimation: Function(piece, x, y, coords) - Returns either the dojo.Animation
or an array of dojo.Animation objects for the piece at location (x, y) in the node's grid;
coords is the result of dojo.coords(args.node, true);
Returns an animation that will split the node into a grid
of pieces that fly away from the center.
args.rows: Integer - The number of horizontal pieces (default is 3)
args.columns: Integer - The number of vertical pieces (default is 3)
args.random: Float - If set, pieces fly to random distances, for random durations,
and in slightly random directions. The value defines how much
randomness is introduced.
args.distance: Float - Multiplier for the distance the pieces fly (even when random)
args.fade: Boolean - If true, pieces fade out while in motion (default is true)
args.fadeEasing: Function - If args.fade is true, the fade animations use this easing function
args.unhide: Boolean - If true, the animation is reversed
args.sync: Boolean - If args.unhide is true, all the pieces converge at the same time
(default is true)
Returns an animation that will split the node into a grid
of pieces that drop.
args.rows: Integer - The number of horizontal pieces (default is 5)
args.columns: Integer - The number of vertical pieces (default is 5)
args.interval: Float - The number of milliseconds between each piece's animation
args.distance: Float - The number of the node's heights to drop (default is 1.5)
args.fade: Boolean - If true, pieces fade out while in motion (default is true)
args.random: Float - If set, pieces fall in random order. The value defines how much
randomness is introduced.
args.reverseOrder: Boolean - If true, pieces animate in reversed order
args.unhide: Boolean - If true, the peices fall from above and land in place
Returns an animation that will split the node into a grid
of pieces that slide in alternating directions.
args.rows: Integer - The number of horizontal pieces (default is 6)
args.columns: Integer - The number of vertical pieces (default is 6)
args.interval: Float - The number of milliseconds between each piece's animation (default is 0)
args.distance: Float - The multiple of the node's dimensions to slide (default is 1)
args.fade: Boolean - If true, pieces fade out while in motion (default is true)
args.random: Float - If true, pieces have a random delay. The value defines how much
randomness is introduced
args.reverseOrder: Boolean - If true, pieces animate in reversed order
args.unhide: Boolean - If true, the animation is reversed
Returns an animation that will split the node into a grid
of pieces that wipe in alternating directions.
args.rows: Integer - The number of horizontal pieces (default is 4)
args.columns: Integer - The number of vertical pieces (default is 4)
args.interval: Float - The number of milliseconds between each piece's animation (default is 0)
args.distance: Float - The percentage of the piece's dimensions the piece should wipe
args.fade: Boolean - If true, pieces fade out while in motion (default is true)
args.random: Float - If true, pieces have a random delay. The value defines how much
randomness is introduced.
args.unhide: Boolean - If true, the animation is reversed
Returns an animation that will split the node into a grid
of pieces that fade in or out.
args.rows: Integer - The number of horizontal pieces (default is 5)
args.columns: Integer - The number of vertical pieces (default is 5)
args.interval: Float - The number of milliseconds between each piece's animation (default is 0)
args.random: Float - If true, pieces have a random delay. The value defines how much
randomness is introduced
args.reverseOrder: Boolean - If true, pieces animate in reversed order
args.unhide: Boolean - If true, the animation is reversed
Creates an animation that will animate
the properties of a node to the properties
defined in a standard CSS .class definition.
(calculating the differences itself)
.bar { line-height: 12px; }
.foo { line-height: 40px; }
<div class="bar" id="test">
Multi<br>line<br>text
</div>
// animate to line-height:40px
dojo.fx.addClass("test", "foo").play();
A String ID or DomNode referce to animate
The CSS class name to add to the node
Additional optional <code>dojo.animateProperty</code> arguments, such as
duration, easing and so on.
Creates an animation that will animate the properties of a
node (args.node) to the properties calculated after removing
a standard CSS className from a that node.
calls dojo.removeClass(args.cssClass) onEnd of animation
standard dojo.Animation object rules apply.
// animate the removal of "foo" from a node with id="bar"
dojox.fx.removeClass("bar", "foo").play()
creates an animation that will animate the effect of
toggling a class on or off of a node.
Adds a class to node if not present, or removes if present.
Pass a boolean condition if you want to explicitly add or remove.
// add the class "sampleClass" to a node id="theNode"
dojox.fx.toggleClass("theNode","sampleClass",true).play();
// toggle the class "sampleClass" on the node id="theNode"
dojox.fx.toggleClass("theNode","sampleClass").play();
The domNode (or string of the id) to toggle
String of the classname to add to the node
If passed, true means to add the class, false means to remove.
Additional <code>dojo.Animation</code> args to pass along.
An Alias to <code>dojo.fx.easing</code>. Moved to Core in Dojo 1.2.
Module to provide scroll-related FX
Module to provide CSS animations
Base location for drop-shadow images
How wide (in px) to make the shadow
How deep to make the shadow appear to be
Overall opacity of the shadow
A toggle to disable animated transitions
The node we will be applying this shadow to
The node to manipulate
The class to use during the manipulation
the width to set
the height to set
a normal dojo._Line is the curve, and does Line(start,end)
for propertyAnimation. as we make more complicatied animations, we realize
some properties can have 2, or 4 values relevant (x,y) or (t,l,r,b) for example
this function provides support for those Lines, and is ported directly from 0.4
this is a lot of extra code for something so seldom used, so we'll put it here as
and optional core addition. you can create a new line, and use it during onAnimate
as you see fit.
a floating point number greater than 0 and less than 1
Mixed
An Integer (or an Array of integers) to use as a starting point
An Integer (or an Array of integers) to use as an ending point
module to include to support dojox.fx animations in dojo.query()
Returns an animation that will split the node into a grid
of pieces that move independently.
NOTE:
In some rendering engines, the text will appear to "jump" from its initial position
when the animation begins. To work around this bug, enclose the node's text in a <p> or <div>.
args.crop: Boolean - If true, pieces will be positioned relatively rather than absolutely
args.text: String - Text to place inside the node (otherwise node.innerHTML is used)
args.words: Boolean - If true, the text will be split into words rather than characters
args.pieceAnimation: Function(piece, pieceCoords, nodeCoords, number, numPieces)
- Returns either the dojo.Animation or an array of dojo.Animation objects for the piece;
pieceCoords is the result of dojo.coords(piece, true);
nodeCoords is the result of dojo.coords(args.node, true);
number is the piece's position in the array of pieces, and numPieces is the array.length
Returns an animation that will split the text into a spans
of words or characters that fly away from the center.
args.crop: Boolean - If true, pieces will be positioned relatively rather than absolutely
args.words: Boolean - If true, text will be split into words rather than characters
args.random: Float - If set, pieces fly to random distances, for random durations,
and in slightly random directions. The value defines how much
randomness is introduced.
args.distance: Float - Multiplier for the distance the pieces fly (even when random)
args.fade: Boolean - If true, pieces fade out while in motion (default is true)
args.fadeEasing: Function - If args.fade is true, the fade animations use this easing function
args.unhide: Boolean - If true, the animation is reversed
args.sync: Boolean - If args.unhide is true, all the pieces converge at the same time
(default is true)
Returns an animation that will split the text into spans of words
or characters that drop.
args.crop: Boolean - If true, pieces will be positioned relatively rather than absolutely
args.words: Boolean - If true, text will be split into words rather than characters
args.interval: Float - The number of milliseconds between each piece's animation
args.distance: Float - The number of the node's heights to drop (default is 1.5)
args.fade: Boolean - If true, pieces fade out while in motion (default is true)
args.random: Float - If set, pieces fall in random order. The value defines how much
randomness is introduced
args.reverseOrder: Boolean - If true, pieces animate in reversed order
args.unhide: Boolean - If true, the peices fall from above and land in place
Returns an animation that will split the text into spans of words
or characters that fade in or out.
args.words: Boolean - If true, text will be split into words rather than characters
args.interval: Float - The number of milliseconds between each piece's animation (default is 0)
args.random: Float - If true, pieces have a random delay. The value defines how much
randomness is introduced
args.reverseOrder: Boolean - If true, pieces animate in reversed order
args.unhide: Boolean - If true, the animation is reversed
Returns an animation that will split the text into spans of words
or characters that appear as if they were being backspaced (or typed) in real-time.
args.interval: Float - The number of milliseconds between each piece's animation
(default is determined by text length and args.duration);
args.wordDelay: Integer - The number of milliseconds between each word
(only effective when args.unhide = true)
args.fixed: Boolean - If true, only style.opacity changes; otherwise, style.display
changes between none and inline, adding realism (default = false)
args.random: Float - If true, pieces have a random delay. The value defines how much
randomness is introduced (only effective when args.unhide = true)
args.unhide: Boolean - If true, the animation is reversed
Support rendering Americas, AsiaPacific, ContinentalEurope, EuropeMiddleEastAfrica,
USStates, WorldCountries, and WorldCountriesMercator by default.
map container html node/id
map shape data url, handled as json style
data format:
outside marker data url, handled as json style.
data format: {"NY":"New York",.....}
Default map feature color, e.g: "#B7B7B7"
Map feature color when mouse over it, e.g: "#"
stack to data range, e.g: [{name:'label 1', min:20, max:70, color:'#DDDDDD'},{...},...]
container html node/id
shapeFile:
map shape data url, handled as json style
data format:
a shape object to be moved
an optional object with additional parameters;
following parameters are recognized:
mouse event
mouse event
mouse event
a shape object to be moved
params: Object: an optional object with additional parameters;
following parameters are recognized:
delay move by this number of pixels
a constructor of custom Mover
a shape object to be moved
a mouse event, which started the move;
only clientX and clientY properties are used
object which implements the functionality of the move,
and defines proper events (onMoveStart and onMoveStop)
mouse event
object which implements the functionality of the move,
and defines proper events (onMoveStart and onMoveStop)
a shape object to be moved
e: Event: a mouse event, which started the move;
only clientX and clientY properties are used
The main method of a VectorFont, draw() will take a text fragment
and render it in a set of groups and paths based on the parameters
passed.
The basics of drawing text are simple enough: pass it your text as
part of the textArgs object, pass size and family info as part of
the fontArgs object, pass at least a color as the fillArgs object,
and if you are looking to create an outline, pass the strokeArgs
object as well. fillArgs and strokeArgs are the same as any other
gfx fill and stroke arguments; they are simply applied to any path
object generated by this method.
Resulting GFX structure
-----------------------
The result of this function is a set of gfx objects in the following
structure:
dojox.gfx.Group // the parent group generated by this function
+ dojox.gfx.Group[] // a group generated for each line of text
+ dojox.gfx.Path[] // each glyph/character in the text
Scaling transformations (i.e. making the generated text the correct size)
are always applied to the parent Group that is generated (i.e. the top
node in the above example). In theory, if you are looking to do any kind
of other transformations (such as a translation), you should apply it to
the group reference you pass to this method. If you find that you need
to apply transformations to the group that is returned by this method,
you will need to reapply the scaling transformation as the *last* transform,
like so:
textGroup.setTransform(new dojox.gfx.Matrix2D([
dojox.gfx.matrix.translate({ dx: dx, dy: dy }),
textGroup.getTransform()
]));
In general, this should never be necessary unless you are doing advanced
placement of your text.
Advanced Layout Functionality
-----------------------------
In addition to straight text fragments, draw() supports a few advanced
operations not normally available with vector graphics:
* Flow operations (i.e. wrap to a given width)
* Fitting operations (i.e. find a best fit to a given rectangle)
To enable either, pass a `fitting` property along with the textArgs object.
The possible values are contained in the dojox.gfx.vectorFontFitting enum
(NONE, FLOW, FIT).
`Flow fitting`
Flow fitting requires both a passed size (in the fontArgs object) and a
width (passed with the textArgs object). draw() will attempt to split the
passed text up into lines, at the closest whitespace according to the
passed width. If a width is missing, it will revert to NONE.
`Best fit fitting`
Doing a "best fit" means taking the passed text, and finding the largest
size and line breaks so that it is the closest fit possible. With best
fit, any size arguments are ignored; if a height is missing, it will revert
to NONE.
Other notes
-----------
`a11y`
Since the results of this method are rendering using pure paths (think
"convert to outlines" in Adobe Illustrator), any text rendered by this
code is NOT considered a11y-friendly. If a11y is a requirement, we
suggest using other, more a11y-friendly methods.
`Font sources`
Always make sure that you are legally allowed to use any fonts that you
convert to SVG format; we claim no responsibility for any licensing
infractions that may be caused by the use of this code.
a point-like object as a start of the arc
a horizontal radius for the virtual ellipse
a vertical radius for the virtual ellipse
a rotation of an x axis of the virtual ellipse in degrees
which part of the ellipse will be used (the larger arc if true)
direction of the arc (CW if true)
the x coordinate of the end point of the arc
the y coordinate of the end point of the arc
a parent node
width of surface, e.g., "100px"
height of surface, e.g., "100px"
width of surface, e.g., "100px"
height of surface, e.g., "100px"
the image object
the url of the image
a 2D matrix object to be applied
Number: an x coordinate of a point
Number: a y coordinate of a point
The resulting matrix is used to translate (move) points by specified offsets.
an x coordinate value
a y coordinate value
The resulting matrix is used to scale (magnify) points by specified offsets.
a scaling factor used for the x coordinate
a scaling factor used for the y coordinate
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified angle.
an angle of rotation in radians (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx.matrix.rotate() for comparison.
an angle of rotation in degrees (>0 for CW)
The resulting matrix is used to skew points in the x dimension
around the origin of coordinates (0, 0) by specified angle.
an skewing angle in radians
The resulting matrix is used to skew points in the x dimension
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx.matrix.skewX() for comparison.
an skewing angle in degrees
The resulting matrix is used to skew points in the y dimension
around the origin of coordinates (0, 0) by specified angle.
an skewing angle in radians
The resulting matrix is used to skew points in the y dimension
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx.matrix.skewY() for comparison.
an skewing angle in degrees
The resulting matrix is used to reflect points around a vector,
which goes through the origin.
a point-like object, which specifies a vector of reflection
The resulting matrix is used to project points orthogonally on a vector,
which goes through the origin.
a point-like object, which specifies a vector of projection
Converts any 2D matrix-like object or an array of
such objects to a valid dojox.gfx.matrix.Matrix2D object.
an object, which is converted to a matrix, if necessary
a 2D matrix-like object to be cloned
a 2D matrix-like object to be inverted
a 2D matrix object to be applied
an x coordinate of a point
a y coordinate of a point
a 2D matrix-like object,
all subsequent arguments are matrix-like objects too
a 2D matrix-like object, which is applied at a central point
an x component of the central point
a y component of the central point
Compare with dojox.gfx.matrix.scale().
a scaling factor used for the x coordinate
a scaling factor used for the y coordinate
an x component of a central point
a y component of a central point
Compare with dojox.gfx.matrix.rotate().
an angle of rotation in radians (>0 for CW)
an x component of a central point
a y component of a central point
Compare with dojox.gfx.matrix.rotateg().
an angle of rotation in degrees (>0 for CW)
an x component of a central point
a y component of a central point
Compare with dojox.gfx.matrix.skewX().
an skewing angle in radians
an x component of a central point
a y component of a central point
Compare with dojox.gfx.matrix.skewXg().
an skewing angle in degrees
an x component of a central point
a y component of a central point
Compare with dojox.gfx.matrix.skewY().
an skewing angle in radians
an x component of a central point
a y component of a central point
Compare with dojox.gfx.matrix.skewYg().
Number: an skewing angle in degrees
Number: an x component of a central point
Number: a y component of a central point
an identity matrix constant: identity * (x, y) == (x, y)
a matrix, which reflects points at x = 0 line: flipX * (x, y) == (-x, y)
a matrix, which reflects points at y = 0 line: flipY * (x, y) == (x, -y)
a matrix, which reflects points at the origin of coordinates: flipXY * (x, y) == (-x, -y)
dojox.gfx.fx.animateStroke{{
shape: shape,
duration: 500,
color: {start: "red", end: "green"},
width: {end: 15},
join: {values: ["miter", "bevel", "round"]}
}).play();
dojox.gfx.fx.animateFill{{
shape: shape,
duration: 500,
color: {start: "red", end: "green"}
}).play();
dojox.gfx.fx.animateFont{{
shape: shape,
duration: 500,
variant: {values: ["normal", "small-caps"]},
size: {end: 10, units: "pt"}
}).play();
dojox.gfx.fx.animateTransform{{
shape: shape,
duration: 500,
transform: [
{name: "translate", start: [0, 0], end: [200, 200]},
{name: "original"}
]
}).play();
input gradient as a list of colors with offsets
(see dojox.gfx.defaultLinearGradient and dojox.gfx.defaultRadialGradient)
the beginning of the window, should be less than "to"
the end of the window, should be more than "from"
matrix to apply to a shape and its gradient
a linear gradient object to be transformed
top-left corner of shape's bounding box
right-bottom corner of shape's bounding box
top-left corner of shape's transformed bounding box
right-bottom corner of shape's transformed bounding box
fill object
point where to sample a color
fill object
Normalizes a 2D matrix-like object. If arrays is passed,
all objects of the array are normalized and multiplied sequentially.
a DOM node to be used by this path object
true/false or "absolute"/"relative" to specify the mode
an x coordinate
a y coordinate
a segment
valid SVG code for a segment's type
a list of parameters for this segment
an output argument (array of numbers)
an input argument (can be values of Boolean, Number, dojox.gfx.Point, or an embedded array of them)
an SVG path string
an SVG path string or a path object (see dojox.gfx.defaultPath)
a DOM node to be used by this path object
a DOM node to be used by this TextPath object
a shape object
(see dojox.gfx.defaultPath,
dojox.gfx.defaultPolyline,
dojox.gfx.defaultRect,
dojox.gfx.defaultEllipse,
dojox.gfx.defaultCircle,
dojox.gfx.defaultLine,
or dojox.gfx.defaultImage)
a fill object
(see dojox.gfx.defaultLinearGradient,
dojox.gfx.defaultRadialGradient,
dojox.gfx.defaultPattern,
or dojo.Color)
a stroke object
(see dojox.gfx.defaultStroke)
a matrix or a matrix-like object
(see an argument of dojox.gfx.Matrix2D
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx.Matrix2D
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx.Matrix2D
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx.Matrix2D
constructor for a list of acceptable arguments)
if true, do not redraw a picture yet
a parent or null
(see dojox.gfx.Surface,
dojox.gfx.shape.VirtualGroup,
or dojox.gfx.Group)
a 2D matrix or a matrix-like object
a 2D matrix or a matrix-like object
underlying node
This object is defined for documentation purposes.
You should use the naked object instead: {x: 1, y: 2}.
This object is defined for documentation purposes.
You should use the naked object instead: {x: 1, y: 2, width: 100, height: 200}.
a DOM Node
a DOM Node
a DOM Node
a DOM Node
a DOM Node
a DOM Node
a DOM Node
a DOM Node
a DOM Node
a polyline/polygon shape object
close the polyline to make a polygon
a DOM Node
a DOM Node
a DOM Node
a DOM Node
a font object (see dojox.gfx.defaultFont) or a font string
a DOM Node
a shape
if true, do not redraw a picture yet
a list of children
a shape descriptor object
a path object (see dojox.gfx.defaultRect)
an ellipse object (see dojox.gfx.defaultEllipse)
a circle object (see dojox.gfx.defaultCircle)
a line object (see dojox.gfx.defaultLine)
a points object (see dojox.gfx.defaultPolyline)
or an Array of points
an image object (see dojox.gfx.defaultImage)
a text object (see dojox.gfx.defaultText)
a path object (see dojox.gfx.defaultPath)
a textpath object (see dojox.gfx.defaultTextPath)
a class constructor to create an instance of
properties to be passed in to the classes "setShape" method
a parent node
width of surface, e.g., "100px"
height of surface, e.g., "100px"
an Silverlight node
an Silverlight node
a text shape object
an Silverlight node
width of surface, e.g., "100px"
height of surface, e.g., "100px"
a fill object
(see dojox.gfx.defaultLinearGradient,
dojox.gfx.defaultRadialGradient,
dojox.gfx.defaultPattern,
or dojo.Color)
a stroke object
(see dojox.gfx.defaultStroke)
a rectangle shape object
an ellipse shape object
a circle shape object
a line shape object
a polyline/polygon shape object
an image shape object
a segment
an SVG path string or a path object (see dojox.gfx.defaultPath)
a segment
an SVG path string or a path object (see dojox.gfx.defaultPath)
an SVG external reference
a parent node
width of surface, e.g., "100px"
height of surface, e.g., "100px"
an SVG node
an SVG node
a text shape object
a segment
an SVG path string or a path object (see dojox.gfx.defaultPath)
an SVG node
width of surface, e.g., "100px"
height of surface, e.g., "100px"
a fill object
(see dojox.gfx.defaultLinearGradient,
dojox.gfx.defaultRadialGradient,
dojox.gfx.defaultPattern,
or dojo.Color)
a stroke object (see dojox.gfx.defaultStroke)
a shape object
(see dojox.gfx.defaultPath,
dojox.gfx.defaultPolyline,
dojox.gfx.defaultRect,
dojox.gfx.defaultEllipse,
dojox.gfx.defaultCircle,
dojox.gfx.defaultLine,
or dojox.gfx.defaultImage)
a rectangle shape object
a polyline/polygon shape object
an image shape object
a segment
an SVG path string or a path object (see dojox.gfx.defaultPath)
|| dojox.gfx.Shape
|| dojox.gfx.Shape
|| dojox.gfx.Shape
|| dojox.gfx.Shape
|| Array
|| dojox.gfx.Shape
Function to serialize a GFX surface to SVG text. The value of this output
is that there are numerous serverside parser libraries that can render
SVG into images in various formats. This provides a way that GFX objects
can be captured in a known format and sent serverside for serialization
into an image.
The GFX surface to serialize.
Deferred object that will be called when SVG serialization is complete.
The node from which to generate the XML text representation.
a representation of a floating-point number
a parent node
width of surface, e.g., "100px"
height of surface, e.g., "100px"
an VML node
an VML node
width in pixels
height in pixels
width of surface, e.g., "100px"
height of surface, e.g., "100px"
a fill object
(see dojox.gfx.defaultLinearGradient,
dojox.gfx.defaultRadialGradient,
dojox.gfx.defaultPattern,
or dojo.Color)
a stroke object
(see dojox.gfx.defaultStroke)
width in pixels
height in pixels
a rectangle shape object
an ellipse shape object
a circle shape object
a line shape object
a polyline/polygon shape object
if true, close the polyline explicitely
an image shape object
width in pixels
height in pixels
a text shape object
a segment
an VML path string or a path object (see dojox.gfx.defaultPath)
The resulting matrix is used to translate (move) points by specified offsets.
an x coordinate value
a y coordinate value
a z coordinate value
The resulting matrix is used to scale (magnify) points by specified offsets.
a scaling factor used for the x coordinate
a scaling factor used for the y coordinate
a scaling factor used for the z coordinate
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified angle.
an angle of rotation in radians (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx3d.matrix.rotateX() for comparison.
an angle of rotation in degrees (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified angle.
an angle of rotation in radians (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx3d.matrix.rotateY() for comparison.
an angle of rotation in degrees (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified angle.
an angle of rotation in radians (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx3d.matrix.rotateZ() for comparison.
an angle of rotation in degrees (>0 for CW)
The resulting matrix is used to translate (move) points by specified offsets.
an x coordinate value
a y coordinate value
a z coordinate value
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified angle.
an angle of rotation in radians (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx3d.matrix.rotateX() for comparison.
an angle of rotation in degrees (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified angle.
an angle of rotation in radians (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx3d.matrix.rotateY() for comparison.
an angle of rotation in degrees (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified angle.
an angle of rotation in radians (>0 for CW)
The resulting matrix is used to rotate points
around the origin of coordinates (0, 0) by specified degree.
See dojox.gfx3d.matrix.rotateZ() for comparison.
an angle of rotation in degrees (>0 for CW)
Converts any 3D matrix-like object or an array of
such objects to a valid dojox.gfx3d.matrix.Matrix3D object.
an object, which is converted to a matrix, if necessary
a 3D matrix-like object to be cloned
a 2D matrix-like object to be inverted
an x coordinate of a point
a y coordinate of a point
a z coordinate of a point
a 3D matrix object to be applied
Number: an x coordinate of a point
Number: a y coordinate of a point
Number: a z coordinate of a point
a 3D matrix-like object,
all subsequent arguments are matrix-like objects too
an x coordinate of a point
a y coordinate of a point
a z coordinate of a point
a 3D matrix object to be applied
Number: an x coordinate of a point
Number: a y coordinate of a point
Number: a z coordinate of a point
an identity matrix constant: identity * (x, y, z) == (x, y, z)
Normalizes a 3D matrix-like object. If arrays is passed,
all objects of the array are normalized and multiplied sequentially.
a matrix or a matrix-like object
(see an argument of dojox.gfx.matrix.Matrix
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx3d.matrix.Matrix
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx3d.matrix.Matrix
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx3d.matrix.Matrix
constructor for a list of acceptable arguments)
Array: an array of light object
or lights object
Color: an ambient object
Color: an specular object
|| light object: light object(s)
the dimension of the canvas
a matrix or a matrix-like object
(see an argument of dojox.gfx3d.matrix.Matrix
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx.matrix.Matrix
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx.matrix.Matrix
constructor for a list of acceptable arguments)
a matrix or a matrix-like object
(see an argument of dojox.gfx.matrix.Matrix
constructor for a list of acceptable arguments)
a fill object
(see dojox.gfx.defaultLinearGradient,
dojox.gfx.defaultRadialGradient,
dojox.gfx.defaultPattern,
dojo.Color
or dojox.gfx.MODEL)
a stroke object
(see dojox.gfx.defaultStroke)
an abstract Object object
(see dojox.gfx3d.defaultEdges,
dojox.gfx3d.defaultTriangles,
dojox.gfx3d.defaultQuads
dojox.gfx3d.defaultOrbit
dojox.gfx3d.defaultCube
or dojox.gfx3d.defaultCylinder)
of points || Object
optional
an output argument (array of numbers)
an input argument (can be values of Boolean, Number, dojox.gfx.Point, or an embedded array of them)
valid SVG code for a segment's type
a list of parameters for this segment
of points || Object
optional
of points || Object
optional
of points || Object
of points || Object
of points || Object
if true, do not redraw a picture yet
dojox.gfx3d.Object
an x coordinate of a point
a y coordinate of a point
a z coordinate of a point
an x coordinate of a point
a y coordinate of a point
a z coordinate of a point
Number: an x coordinate of a point
Number: a y coordinate of a point
Number: a z coordinate of a point
Number: an x coordinate of a point
Number: a y coordinate of a point
Number: a z coordinate of a point
an x coordinate of a point
a y coordinate of a point
a z coordinate of a point
an x coordinate of a point
a y coordinate of a point
a z coordinate of a point
Number: an x coordinate of a point
Number: a y coordinate of a point
Number: a z coordinate of a point
Number: an x coordinate of a point
Number: a y coordinate of a point
Number: a z coordinate of a point
Object: a point
Object: a point
Object: a point
Provides data to display in a grid cell. Called in grid cell context.
So this.cell.index is the column index.
Row for which to provide data
Data to display for a given grid cell.
Time, in milliseconds, to delay updates automatically so that multiple
calls to onSet/onNew/onDelete don't keep rerendering the grid. Set
to 0 to immediately cause updates. A higher value will result in
better performance at the expense of responsiveness of the grid.
View layout defintion.
EnhancedGrid features are implemented as plugins that could be loaded on demand.
Explicit dojo.require() is needed to use these feature plugins.
Plugin properties, e.g. {nestedSorting: true, dnd: true, ...}
Singleton plugin manager
Whether keep selection after sort, filter, pagination etc.
Default plugin manager class
LazyTreeGrid inherits from dojo.grid.TreeGrid, and applies virtual scrolling mechanism
to nested children rows so that it's possible to deal with large data set specifically
in tree structure with large number of children rows. It's also compatible with dijit.tree.ForestStoreModel
Most methods and properties pertaining to the dojox.grid.DataGrid
and dojox.grid.TreeGrid also apply here
LazyTreeGrid does not support summary row/items aggregate for the
lazy-loading reason.
a json object that defines column span of each level rows
attributes:
0/1/..: which level need to colspan
start: start column index of colspan
end: end column index of colspan
primary: index of column which content will be displayed (default is value of start).
size)
TreeGrid currently only works on "simple" structures. That is,
single-view structures with a single row in them.
The TreeGrid works using the concept of "levels" - level 0 are the
top-level items.
Whether or not we default to open (all levels). This defaults to
false for grids with a treeModel.
If true, child items will be returned sorted according to the sorting
properties of the grid.
Which levels we are open at (overrides defaultOpen for the values
that exist here). Its values can be a boolean (true/false) or an
integer (for the # of children to be closed if there are more than
that)
When used in conjunction with a treeModel (see above), this is a 0-based
index of the cell in which to place the actual expando
The dojox.Grid this editor should be attached to
object
Grid cell object
Grid row index
Boolean
True if grid is actively editing
Grid row index
Grid cell index
Boolean
True if given cell is being edited
Grid row index
Boolean
True if given row is being edited
Grid cell object
Grid row index
Grid row index
Grid view
Grid view
Grid row index
Default synthetic events dispatched for _Grid. dojo.connect to events to
retain default implementation or override them for custom handling.
onStyleRow({ selected: true, over:true, odd:false })
Object containing row state information: selected, true if the row is selcted; over:
true of the mouse is over the row; odd: true if the row is odd. Use customClasses and
customStyles to control row css classes and styles; both properties are strings.
Decorated event object contains reference to grid, cell, and rowIndex
Decorated event object that contains reference to grid, cell, and rowIndex
Decorated event object that contains reference to grid, cell, and rowIndex
Decorated event object contains reference to grid, cell, and rowIndex
Decorated event object contains reference to grid, cell, and rowIndex
Decorated event object that contains reference to grid, cell, and rowIndex
Decorated event object contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Cell object containing properties of the grid column.
Index of the grid row
Decorated event object which contains reference to grid, cell, and rowIndex
decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid, cell, and rowIndex
Cell object containing properties of the grid column.
Index of the grid row
Value from cell editor
Index of the grid row
Index in the grid's data store
Index of the grid row
Index of the grid row
Index of the grid row
Boolean
true if the row can be selected
Index of the grid row
Boolean
true if the row can be deselected
Index of the grid row
Index of the grid row
css class to apply to grid cells over which the cursor is placed.
grid cell object
grid row index
true of the given grid cell is focused
true if focus is on a column header; false otherwise.
index of the focused column header, or -1 if none have focus.
Boolean
true if headers are hidden
false if headers are not hidden
grid row index
grid cell index
grid cell object
grid row index
vertical distance from current focus
horizontal distance from current focus
Boolean
true if focus was set to a cell
false if no cell found to set focus onto
_Grid provides the full set of grid features without any
direct connection to a data store.
The grid exposes a get function for the grid, or optionally
individual columns, to populate cell contents.
The grid is rendered based on its structure, an object describing
column and cell layout.
Index of the row to render
Index of the starting row to render
How many rows to update.
Number of rows in the grid.
index of the row that has changed height
vertical position of the grid in pixels
grid row index
Grid column index of cell to retrieve
a grid cell
Sort information, 1-based index of column on which to sort, positive for an ascending sort
and negative for a descending sort
Boolean
True if grid can be sorted on the given column in the given direction
Column index on which to sort.
If true, sort the grid in ascending order, otherwise in descending order
CSS class applied to the grid's domNode
Number of rows to display.
Number of rows to keep in the rendering cache.
Number of rows to render at a time.
If autoWidth is true, grid width is automatically set to fit the data.
A css string to use to set our initial width (only used if autoWidth
is true). The first rendering of the grid will be this width, any
resizing of columns, etc will result in the grid switching to
autoWidth mode. Note, this width will override any styling in a
stylesheet or directly on the node.
If autoHeight is true, grid height is automatically set to fit the data.
If it is an integer, the height will be automatically set to fit the data
if there are fewer than that many rows - and the height will be set to show
that many rows if there are more
If rowHeight is set to a positive number, it will define the height of the rows
in pixels. This can provide a significant performance advantage, since it
eliminates the need to measure row sizes during rendering, which is one
the primary bottlenecks in the DataGrid's performance.
If autoRender is true, grid will render itself after initialization.
default height of the grid, measured in any valid css unit.
explicit height of the grid, measured in any valid css unit. This will be populated (and overridden)
if the height: css attribute exists on the source node.
View layout defintion.
Override defaults and make the indexed grid view elastic, thus filling available horizontal space.
Single-click starts editing. Default is double-click
Set the selection mode of grid's Selection. Value must be 'single', 'multiple',
or 'extended'. Default is 'extended'.
If set to true, will add a row selector view to this grid. If set to a CSS width, will add
a row selector of that width to this grid.
If set to true, will add drag and drop reordering to views with one row of columns.
If set to a dijit.Menu, will use this as a context menu for the grid headers.
Label of placeholders to search for in the header menu to replace with column toggling
menu items.
Set to true if you want to be able to select the text within the grid.
Message that shows while the grid is loading
Message that shows when the grid encounters an error loading
Message that shows if the grid has no data - wrap it in a
span with class 'dojoxGridNoData' if you want it to be
styled similar to the loading and error messages
This will escape HTML brackets from the data to prevent HTML from
user-inputted data being rendered with may contain JavaScript and result in
XSS attacks. This is true by default, and it is recommended that it remain
true. Setting this to false will allow data to be displayed in the grid without
filtering, and should be only used if it is known that the data won't contain
malicious scripts. If HTML is needed in grid cells, it is recommended that
you use the formatter function to generate the HTML (the output of
formatter functions is not filtered, even with escapeHTMLInData set to true).
An object to execute format functions within. If not set, the
format functions will execute within the scope of the cell that
has a format function.
indicates if the grid contains editable cells, default is false
set to true if editable cell encountered during rendering
The class to use for our layout - can be overridden by grid subclasses
flag modifies vertical scrolling behavior. Defaults to true but set to false for slower
scroll performance but more immediate scrolling feedback
pixel distance a user must scroll vertically to trigger grid scrolling.
The text to use in the header of the grid for this cell.
If "get" is not specified, this is used as the data for the cell.
defaultValue: String?
If "get" and "value" aren't specified or if "get" returns an undefined
value, this is used as the data for the cell. "formatter" is not run
on this if "get" returns an undefined value.
TODO
Whether this cell should be editable or not.
If true, the cell will not be displayed.
noresize: Boolean?
If true, the cell will not be able to be resized.
A CSS size. If it's an Integer, the width will be in em's.
How many columns to span this cell. Will not work in the first
sub-row of cells.
How many sub-rows to span this cell.
A string of styles to apply to both the header cell and main
grid cells. Must end in a ';'.
A string of styles to apply to just the header cell. Must end
in a ';'
A string of styles to apply to just the main grid cells. Must
end in a ';'
A space separated list of classes to apply to both the header
cell and the main grid cells.
A space separated list of classes to apply to just the header
cell.
A space separated list of classes to apply to just the main
grid cells.
A space separated string of attribute='value' pairs to add to
the header cell element and main grid cell elements.
If true, no scrollbars will be rendered without scrollbars.
A CSS size. If it's an Integer, the width will be in em's. If
"noscroll" is true, this value is ignored.
The structure of the cells within this grid.
A string containing the constructor of a subclass of
dojox.grid._View. If this is not specified, dojox.grid._View
is used.
A cell definition with default values for all cells in this view. If
a property is defined in a cell definition in the "cells" array and
this property, the cell definition's property will override this
property's property.
Default width of the view
Width for the view, in valid css unit
Width of the column being toggled (-1 for none)
The class to use for our header builder
The class to use for our content builder
Grid creates views automatically based on grid's layout structure.
Users should typically not need to access individual views or the views collection directly.
grid row index
html for a given grid cell
cell data to edit
grid row index
string of html to place in grid cell
grid row index
dom node for a given grid cell
node
dom node for the editor
cell data to edit
grid row index
grid row index
value of editor
grid row index
value of editor
grid row index
node
editor node
grid row index
grid row index
grid row index
grid row index
grid row index
optional regex for disallowing keypresses
text of each item
value for each item
editor returns only the index of the selected option and not the value
Methods are copied or replaced for overwriting, this might be refined once
an overall plugin architecture is set up for DataGrid.
Un-decorated event object
Decorated event object that contains reference to grid, cell, and rowIndex
Decorated event object that contains reference to grid, cell, and rowIndex
Decorated event object which contains reference to grid and info of selected
regions(selection type - row|column, selected index - [...])
Method map cached from dojox.grid._Events().
css class to apply to grid header cells when activated(mouse down)
css class to apply to grid content cells when activated(mouse down)
css class to apply to grid rows when activated(mouse down)
TODO - make the following events more reasonalble - e.g. more accurate conditions
events for row selectors
Name of this area.
step)
Called when this area logically gets focus.
event: Event object
May be unavailable, should check before use.
step: Integer
The distance in the tab sequence from last focused area to this area.
step)
Called when this area logically loses focus.
event: Event object
May be unavailable, should check before use.
step: Integer
The distance in the tab sequence from this area to the area to focus.
colStep, event)
Called when focus is moving around within this area.
rowStep: Integer
colStep: Integer
event: Event object
May be unavailable, should check before use.
isBubble)
Called when some key is pressed when focus is logically in this area.
event: Event object
isBubble: Boolean
Whether is in bubble stage (true) or catch stage (false).
Define the small regions (dom nodes) in this area.
Connected to the onfocus event of the defined regions (if any)
Connected to the onblur event of the defined regions (if any)
placeArea("myarea","before"|"after",...)
placeArea("myarea","below"|"above",...)
Provides common plugin functionality and basic life cycle management.
Each concrete plugin must have a name field and is responsible for registering itself to the global plugin registry
e.g. for dnd plugin:
dojox.grid.EnhancedGrid.registerPlugin("dnd" /*plugin name*/,
dojox.grid.enhanced.plugins.DnD /*full class name of a plugin
{"preInit": false, "dependency": ["nestedSorting"]} /*properties*/);
[Keywords] of plugin properties(case sensitive)
- "preInit": boolean, whether a plugin should be created before EnhancedGrid.postCreate(),
false by default(plugins are created after EnhancedGrid.postCreate()).
- "dependency": array or string, plugin(s) indicated by "dependency" will be created before the current one.
Note: recursive cycle dependencies are not supported e.g. following dependency is invalid:
pluginA -> pluginB -> pluginA
var plugin = new dojox.grid.enhanced._Plugin(grid,"myPlugin",{...});
// when foo.bar() is called, call the listener in the scope of plugin
plugin.connect(foo, "bar", function(){
console.debug(this.xxx());//"this" - plugin scope
});
var plugin = new dojox.grid.enhanced._Plugin(grid,"myPlugin",{...});
// when /my/topic is published, call the subscriber in the scope of plugin
// with passed parameter - "v"
plugin.subscribe("/my/topic", function(v){
console.debug(this.xxx(v));//"this" - plugin scope
});
Plugin name, e.g. 'nestedSorting', 'dnd'...
Grid that the plugin belongs to
Plugin properties - leveraged with default and user specified properties.
e.g. for dnd plugin, it may look like {"class": dojox.grid.enhanced.plugins.DnD, "dependency": ["nestedSorting"], ...}
List of all connections.
List of all subscribes.
Private properties/methods shouldn't be mixin-ed anytime.
Plugin manager is responsible for
1. Loading required plugins
2. Handling collaboration and dependencies among plugins
Some plugin dependencies:
- "columnReordering" attribute won't work when either DnD or Indirect Selections plugin is on.
Plugin properties defined by user
Plugin name
Plugin properties set by user
The global plugin registry
Map for checking process state
True - preInit | False - postInit(by default)
Plugin name
return: Object
The newly loaded plugin
Plugin name
return: Boolean
True - existed | False - not existed
Plugin name
return: Object
Plugin instance
| String
Plugin class
Target cell(column)
return: Boolean
True - fixed| False - not fixed
Full class name, e.g. "dojox.grid.enhanced.plugins.DnD"
- Optional
Plugin properties e.g. {"dependency": ["nestedSorting"], ...}
Connection list
The store to be wrapped.
The layer to be used
returns
The wrapped store, for nested use only.
Plugin name
The time interval (in miliseconds) between 2 scrolling.
The width (in pixel) of the margin area where autoscroll can be triggered.
If it's a function, it's a predicate to decide which rows are to be merged.
It takes an integer (the row index), and should return true or false;
The column index of the left most cell that shall be merged.
The column index of the right most cell that shall be merged.
The column index of the cell whose content should be used as the content of the merged cell.
It must be larger than or equal to the startColumnIndex, and less than or equal to the endColumnIndex.
If it is omitted, the content of the leading edge (left-most for ltr, right most for rtl) cell will be used.
return: Object | null
A handler for the merged cells created by a call of this function.
This handler can be used later to unmerge cells using the function unmergeCells
If the merge is not valid, returns null;
A handler for the merged cells created by a call of function mergeCells.
Plugin name
----------------Public----------------------------
An object with the following structure:
{
name: "some-string",
onLoad: /* void */ function(/* object */partOfCookie, /* EDG */grid){...},
onSave: /* object */ function(/* EDG */grid){...}
}
Name of a cookie handler if provided, otherwise for all cookies.
Name of a cookie handler if provided, otherwise for all cookies.
Plugin name
The following code disables row DnD within grid,
but still can drag rows out of grid or drag rows from other gird.
setUpConfig({
"row": {
"within": false
}
});
The opposite way is also okay:
setUpConfig({
"within": {
"row": false
}
});
And if you'd like to disable/enable a whole set, here's a shortcut:
setUpConfig({
"cell", true,
"out": false
});
Because mode has higher priority than type, the following will disable row dnd within grid:
setUpConfig({
"within", {
"row": false;
},
"row", {
"within": true
}
});
DnD configuration object.
See the examples below.
plugin name;
The grid to plug in to.
A registered export format name
includes:
{
fetchArgs: object?
Any arguments for store.fetch
writerArgs: object?
Arguments for the given format writer
}
Call back function when export result is ready
A registered export format name
Arguments for the given format writer
string
The exported string
undefined
Plugin name.
item
plugin name
you'd like to insert some sort of nodes into your dnd source, turn this on,
and override getCellContent/getRowContent/getColumnContent
to populate the dnd data in your desired format.
For better rendering performance, div(images) are used to simulate radio button|check boxes
Plugin name
Row index
True - checked | False - unchecked
True - disabled | False - enabled
Key up event
Target row
Row index
Column index
Index of destroyed page
Input type - Radio|CheckBox
Cache div refs of radio|checkbox to avoid querying each time
Cache index of disabled rows
Marker of indirectSelection cell(column)
List of all connections.
List of all subscribes.
Checked character for high contrast mode
Unchecked character for high contrast mode
Event fired on the target row
True - select all, False - deselect all
Decorated event object which contains reference to grid, cell, and rowIndex
Mouse up event
Key up event
Index of the start row
Event of the current row,
Row index delta, used for swipe selection via Shift + Arrow key
0: not via key, -1 : Shift + Up, 1 : Shift + Down
Row offset, used for swipe selection via Shift + Cursor
-1 : Shift + Up, 1 : Shift + Down
Event of the current row,
Event fired on the target row
Start row index for swipe selection
Max row index for swipe selection
new state for selection
Row index for last click, used for range selection via Shift + click
Whether toggle all has been triggered or not
| Widget(dijit.Menu)
menu types
A flexible way to control multiple column sorting, including
1. Set default sorting order
2. Disable sorting for certain columns
3. Set sorting order dynamically with JS API
Plugin name
'none'|'asc'|'desc'
page to go to, starting at 1.
Show the go to page button when flag is true, otherwise hide it
The row index
Arguments for print.
Arguments for print.
Arguments for print.
call back function
Arguments for print.
String The html content string to be printed.
undefined
String A title for the html page.
css file pathes.
String Content to print, not including <head></head> part and <html> tags
the wrapped HTML string ready for print
Plugin name
Array of column indexes.
The target position
Array of row indexes.
The target position
plugin name
item)
item)
item
plugin name
Row index of this cell
Column index of this cell
Row index of this row
An array of column indexes of all the unselected cells in this row.
Column index of this column
An array of row indexes of all the unselected cells in this column.
An object with the following structure (all properties are optional):
{
//Default is "multi", all other values are same as "multi".
row: false|"disabled"|"single",
col: false|"disabled"|"single",
cell: false|"disabled"|"single"
}
"row" or "col" or "cell"
If type is "row" or "cell", this is the row index.
If type if "col", this is the column index.
Only valid when type is "cell"
return: Boolean
true if selected, false if not. If cell is covered by a selected column, it's selected.
"row" or "col" or "cell"
If type is "row" or "cell", this is the row index.
If type if "col", this is the column index.
Only valid when type is "cell"
"row" or "col" or "cell"
| Object
If type is "row" or "col", this is the index of the starting row or column.
If type if "cell", this is the left-top cell of the range.
| Object
If type is "row" or "col", this is the index of the ending row or column.
If type if "cell", this is the right-bottom cell of the range.
"row" or "col" or "cell". If omitted, clear all.
"row" or "col" or "cell"
return: Boolean
true if is selection, false otherwise.
To enable or not. Optional.
return: Boolean | undefined
Enabled or not.
"row" or "col" or "cell"
Only meaningful for rows/columns. If true, all selected rows/cols, even they are partly selected, are all returned.
return: __SelectItem[]
"row" or "col" or "cell"
Only meaningful for rows/columns. If true, all selected rows/cols, even they are partly selected, are all returned.
return: Integer
The number of selected items.
"row", "col", or "cell
The item to retain highlight.
"row", "col", or "cell"
The start point
Whether this is a multi selection
Whether this is a range selection (i.e. select from the last end point to this point)
If true, toSelect will be same as the original selection status.
"row", "col", or "cell"
Whether we are selecting or deselecting.
This function is time critical!!
plugin name
// _config: null,
// _enabled: true,
// _selecting: {
// row: false,
// col: false,
// cell: false
// },
// _selected: {
// row: [],
// col: [],
// cell: []
// },
// _startPoint: {},
// _currentPoint: {},
// _lastAnchorPoint: {},
// _lastEndPoint: {},
// _lastSelectedAnchorPoint: {},
// _lastSelectedEndPoint: {},
// _keyboardSelect: {
// row: 0,
// col: 0,
// cell: 0
// },
// _curType: null,
// _lastType: null,
// _usingKeyboard: false,
// _toSelect: true,
keys are original rowIndexes, values are new rowIndexes.
When this feature turned on, Grid will try to preserve selections across various user actions, e.g. sorting, filtering etc.
Precondition - Identifier(id) is required for store, as id is used for differentiating row items.
Known issue - The preserved selections might be inaccurate if some unloaded rows are selected by range previously(e.g.SHIFT + click)
List of all connections.
The store to be wrapped.
Boolean If given, is a setter, otherwise, it's getter.
The name of this layer.
The wrapped store.
The original fetch function of the store.
To control whether this layer is valid.
Boolean If provided, it's a setter, otherwise, it's a getter
The name of the command
anything The content of the command
The content of the command if cmdContent is undefined
server response
in|out] dojo.data.api.Request
The request object for *fetch*. You can modify this object according to the *response*
so as to change the behavior of *fetch*
The url of the server
__cmds [private] object
The command object to be sent to server.
{separator:'...'}
The value in a cell.
The formatted content of a cell
An html tag name
The well formatted attributes for the given html table.tag
Any implementation of this class might accept a writerArgs object (optional),
which contains some writer-specific arguments given by the user.
undefined
All the items fetched from the store
return:
true: go on handling the contents and then call afterContent.
false: skip all the contents, won't call afterContent.
undefined
An object with at least the following context properties available:
{
grid,isHeader,
row,rowIdx,
spCols
}
return:
true: go on handling the current data row and then call afterContentRow.
false: skip the current data row, won't call afterContentRow.
An object with at least the following context properties available:
{
grid,isHeader,
row,rowIdx,
spCols
}
undefined
An object with at least the following context properties available:
{
grid,isHeader,
view,viewIdx,
spCols(if isHeader==false)
}
return:
true: go on handling the current view and then call afterView.
false: skip the current view, won't call afterView.
An object with at least the following context properties available:
{
grid,isHeader,
view,viewIdx,
spCols(if isHeader==false)
}
undefined
An object with at least the following context properties available:
{
grid,isHeader,
row,rowIdx,
view,viewIdx,
subrow,subrowIdx,
spCols(if isHeader==false)
}
return:
true: go on handling the current subrow and then call afterSubrow.
false: skip the current subrow, won't call afterSubrow.
An object with at least the following context properties available:
{
grid,isHeader,
row,rowIdx,
view,viewIdx,
subrow,subrowIdx,
spCols(if isHeader==false)
}
undefined
An object with at least the following context properties available:
{
grid,isHeader,
row,rowIdx,
view,viewIdx,
subrow,subrowIdx,
cell,cellIdx,
spCols(if isHeader==false)
}
undefined
The exported result string.
The grid object we are now handling.
Indicating which context we're handling, header or content.
Reference to the current _View object.
The index of the current _View object in the views array.
If the grid does not have any rowselector view, it conforms to the index
in the _ViewManager.views.
Reference to the current subrow.
A subrow describe the innter structure of a row in a view, it's an array of cells
The index of the current subrow in the subrow array: _View.structure.cells.
Reference to the current cell.
The index of the current cell in the current subrow.
It's different from cell.index, which is the index in the whole line.
The current row of data (logically), a.k.a.: current item.
The index of the current row (item).
An array of special column indexes(flat,not regarding structure).
Special columns are typically attached to grid as a kind of UI facility
by the grid widget, instead of some real data.
For example, indirect selectors and row indexers.
Users can choose to export it or not.
If the grid has a _RowSelector view or something else, this view will NOT be
passed to the user in argObj. So the column index (cell.index) will appear shifted
(start from 1 instead of 0). This colOffset is provided to remove this shift.
usage:
var correctColIndex = argObj.cell.index + argObj.colOffset;
visible criteria box
constructor
constructor
null: clear filter definition
undefined: it's getter
A filter definition if it's getter.
The number of remaining fetched items after filtering.
The number of original fetched items.
The filter definition
function(datarow, colArg, rowIndex, store);
boolean If provided, it's a set function, otherwise it's a get function.
Whether fetch all on first filter if this is a getter
The actual request used in store.fetch.
This function is called recursively to fill the result store items
until the user specified item count is reached. Only in recursive calls,
this parameter is valid.
item
whether this row survived the filter.
object
object
Data items to add.
The start point to insert in the cache.
Current fetch result
The index in cache of the first result item
A map from the row index of this._items to the row index of the original store.
colArg, rowIndex, store);
A user defined way to get data from store
The index of the next item in the store that is never fetched.
The actual size of the original store
object A data item of a store.
function(datarow, colArg)
A user defined function that extract cell data from *datarow*.
*colArg* is an argument that provides a kind of column information.
It is defined by user in the constructor of a _DataExpr object.
MUST return a _ConditionExpr object
An object for serialization.
the name of this kind of expression
If *isColumn* is a boolean true, then it should be a kind of column information, like field name
or column index. Otherwise, it is regarded as a pure value, and the getValue method will simply
return it.
boolean Optional. To specify whether this _DataExpr represents a column or a pure value.
the value of this data expression.
item
item
object
MUST return a _ConditionExpr object.
item
object
MUST return a _ConditionExpr object.
item
item
item
item
item
item
item
item
item
item
item
item
item
item
item
item
Search for locally available data; variable names and any cached
documentation results for matches containing our search parameter
searchFor
The string to search for.
The namespaces to search in. Defaults to dojox.help._namespaces
The maximum number of results.
The string-representation of a namespace.
Whether to recurse through the namespace.
If you pass an item, only that item will be cleaned
Any namespaces to add to the default (dojox.help._namespaces)
Whether to start in noConflict mode
This project parses pre > code nodes, and applies syntax highlighting for
a wide variety of languages. Simply dojo.require() in all the
dojox.highlight.languages you wish to include in your highlighingting,
and customize colors in the highlight.css.
It is provided as a dojo package, contributed under CLA
by Ivan Sagalaev and is available originally from:
http://softwaremaniacs.org/soft/highlight/en/
Object containing:
result - string of html with spans to apply formatting
partialResult - if the formating failed: string of html
up to the point of the failure, otherwise: undefined
langName - the language used to do the formatting
Syntax highlight a passed DomNode or String ID of a DomNode
dojox.highlight.init("someId");
A String ID or DomNode reference to use as the root node of this instance.
Say we fetch a HTML page from level1/page.html
It has some inline CSS:
@import "css/page.css" tv, screen;
...
background-image: url(images/aplhaimage.png);
as we fetched this HTML and therefore this CSS
from level1/page.html, these paths needs to be adjusted to:
@import 'level1/css/page.css' tv, screen;
...
background-image: url(level1/images/alphaimage.png);
In IE it will also adjust relative paths in AlphaImageLoader()
filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='images/alphaimage.png');
will be adjusted to:
filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='level1/images/alphaimage.png');
Please note that any relative paths in AlphaImageLoader in external css files wont work, as
the paths in AlphaImageLoader is MUST be declared relative to the HTML page,
not relative to the CSS file that declares it
A safe string/node/nodelist content replacement/injection with hooks for extension
Example Usage:
dojo.html.set(node, "some string");
dojo.html.set(node, contentNode, {options});
dojo.html.set(node, myNode.childNodes, {options});
the parent element that will receive the content
the content to be set on the parent element.
This can be an html string, a node reference or a NodeList, dojo.NodeList, Array or other enumerable list of nodes
Optional flags/properties to configure the content-setting. See dojo.html._ContentSetter
A fully qualified class name, as it would appear in
a CSS dojo.doc. Start classes with periods, target
nodes with '#'. Large selectors can also be created
like:
"#myDiv.myClass span input"
A single string that would make up a style block, not
including the curly braces. Include semi-colons between
statements. Do not use JavaScript style declarations
in camel case, use as you would in a CSS dojo.doc:
"color:#ffoooo;font-size:12px;margin-left:5px;"
optional )
Name of the dynamic style sheet this rule should be
inserted into. If is not found by that name, it is
created. If no name is passed, the name "default" is
used.
Only removes DYNAMICALLY created cssRules. If you
created it with dojox.html.insertCssRule, it can be removed.
If passed a title, enables a that style sheet. All other
toggle-able style sheets are disabled.
If no argument is passed, returns currently enabled
style sheet.
An array of all toggle-able style sheets
TODO: Sets of style sheets could be grouped according to
an ID and used in sets, much like different
groups of radio buttons. It would not however be
according to W3C spec
An hash map of all the style sheets.
TODO: Does not recursively search for @imports, so it will
only go one level deep.
Adjust relative paths in html string content to point to this page
Only useful if you grab content from a another folder than the current one
The string to process for possible entity encoding.
An optional list of character to entity name mappings (array of
arrays). If not provided, it uses the and Latin entities as the
set to map and escape.
The string to process for possible entity encoding to decode.
An optional list of character to entity name mappings (array of
arrays). If not provided, it uses the HTML and Latin entities as the
set to map and decode.
The string of HTML to try and generate a 'pretty' formatting.
Optional input for the number of spaces to use when indenting.
If not defined, zero, negative, or greater than 10, will just use tab
as the indent.
Optional input for the number of characters a text line should use in
the document, including the indent if possible.
Optional array of entity mapping characters to use when processing the
HTML Text content. By default it uses the default set used by the
dojox.html.entities.encode function.
Optional parameter that declares that the returned HTML should try to be 'xhtml' compatible.
This means normally unclosed tags are terminated with /> instead of >. Example: <hr> -> <hr />
Load two images into cache:
dojox.image.preload(["foo.png", "bar.gif"]);
Using djConfig:
var djConfig = {
preloadImages:["bar.png", "baz.png", "http://example.com/icon.gif"]
};
The list of urls to load. Can be any valid .src attribute.
Array
An Array of DomNodes that have been cached.
A CSS3 Selector that determines the node to become a child
Number of Rows to display
Number of Columns to display
Size in PX of each thumbnail
Size in PX to adjust for cell margins
Time (in ms) to show the image before sizing down again
how many cycles will be going "simultaneously" (>2 not reccommended)
An easing function to use when showing the node (does not apply to shrinking)
If you know your Flickr userid, you can set it to prevent a call to fetch the id
Your Flickr username
The id of the set to display
Free text search. Photos who's title, description, or tags contain the text will be displayed
Where to display the pictures when clicked on. Valid values are the same as the target attribute
of the A tag.
implementation of the dojo.data.api.Read API. This accesses the image
data.
implementation of the dojo.data.api.Request API. This specifies the
query and paging information to be used by the data store
An object defining the names of the item attributes to fetch from the
data store. The four attributes allowed are 'linkAttr', 'imageLargeAttr',
'imageThumbAttr' and 'titleAttr'
If true, a slideshow is active, otherwise the slideshow is inactive.
Function Optional callback function to call when the image has finished displaying.
Maximum height of an image in the SlideShow widget
Maximum width of an image in the SlideShow widget
The number of records to retrieve from the data store per request.
If true, images are loaded before the user views them. If false, an
image is loaded when the user displays it.
Defines the name of the attribute to request from the store to retrieve the
URL to link to from an image, if any.
Defines the name of the attribute to request from the store to retrieve the
URL to the thumbnail image.
Defines the name of the attribute to request from the store to retrieve the
URL to the image.
Defines the name of the attribute to request from the store to retrieve the
title of the picture, if any.
Time, in seconds, between image changes in the slide show.
An Elegant, keyboard accessible, markup and store capable Lightbox widget to show images
in a modal dialog-esque format. Can show individual images as Modal dialog, or can group
images with multiple entry points, all using a single "master" Dialog for visualization
key controls:
ESC - close
Down Arrow / Rt Arrow / N - Next Image
Up Arrow / Lf Arrow / P - Previous Image
Grouping images in a page with similar tags will provide a 'slideshow' like grouping of images
A string of text to be shown in the Lightbox beneath the image (empty if using a store)
Generic time in MS to adjust the feel of widget. could possibly add various
durations for the various actions (dialog fadein, sizeing, img fadein ...)
If true, this Dialog instance will be truly modal and prevent closing until
explicitly told to by calling hide() or clicking the (x) - Defaults to false
to preserve previous behaviors. (aka: enable click-to-click on the underlay)
Privately set this to disable/enable natural link of anchor tags
A widget that intercepts anchor links (typically around images)
and displays a modal Dialog. this is the actual Dialog, which you can
create and populate manually, though should use simple Lightbox's
unless you need the direct access.
There should only be one of these on a page, so all dojox.image.Lightbox's will us it
(the first instance of a Lightbox to be show()'n will create me If i do not exist)
dijit._Widget
Perhaps the only `dijit._Widget` that returns itself to allow
'chaining' or var referencing with .startup()
needs href and title attributes. the values for this image.
The 'size' object passed around for this image
The image information to add.
href: String - link to image (required)
title: String - title to display
attach to group of similar tag or null for individual image instance
Object A reference to the Lightbox child that was added (or an object literal)
only the .href member is compared for uniqueness. The object may contain
a .group member as well.
The current title, read from object passed to show()
Array of objects. this is populated by from the JSON object _groups, and
should not be populate manually. it is a placeholder for the currently
showing group of images in this master dialog
The src="" attribute of our imageNode (can be null at statup)
The text to display when an unreachable image is linked
If true, ensure the image always stays within the viewport
more difficult than necessary to disable, but enabled by default
seems sane in most use cases.
If true, this Dialog instance will be truly modal and prevent closing until
explicitly told to by calling hide() or clicking the (x) - Defaults to false
to preserve previous behaviors. (aka: enable click-to-click on the underlay)
Path to the image used when a 404 is encountered
Very lightweight lightbox which only displays a larger image. There is
no support for a caption or description. The lightbox can be closed by
clicking any where or pressing any key. This widget is intended to be
used on <a> and <img> tags. Upon creation, if the domNode is <img> tag,
then it is wrapped in an <a> tag, then a <div class="enlarge"> is placed
inside the <a> and can be styled to display an icon that the original
can be enlarged.
An object with optional members of <code>href</code> and <code>origin</code>.
<code>origin</code> can be be a String|Id of a DomNode to use when
animating the openeing of the image (the 'box' effect starts
from this origin point. eg: { origin: e.target })
If there's no origin, it will use the center of the viewport.
The <code>href</code> member is a string URL for the image to be
displayed. Omiting either of these members will revert to
the default href (which could be absent in some cases) and
the original srcNodeRef for the widget.
URL to the large image to show in the lightbox.
The delay in milliseconds of the LightboxNano open and close animation.
The delay in milliseconds after the LightboxNano is created before preloading the larger image.
An unobtrusive way to add an unstyled overlay
above the srcNode image element. The overlay/glass is a
scaled version of the src image (so larger images sized down
are clearer).
over-ride the _createGlass method to create your custom surface,
being sure to create an img node on that surface.
An unobtrusive way to add an unstyled overlay
above the srcNode image element. The overlay/glass is a
scaled version of the src image (so larger images sized down
are clearer).
The logic behind requiring the src image to be large is
"it's going to be downloaded, anyway" so this method avoids
having to make thumbnails and 2 http requests among other things.
the width and height of the bounding box
the multiplier of the Mangification.
implementation of the dojo.data.api.Read API. This accesses the image
data.
implementation of the dojo.data.api.Request API. This specifies the
query and paging information to be used by the data store
An object defining the names of the item attributes to fetch from the
data store. The three attributes allowed are 'linkAttr', 'imageLargeAttr' and 'titleAttr'
Removes all previously loaded images, and clears all caches.
number index in the data store to check if it is loaded.
number index in the data store to start loading images from.
If true, a slideshow is active, otherwise the slideshow is inactive.
The information published is: index, title and url
The information published is the index position of the image loaded.
The position of the image in the data store to display
Optional callback function to call when the image has finished displaying.
If true, the widget is always resized, regardless of the value of 'fixedHeight'
This function loads the image at position 'index' into the
internal cache of images. This does not cause the image to be displayed.
position in the data store to load an image from.
optional function to execute when the image has finished loading.
The String title of the image
The image DOM node to optionally resize
An Event object
If true, the navigation controls are repositioned even if they are
currently visible.
The DOM Event that triggered this function
The maximum height of an image
The maximum width of an image.
The initial title of the SlideShow
a way to customize the wording in the title. supported parameters to be populated are:
${title} = the passed title of the image
${current} = the current index of the image
${total} = the total number of images in the SlideShow
should add more?
Prevents the slideshow from putting an anchor link around the displayed image
enables if true, though still will not link in absence of a url to link to
true/false - make the slideshow loop
toggle to enable/disable the visual navigation controls
Contains the DOM nodes that individual images are stored in when loaded or loading.
The number of images to request each time.
If true, then images are preloaded, before the user navigates to view them.
If false, an image is not loaded until the user views it.
If true, the SlideShow begins playing immediately
If true, the widget does not resize itself to fix the displayed image.
Implementation of the dojo.data.api.Read API, which provides data on the images
to be displayed.
Defines the name of the attribute to request from the store to retrieve the
URL to link to from an image, if any.
Defines the name of the attribute to request from the store to retrieve the
URL to the image.
Defines the name of the attribute to request from the store to retrieve the
title of the picture, if any.
Time, in seconds, between image transitions during a slideshow.
A counter to keep track of which index image is to be loaded next
The temporary image to show when a picture is loading.
implementation of the dojo.data.api.Read API. This accesses the image
data.
implementation of the dojo.data.api.Request API. This specifies the
query and paging information to be used by the data store
An object defining the names of the item attributes to fetch from the
data store. The four attributes allowed are 'linkAttr', 'imageLargeAttr',
'imageThumbAttr' and 'titleAttr'
The index of the first thumbnail
If 'useLoadNotifier' is set to true, then a visual cue is
given to state whether the image is loaded or not. Calling this function
marks an image as loaded.
The thumbnail DOM node to set the class on
The CSS class to add to the DOM node.
A data store that implements the dojo.data Read API.
Width or height in pixels, depending if horizontal or vertical.
FIXME: use CSS?
Default height of a thumbnail image
FIXME: use CSS?
Default width of an image
FIXME: use CSS?
Setting useLoadNotifier to true makes a colored DIV appear under each
thumbnail image, which is used to display the loading status of each
image in the data store.
Setting useHyperlink to true causes a click on a thumbnail to open a link.
If hyperlinkTarget is set to "new", clicking on a thumb will open a new window
If it is set to anything else, clicking a thumbnail will open the url in the
current window.
When set to true, the cursor over a thumbnail changes.
When true, uses smoothScroll to move between pages
If true, the thumbnails are displayed horizontally. Otherwise they are displayed
vertically
The attribute name for accessing the url from the data store
The attribute name for accessing the thumbnail image url from the data store
The attribute name for accessing the large image url from the data store
The number of images to request each time.
The attribute name for accessing the title from the data store
The index of the first thumbnail shown
The total number of photos in the image store
Stores the indices of images that have been marked as loaded using the
markImageLoaded function.
HTTP stream to parse
Extra header information to add to each HTTP request (kind of HTTP inheritance)
A true value indicates that the stream may not be finished, it may end arbitrarily in mid stream.
The last XHR object will have a special property _lastIndex that indicates the how far along
the httpStream could be successfully parsed into HTTP messages.
return:
Returns an array of XHR-like object for reading the headers for each message
Url prefix of the site which can handle JSONP requests.
This allows for adapting HTTP requests that could not otherwise be
sent with JSONP, so you can use a convention for headers and PUT/DELETE methods.
Url prefix of the site which can handle windowName requests.
This allows for adapting HTTP requests that could not otherwise be
sent with window.name, so you can use a convention for headers and PUT/DELETE methods.
The key or token issued to either the consumer or by the OAuth service.
The secret (shared secret for consumers, issued secret by OAuth service).
The consumer information issued to your OpenAuth application.
sig_method: String
The method used to create the signature. Should be PLAINTEXT or HMAC-SHA1.
The request token and secret issued by the OAuth service. If not
issued yet, this should be null.
Do not use this object directly. See the Dojo Book page
on XMLHttpRequest IFrame Proxying:
http://dojotoolkit.org/book/dojo-book-0-4/part-5-connecting-pieces/i-o/cross-domain-xmlhttprequest-using-iframe-proxy
Usage of XHR IFrame Proxying does not work from local disk in Safari.
Do not use this object directly. See the Dojo Book page
on XMLHttpRequest IFrame Proxying:
http://dojotoolkit.org/book/dojo-book-0-4/part-5-connecting-pieces/i-o/cross-domain-xmlhttprequest-using-iframe-proxy
In order to provide a windowname transport accessible resources/web services, a server
should check for the presence of a parameter window.name=true and if a request includes
such a parameter, it should respond to the request with an HTML
document that sets it's window.name to the string that is to be
delivered to the client. For example, if a client makes a window.name request like:
http://othersite.com/greeting?windowname=true
And server wants to respond to the client with "Hello", it should return an html page:
<html><script type="text/javascript">
window.name="Hello";
</script></html>
One can provide XML or JSON data by simply quoting the data as a string, and parsing the data
on the client.
If you use the authorization window.name protocol, the requester should include an
authElement element in the args, and a request will be created like:
http://othersite.com/greeting?windowname=auth
And the server can respond like this:
<html><script type="text/javascript">
var loc = window.name;
authorizationButton.onclick = function(){
window.name="Hello";
location = loc;
};
</script></html>
When using windowName from a XD Dojo build, make sure to set the
dojo.dojoBlankHtmlUrl property to a local URL.
The method to use to send the request, GET or POST
See dojo.xhr
args.authElement: DOMNode?
By providing an authElement, this indicates that windowName should use the
authorized window.name protocol, relying on
the loaded XD resource to return to the provided return URL on completion
of authorization/authentication. The provided authElement will be used to place
the iframe in, so the user can interact with the server resource for authentication
and/or authorization to access the resource.
args.onAuthLoad: Function?
When using authorized access to resources, this function will be called when the
authorization page has been loaded. (When authorization is actually completed,
the deferred callback function is called with the result). The primary use for this
is to make the authElement visible to the user once the resource has loaded
(this can be preferable to showing the iframe while the resource is loading
since it may not require authorization, it may simply return the resource).
Name of the form value.
The contents of the value.
An optional filename to pass to the server, as defined by the boundary.
An optional content-type (MIME) to pass to the server, if value is being
treated as a file.
Optional charset to pass, for the server to interpret the file correctly.
Optional transfer encoding header value.
URL to server endpoint.
Contains properties with string values. These
properties will be serialized using multi-part
boundaries.
Alias for "content". Provided for backwards compatibility.
Milliseconds to wait for the response. If this time
passes, the then error callbacks are called.
DOM node for a form. Used to extract the form values
and send to the server; each form value will be serialized
using multi-part boundaries.
Default is false. If true, then a
"dojo.preventCache" parameter is sent in the request
with a value that changes with each request
(timestamp). Useful only with GET-type requests.
Acceptable values depend on the type of IO
transport (see specific IO calls for more information).
Define a proxy:
dojox.io.xhrPlugins.addProxy("/proxy?url=");
And then when you call:
dojo.xhr("GET",{url:"http://othersite.com/file"});
It would result in the request (to your origin server):
GET /proxy?url=http%3A%2F%2Fothersite.com%2Ffile HTTP/1.1
is URL to send the requests to.
This can be used for servers that support W3C cross-site XHR. In order for
a server to allow a client to make cross-site XHR requests,
it should respond with the header like:
Access-Control: allow <*>
see: http://www.w3.org/TR/access-control/
that start with this URL will be considered for using
cross-site XHR.
allows for adapting HTTP requests that could not otherwise be
sent with XDR, so you can use a convention for headers and PUT/DELETE methods.
The following convention is used:
method name -> ?http-method=PUT
Header -> http-Header-Name=header-value
X-Header -> header_name=header-value
dojox.io.xhrPlugins.addXdr("http://somesite.com", dojox.io.xhrPlugins.fullHttpAdapter);
JSONQuery provides a comprehensive set of data querying tools including filtering,
recursive search, sorting, mapping, range selection, and powerful expressions with
wildcard string comparisons and various operators. JSONQuery generally supersets
JSONPath and provides syntax that matches and behaves like JavaScript where
possible.
JSONQuery evaluations begin with the provided object, which can referenced with
$. From
the starting object, various operators can be successively applied, each operating
on the result of the last operation.
Supported Operators:
--------------------
* .property - This will return the provided property of the object, behaving exactly
like JavaScript.
* [expression] - This returns the property name/index defined by the evaluation of
the provided expression, behaving exactly like JavaScript.
* [?expression] - This will perform a filter operation on an array, returning all the
items in an array that match the provided expression. This operator does not
need to be in brackets, you can simply use ?expression, but since it does not
have any containment, no operators can be used afterwards when used
without brackets.
* [^?expression] - This will perform a distinct filter operation on an array. This behaves
as [?expression] except that it will remove any duplicate values/objects from the
result set.
* [/expression], [\expression], [/expression, /expression] - This performs a sort
operation on an array, with sort based on the provide expression. Multiple comma delimited sort
expressions can be provided for multiple sort orders (first being highest priority). /
indicates ascending order and \ indicates descending order
* [=expression] - This performs a map operation on an array, creating a new array
with each item being the evaluation of the expression for each item in the source array.
* [start:end:step] - This performs an array slice/range operation, returning the elements
from the optional start index to the optional end index, stepping by the optional step number.
* [expr,expr] - This a union operator, returning an array of all the property/index values from
the evaluation of the comma delimited expressions.
* .* or [*] - This returns the values of all the properties of the current object.
* $ - This is the root object, If a JSONQuery expression does not being with a $,
it will be auto-inserted at the beginning.
* @ - This is the current object in filter, sort, and map expressions. This is generally
not necessary, names are auto-converted to property references of the current object
in expressions.
* ..property - Performs a recursive search for the given property name, returning
an array of all values with such a property name in the current object and any subobjects
* expr = expr - Performs a comparison (like JS's ==). When comparing to
a string, the comparison string may contain wildcards * (matches any number of
characters) and ? (matches any single character).
* expr ~ expr - Performs a string comparison with case insensitivity.
* ..[?expression] - This will perform a deep search filter operation on all the objects and
subobjects of the current data. Rather than only searching an array, this will search
property values, arrays, and their children.
* $1,$2,$3, etc. - These are references to extra parameters passed to the query
function or the evaluator function.
* +, -, /, *, &, |, %, (, ), <, >, <=, >=, != - These operators behave just as they do
in JavaScript.
dojox.json.query(queryString,object)
and
dojox.json.query(queryString)(object)
always return identical results. The first one immediately evaluates, the second one returns a
function that then evaluates the object.
dojox.json.query("foo",{foo:"bar"})
This will return "bar".
evaluator = dojox.json.query("?foo='bar'&rating>3");
This creates a function that finds all the objects in an array with a property
foo that is equals to "bar" and with a rating property with a value greater
than 3.
evaluator([{foo:"bar",rating:4},{foo:"baz",rating:2}])
This returns:
{foo:"bar",rating:4}
evaluator = dojox.json.query("$[?price<15.00][\rating][0:10]");
This finds objects in array with a price less than 15.00 and sorts then
by rating, highest rated first, and returns the first ten items in from this
filtered and sorted list.
Query string
Target of the JSONQuery
A JSON Schema object that can be used to advise the handling of the JSON (defining ids, date properties, urls, etc)
The validate method will return an object with two properties:
valid: A boolean indicating if the instance is valid by the schema
errors: An array of validation errors. If there are no errors, then an
empty list will be returned. A validation error will have two properties:
property: which indicates which property had the error
message: which indicates what the error was
The instance value/object to validate
The schema to use to validate
The new instance value/object to check
The schema to use to validate
return:
see dojox.validate.jsonSchema.validate
result returned from checkPropertyChange or validate
An instance to be matched. If null, any context will be examined.
Otherwise the context should belong to this instance.
An optional pattern to be matched against a method name. Can be a string,
a RegExp object or an array of strings and RegExp objects.
If it is omitted, any name will satisfy the criteria.
the function, which takes method's arguments and returns a key,
which can be used to index the result.
Optional method's name to be guarded: only cache for
this method will be invalidated on call. Can be a string
or an array of method names. If omitted the whole cache
will be invalidated.
The optional name of the profile section.
The optional unique name of the timer.
The flag to group output. If true, indents embedded console messages.
Attaches AOP-style advices to a method. Can attach several
advices at once and operate on several methods of an object.
The latter is achieved when a RegExp is specified as
a method name, or an array of strings and regular expressions
is used. In this case all functional methods that
satisfy the RegExp condition are processed. This function
returns a handle, which can be used to unadvise, or null,
if advising has failed.
This function is a convenience wrapper for
dojox.lang.aspect.adviseRaw().
A source object for the advised function. Cannot be a DOM node.
If this object is a constructor, its prototype is advised.
A string name of the function in obj. In case of RegExp all
methods of obj matching the regular expression are advised.
An object, which defines advises, or a function, which
returns such object, or an array of previous items.
The advice object can define following member functions:
before, around, afterReturning, afterThrowing, after.
If the function is supplied, it is called with a context
object once per call to create a temporary advice object, which
is destroyed after the processing. The temporary advice object
can implement a destroy() method, if it wants to be called when
not needed.
Attaches AOP-style advices to object's methods. Can attach several
advices at once and operate on several methods of the object.
The latter is achieved when a RegExp is specified as
a method name. In this case all functional methods that
satisfy the RegExp condition are processed. This function
returns a handle, which can be used to unadvise, or null,
if advising has failed.
A source object for the advised function.
Cannot be a DOM node.
An array of method names (strings) to be advised.
An array of advices represented by objects or functions that
return such objects on demand during the event processing.
The advice object can define following member functions:
before, around, afterReturning, afterThrowing, after.
If the function is supplied, it is called with a context
object once per call to create a temporary advice object, which
is destroyed after the processing. The temporary advice object
can implement a destroy() method, if it wants to be called when
not needed.
The object returned by dojox.lang.aspect.advise().
Calls the original function (or the next level around advice).
Accepts and passes on any number of arguments, and returns a value.
This function is valid only in the content of around calls.
If true, the documentation will be loaded asynchronously
The String variable representing the lambda function.
Conveys how to initialize parameters. If it is a String, then the apply() method
would be emulated treating "init" as a list of input parameters.
It it is an Array, then the call() method is emulated treating array members
as input parameters.
The optional function, which is used to record names of lambda parameters.
If supplied, this function is called with a name of every parameter.
The lambda expression, which is used to detect the termination of recursion.
It accepts the same parameter as the generated recursive function itself.
This function should return "true", if the recursion should be stopped,
and the "then" part should be executed. Otherwise the recursion will proceed.
The lambda expression, which is called upon termination of the recursion.
It accepts the same parameters as the generated recursive function itself.
The returned value will be returned as the value of the generated function.
The lambda expression, which is called before the recursive step.
It accepts the same parameter as the generated recursive function itself.
The returned value should be an array of two variable, which are used to call
the generated function recursively twice in row starting from the first item.
above:
The lambda expression, which is called after the recursive step.
It accepts three parameters: two returned values from recursive steps, and
the original array of parameters used with all other functions.
The returned value will be returned as the value of the generated function.
This method is used to produce partially bound
functions. If you want to change the order of arguments, use
dojox.lang.functional.mixer() or dojox.lang.functional.flip().
This method is to normalize a functional representation (a
text snippet) to an object that contains an array of
arguments, and a body , which is used to calculate the
returning value.
This method returns a textual representation of a function
built from the snippet. It is meant to be evaled in the
proper context, so local variables can be pulled from the
environment.
This method is used to normalize a functional
representation (a text snippet, an array, or a function) to
a function object.
The lambda expression, which is used to detect the termination of recursion.
It accepts the same parameter as the generated recursive function itself.
This function should return "true", if the recursion should be stopped,
and the "then" part should be executed. Otherwise the recursion will proceed.
The lambda expression, which is called upon termination of the recursion.
It accepts the same parameters as the generated recursive function itself.
The returned value will be returned as the value of the generated function.
The lambda expression, which is called before the recursive step.
It accepts the same parameter as the generated recursive function itself.
The returned value should be an array, which is used to call
the generated function recursively.
above:
The lambda expression, which is called after the recursive step.
It accepts two parameters: the returned value from the recursive step, and
the original array of parameters used with all other functions.
The returned value will be returned as the value of the generated function.
This method returns a textual representation of a function
built from the list comprehension text snippet (conformant to JS 1.7).
It is meant to be evaled in the proper context, so local variable can be
pulled from the environment.
This method returns a function built from the list
comprehension text snippet (conformant to JS 1.7). It is meant to be
reused several times.
The lambda expression, which is used to detect the termination of recursion.
It accepts the same parameter as the generated recursive function itself.
This function should return "true", if the recursion should be stopped,
and the "then" part should be executed. Otherwise the recursion will proceed.
The lambda expression, which is called upon termination of the recursion.
It accepts the same parameters as the generated recursive function itself.
The returned value will be returned as the value of the generated function.
The lambda expression, which is called before the recursive step.
It accepts the same parameter as the generated recursive function itself.
The returned value should be an array, which is used to call
the generated function recursively. Each member of the array should be
an array of parameters. The length of it defines how many times
the generated function is called recursively.
above:
The lambda expression, which is called after the recursive step.
It accepts two parameters: the array of returned values from recursive steps,
and the original array of parameters used with all other functions.
The returned value will be returned as the value of the generated function.
This is a simplification of the linear recursion combinator:
- the generated function takes one numeric parameter "x",
- the "cond" is fixed and checks for 0.
- the "before" is fixed and the generated function is called with "x - 1".
- the "above is called with two parameters: the return from the generated
function, and with "x".
- as you can see the recursion is done by decreasing the parameter,
and calling itself until it reaches 0.
The value, which is used upon termination of the recursion.
It will be returned as the value of the generated function.
above:
The lambda expression, which is called after the recursive step.
It accepts two parameters: the returned value from the recursive step, and
the original parameter. The returned value will be returned as the value of
the generated function.
The lambda expression, which is used to detect the termination of recursion.
It accepts the same parameter as the generated recursive function itself.
This function should return "true", if the recursion should be stopped,
and the "then" part should be executed. Otherwise the recursion will proceed.
The lambda expression, which is called upon termination of the recursion.
It accepts the same parameters as the generated recursive function itself.
The returned value will be returned as the value of the generated function.
The lambda expression, which is called before the recursive step.
It accepts the same parameter as the generated recursive function itself,
and returns an array of arguments for the next recursive call of
the generated function.
This is the venerable zip combiner (for example,
see Python documentation for general details). The returned
array is truncated to match the length of the shortest input
array.
This function is similar to dojox.lang.functional.zip()
and can be used to unzip objects packed by
dojox.lang.functional.zip(). It is here mostly to provide
a short-cut for the different method signature.
a function to handle the custom assignment,
or an object with exec() method
Function:
new decorator constructor
object to be filtered
the dictionary for renaming/removing while copying
new dojox.lang.oo.Filter object
top-level decorator to apply
name of the property
new value of the property
old value of the property
Object:
returns the final value of the property
target to receive new/updated properties
source of properties
defaults: dojox.lang.oo.__MixinDefaults?:
default functions for various aspects of mixing
Object:
target
target to receive new/updated properties
source of properties, more than one source is allowed
Object:
target
Properties of an object are to be renamed or removed specified
by "map" argument. Only own properties of "map" are processed.
oo.rearrange(bag, {
abc: "def", // rename "abc" attribute to "def"
ghi: null // remove/hide "ghi" attribute
});
the object to be processed
the dictionary for renaming (false value indicates removal of the named property)
Object:
the original object
This object holds an original function or another decorator
object, and implements a special mixin algorithm to be used
by dojox.lang.oo.mixin.
a payload to be processed by the decorator.
a function to handle the custom assignment, or an object with exec()
method. The signature is:
decorator(/*String*/ name, /*Function*/ newValue, /*Function*/ oldValue).
This object is used as a holder of an original object
(whose properites are to be copied), and a filter
function used while copying by dojox.lang.oo.mixin.
object to be filtered
a function to handle the name filtering,
or an object with exec() method
a decorator function to be used in absence of other decorators
a filter function to be used in absence of other filters
a mixer function to be used to mix in new properties
useful if you send ContentPane a complete page, instead of a html fragment
scans for
* title Node, remove
* DOCTYPE tag, remove
Adjust relative paths in html string content to point to this page.
Only useful if you grab content from a another folder then the current one
trigger/load styles in the content
Execute (eval) scripts that is found in the content
replace keyword '_container_' in scripts with 'dijit.byId(this.id)'
NOTE this name might change in the near future
reference to the method that should grab the content
makes it possible to add custom args to xhrGet, like ioArgs.headers['X-myHeader'] = 'true'
could put back _renderStyles by wrapping/aliasing dojox.html._ContentSetter.prototype._renderStyles
A small widget which takes a node with overflow:auto and
allows dragging to position the content. Useful with images,
or for just adding "something" to a overflow-able div.
Naturally, the behavior is to invert the axis of the drag.
Setting invert:false will make the pane drag in the same
direction as the mouse.
Works just like a ContentPane inside of a borderContainer. Will expand/collapse on
command, and supports having Layout Children as direct descendants
The size object to resize to
easing function used to hide pane
easing function use to show pane
duration to run show/hide animations
Does this widget start in an open (true) or closed (false) state
A value from 0 .. 1 indicating the opacity to use on the container
when only showing a preview
If true, will override the default behavior of a double-click calling a full toggle.
If false, a double-click will cause the preview to popup
Makes a `dojox.layout.ContentPane` float and draggable by it's title [similar to TitlePane]
and over-rides onClick to onDblClick for wipeIn/Out of containerNode
provides minimize(dock) / show() and hide() methods, and resize [almost]
Allow closure of this Node
Allow minimizing of pane if true
Allow resizing of pane true if true
Horrible param name for "Can you maximize this floating pane?"
One of: x | xy | y to limit pane's sizing direction
Title to use in the header
if empty, will create private layout.Dock that scrolls with viewport
on bottom span of viewport.
Time is MS to spend toggling in/out node
[not implemented yet] will be either icon in titlepane to left
of Title, and/or icon show when docked in a fisheye-like dock
or maybe dockIcon would be better?
The className to give to the inner node which has the content
Shown in dock icon. should read parent iconSrc?
reference to the FloatingPane we reprasent in any given dock
This component inherits of all features of gridContainerLite plus :
- Resize colums
- Add / remove columns
- Fix columns at left or at right.
Allow to resize and put grips
domNode of dropped widget.
AreaManager Object containing information of targetArea
Index where the dropped widget has been placed
index where the grip has to be created.
Number of columns
Number of column to added
Column index array
dojox.mdnd.AreaManager singleton
Allow or not resizing of columns by a grip handle.
Specifies whether columns resize as you drag (true) or only upon mouseup (false)
Minimum column width in percentage.
Minimum children width in pixel (only used for IE6 which doesn't handle min-width css property)
Location to add/remove columns, must be set to 'left' or 'right' (default).
Define if the last right column is fixed.
Used when you add or remove columns by calling setColumns method.
Define if the last left column is fixed.
Used when you add or remove columns by calling setColumns method.
GridContainerLite displays the child elements by column
(ie: the children widths are fixed by the column width of the grid but
the children heights are free).
Each child is movable by drag and drop inside the GridContainer.
The position of other children is automatically calculated when a child is moved.
These components are resized only if the targetArea.node is a
child of this instance of gridContainerLite.
To be resized, the dropped node must have also a method resize.
domNode of dropped widget.
AreaManager Object containing information of targetArea
Index where the dropped widget has been placed
True if resized.
domNode of dragged widget.
AreaManager Object containing information of sourceArea
Index where the dragged widget has been placed
An array containing all children (widgets).
true if the content is currently shown
Column number
Place in the zone (0 - first)
The widget inserted
widget to insert
column number
place in the zone (first = 0)
The widget inserted
dojox.mdnd.AreaManager singleton
Possibility to move focus into the GridContainer (TAB, LEFT ARROW, RIGHT ARROW, UP ARROW, DOWN ARROW).
Possibility to move GridContainer's children (Drag and Drop) with keyboard. (SHIFT + ARROW).
If the type of widget is not draggable, a popup is displayed.
Enable the refresh of registered areas on drag start.
template of gridContainer.
:
CSS class enabling a drag handle on a child.
The number of dropped zones, by default 1.
If true, change the size of my currently displayed child to match my size.
If true, widgets are organized automatically,
else the attribute colum of child will define the right column.
The GridContainer will only accept the children that fit to the types.
A comma separated list of column widths. If the column widths do not add up
to 100, the remaining columns split the rest of the width evenly
between them.
used for Fade and Slide RadioGroup's, the duration to run the transition animation. does not affect anything
in default RadioGroup
toggles internal button making on or off
The full declared className of the Button widget to use for hasButtons
the template for our container
An extension on a stock RadioGroup widget, sliding the pane
into view from being hidden. The entry direction is randomized
on each view
A z-index to apply to the incoming pane
A private widget used to manipulate the StackContainer (RadioGroup*). Don't create directly.
the Text Label of the button
The handle on the bottom-right corner of FloatingPane or other widgets that allows
the widget to be resized.
Typically not used directly.
id of the Widget OR DomNode that I will size
over-ride targetId and attch this handle directly to a reference of a DomNode
one of: x|y|xy limit resizing to a single axis, default to xy ...
if true, node will size realtime with mouse movement,
if false, node will create virtual node, and only resize target on mouseUp
css class applied to virtual resize node.
only applicable if activeResize = false. onMouseup, animate the node to the
new size
one of "chain" or "combine" ... visual effect only. combine will "scale"
node to size, "chain" will alter width, then height
time in MS to run sizing animation. if animateMethod="chain", total animation
playtime is 2*animateDuration
smallest height in px resized node can be
smallest width in px resize node can be
Toggle if this widget cares about the maxHeight and maxWidth
parameters.
Largest height size in px the resize node can become.
Largest width size in px the reize node can become.
Toggle to enable this widget to maintain the aspect
ratio of the attached node.
Toggle to enable/disable this widget from firing onResize
events at every step of a resize. If <code>activeResize</code> is true,
and this is false, onResize only fires _after_ the drop
operation. Animated resizing is not affected by this setting.
The name of the topic this resizehandle publishes when resize is starting
The name of the topic this resizehandle publishes when resize is complete
The RotatorContainer cycles through the children with a transition.
published topics:
[widgetId]-update - Notifies pager(s) that a child has changed.
Parameters:
/*boolean*/ playing - true if playing, false if paused
/*int*/ current - current selected child
/*int*/ total - total number of children
or int
Sets the display of the tabs. The tabs are actually a StackController.
The child's title is used for the tab's label.
The delay in milliseconds before transitioning to the next child.
The type of transition to perform when switching children.
A null transition will transition instantly.
The duration of the transition in milliseconds.
Starts the timer to transition children upon creation.
Pause the rotator when the mouse hovers over it.
Pause the rotator when the tab is changed or the pager's next/previous
buttons are clicked.
Causes the rotator to rotate in reverse order.
ID the pager widget.
Number of cycles before pausing.
The declared Class of the Pager used for this Widget
A pager can be defined one of two ways:
* Externally of the RotatorContainer's template and tell the
RotatorPager the rotatorId of the RotatorContainer
* As a direct descendant of the RotatorContainer (i.e. inside the
RotatorContainer's template)
The pager can contain the following components:
* Previous button
- Must be a dijit.form.Button
- dojoAttachPoint must be named "previous"
* Next button
- Must be a dijit.form.Button
- dojoAttachPoint must be named "next"
* Play/Pause toggle button
- Must be a dijit.form.ToggleButton
- dojoAttachPoint must be named "playPause"
- Use iconClass to specify toggled state
* Current child #
- dojoAttachPoint must be named "current"
* Total # of children
- dojoAttachPoint must be named "total"
You can choose to exclude specific controls as well as add elements
for styling.
Should you need a pager, but don't want to use Dijit buttons, you can
write your own pager widget and just wire it into the topics. The
topic names are prefixed with the widget ID of the RotatorContainer.
Notifications are received from and sent to the RotatorContainer as
well as other RotatorPagers.
published topics:
[widgetId]-cycle - Notify that the next or previous button was pressed.
Parameters:
/*boolean*/ next - true if next, false if previous
[widgetId]-state - Notify that the play/pause button was toggled.
Parameters:
/*boolean*/ playing - true if playing, false if paused
The ID of the rotator this pager is tied to.
Only required if defined outside of the RotatorContainer's container.
A sizable container that takes it's content's natural size and creates
a scroll effect based on the relative mouse position. It is an interesting
way to display lists of data, or blocks of content, within a confined
space.
Horizontal scrolling is supported. Combination scrolling is not.
FIXME: need to adust the _line somehow, it stops scrolling
storage for our top and bottom most scrollpoints
height of the visible pane
either "horizontal" or "vertical" for scroll orientation.
The TableContainer lays out child widgets in a Table layout.
Each widget can specify a "label" or a "title" parameter.
This label is displayed either above or to the left of
a widget depending on whether the "orientation" attribute
is "horiz" or "vert", for horizontal and vertical respectively.
The number of columns is configured using the "cols" attribute.
The width of labels can be configured using the "labelWidth" parameter.
Defines the width of a label. If the value is a number, it is
treated as a pixel value. The other valid value is a percentage,
e.g. "50%"
True if labels should be displayed, false otherwise.
Either "horiz" or "vert" for label orientation.
The cell spacing to apply to the table.
A CSS class that will be applied to child elements. For example, if
the class is "myClass", the table will have "myClass-table" applied to it,
each label TD will have "myClass-labelCell" applied, and each
widget TD will have "myClass-valueCell" applied.
Extends the dijit.layout._Splitter to add a toggling behavior
on double-click
the initial and current state of the splitter (and its attached pane)
how small the attached pane can be before its considered closed
the css height/width value to apply by default when the attached pane is open
the css height/width value to apply by default when the attached pane is closed
function that returns an instance of PRNG (pseudorandom number generator)
with two methods: init(array) and next(). It should have a property "size"
to indicate the required pool size.
if false or absent, onclick and onkeypress event will be used to add
"randomness", otherwise events will not be used.
Array: array to be filled in with random numbers, only existing
elements will be filled.
function that returns an instance of PRNG (pseudorandom number generator)
with two methods: init(array) and next(). It should have a property "size"
to indicate the required pool size.
noEvents: Boolean?:
if false or absent, onclick and onkeypress event will be used to add
"randomness", otherwise events will not be used.
|| Number[]
|| Number[]
a sorted numeric array to be used for the approximation.
a position number from 0 to 1. If outside of this range it
will be clamped.
Number
a numeric array to be appraised.
a Boolean flag to indicated that the array is already sorted.
This is an optional flag purely to improve the performance.
If skipped, the array will be assumed unsorted.
Object
a DOM node corresponding to the Dnd Area
if false or undefined, init the areas.
A node corresponding to the D&D Area.
True if the area is found and unregistered.
A child of the D&D Area.
The draggable item.
A moveable Object.
area index or -1
A child of the D&D Area.
The drag handle node.
a node corresponding to the D&D Area
the node which has to be treated.
the place in the area
noCheckParent:
if true, doesn't check if node has a parent.
True if the node has been inserted else false.
A node corresponding to the DndArea.
The node which has to be treated.
the removed node
A DnD area.
The children of a DnD area
The object of a D&D Area.
The node which contains margins
an object encapsulating X and Y position
an object encapsulating the area size
an index of area
containing item type
containing types
The node which is about to be dragged
an object encapsulating X and Y position
an object encapsulating width and height values
coordinates of the dragged Node.
size of the dragged Node.
coordinates of the dragged Node.
size of the dragged Node.
The node which is dragged
an object encapsulating X and Y position
an object encapsulating width and height values
coordinates of mouse
an object encapsulating X and Y position
an object encapsulating width and height values
the current drop index
an object encapsulating width and height values
The node which is about to be dropped
Enable the refresh of registered areas on drag start.
CSS class enabled an area if areaClass is defined
CSS class enabled a drag handle.
node to scroll
default mouse move offset
Default mouse margin
the dnd targer area node
node where the dropIndicator have to be placed into the area
dragNode:
the node which is dragged
the node inserted or null if it crashes
the drop indicator node
Hash of parameters
The draggable node
a DOM event
if true, the target is one of those specific nodes.
a DOM event
A DOM event
A DOM event
a DOM event
a DOM event
a DOM node
absolute position of the main node
an object encapsulating width an height values
a DOM node
a DOM node
position of the main node (equals to css left/top properties)
an object encapsulating width and height values
coordiantes of mouse
The node on which the user clicks to drag the main node.
A flag to control a drag action if a form element has been focused.
If true, the drag action is not executed.
The user clicks on the handle, but the drag action will really begin
if he tracks the main node to more than 3 pixels.
Node or node's id to build the source on.
Any property of this class may be configured via the params
object which is mixed-in to the 'dojo.dnd.Source' instance.
The "copy" was pressed.
True, if we need to copy items, false to move.
???
???
New dojox.mdnd.PureSource instance.
Mouse event.
Mouse event.
Mouse event
Copy status.
Mouse event.
True if user clicked on "approved" items.
containing the coordinates x and y (mouse position)
the source which provides items
the list of transferred items
copy items, if true, move items otherwise
the DOM event
The dragged node.
containing the type accepted for a target dojo.
true if the dragged node is accepted in the target dojo.
the dojo source/target
the source which provides items
the list of transferred items
copy items, if true, move items otherwise
The current Area on mouse over
The old area the mouse has passed over
The handler of mouse connection
The list of dojo dnd topics
DOMNode A node corresponding to the target dojo.
The index of area if it's registered else -1.
A registered DOM node.
An object which contains coordinates : *{x:0,y:,x1:0,y1:0}*
The DOM node which has to be registered.
A String to identify the node.
dojoTarger:
True if the dojo D&D have to be enable when mouse is hover the registered target dojo.
The DOM node of target dojo.
A String to identify dojo targets.
A String to identify dojo targets.
Coordinates of the mouse.
Event object.
The current Javascript Event.
current javscript event
Event object.
Representing the current dojo area
The reference to the dojox AreaManager
Handle to keep start subscribe
Handle to keep drop subscribe
Handle to keep move subscribe
Handle to kee move up subscribe
array of areas
data type of a DndArea
a sorted area
array of areas
the DnD area
the DnD area
a DnD area object
index of a draggable item
dropIndicator size
boolean to know if a dropIndicator has been added or deleted
return for:
- X point : the middle
- Y point : search if the user goes up or goes down with his mouse.
- Up : top of the draggable item
- Down : bottom of the draggable item
an object encapsulating X and Y position
an object encapsulating width and height values
coordinates of mouse
an object of coordinates
example : {'x':10,'y':10}
a list of DnD areas objects
coordinates [x,y] of the dragItem
an index representing the active DnD area
the index of the DnD area
a list of DnD areas objects
index of a DnD area (to get the interval)
coordinate x, of the dragNode
true if the dragNode is in intervall
a DnD area object
coordinates [x,y] of the draggable item
a number
or -1 if the area has no children or the drop index represents the last position in to the area
used to save a X position
used to save a Y position
see <getDragPoint>
array of areas
data type of a DndArea
a sorted area
the area position (and size) is equal to the postion of the domNode associated.
array of areas
the D&D area.
the D&D area.
a D&D area object
index of a draggable item
dropIndicator size
boolean to know if a dropIndicator has been added or deleted
an object encapsulating X and Y position
an object encapsulating width and height values
coordinates of mouse
an object of coordinates
examples:{'x':10,'y':10}
a list of D&D areas objects
coordinates [x,y] of the dragItem (see getDragPoint())
an index representing the active D&D area
the index of the D&D area
a list of D&D areas objects
index of a D&D area (to get the interval)
coordinate x, of the dragNode (see getDragPoint())
true if the dragNode is in intervall
a D&D area object.
coordinates [x,y] of the draggable item.
a number or -1 if the area has no children or the drop index represents the last position in to the area
used to save a X position
used to save a Y position
see getDragpoint()
array of areas
data type of a DndArea
a sorted area
array of areas
the DnD area
the DnD area
a DnD area object
index of a draggable item
dropIndicator size
boolean to know if a dropIndicator has been added or deleted
return for:
- X point : the middle
- Y point : search if the user goes up or goes down with his mouse.
- Up : top of the draggable item
- Down : bottom of the draggable item
an object encapsulating X and Y position
an object encapsulating width and height values
coordinates of mouse
an object of coordinates
example : {'x':10,'y':10}
a list of DnD areas objects
coordinates [x,y] of the dragItem
an index representing the active DnD area
the index of the DnD area
a list of DnD areas objects
index of a DnD area (to get the interval)
coordinate x, of the dragNode
true if the dragNode is in intervall
a DnD area object
coordinates [x,y] of the draggable item
a number
or -1 if the area has no children or the drop index represents the last position in to the area
used to save a X position
used to save a Y position
see <getDragPoint>
Finds the currently applied theme name, such as 'iphone' or 'android'
from link elements, and adds it as a class name for the body element.
The CSS files to load and register with the page.
Dynamic creation is not supported.
View acts as a container for any HTML and/or widgets. An entire HTML page
can have multiple View widgets and the user can navigate through
the views back and forth without page transitions.
Transitions to the blank view, and then opens another page.
performTransition(null, 1, "slide", null, function(){location.href = href;});
The destination view id to transition the current view to.
If null, transitions to a blank view.
The transition direction. If 1, transition forward. If -1, transition backward.
For example, the slide transition slides the view from right to left when dir == 1,
and from left to right when dir == -1.
transision: String
The type of transition to perform. "slide", "fade", or "flip"
Object The object that the callback function will receive as "this".
A callback function that is called when the transition has been finished.
A function reference, or name of a function in context.
Note that dojox.mobile.currentView is the last shown view.
If the page consists of a splitter, there are multiple showing views.
node to forcibly redraw.
If true, the view is displayed at startup time.
If true, the scroll position is kept between views.
Thhe state to toggle, switch 'on' or 'off'
The DOM node to connect to
integer. If positive, the dialog is shown. If negative,
the dialog is hidden.
The title of the AlertDialog
The text message displayed in the AlertDialog
The SceneController for the currently active scene
Handle the selection of a value
The data items from which the image urls are retrieved.
If an item is a string, it is expected to be a URL. Otherwise
by default it is expected to have a 'url' member. This can
be configured using the 'urlParam' attribute on this widget.
The paramter name used to retrieve an image url from a JSON object
The position of the image that has loaded, either
"center", "left" or "right"
The src of the image
True if it is a small version of the image that has loaded,
false otherwise.
The current level of zoom. This should not be set manually.
The X coordinate in the image where the zoom is focused
The Y coordinate in the image where the zoom is focused
The highest degree to which an image can be zoomed. For example,
a maxZoom of 5 means that the image will be 5 times larger than normal
The degree to which the image is zoomed when auto zoom is invoked.
The higher the number, the more the image is zoomed in.
Disables auto zoom
Disables the users ability to swipe from one image to the next.
Overrides the default event listened to which invokes auto zoom
The small sized image to the left
The small sized image to the right
Handles the loading of an image, both the large and small
versions. A render is triggered as a result of each image load.
DOM node of the row about to be deleted.
data related to the row being deleted
index of the data in the total array
array of data used.
The array of data items that will be rendered.
The URL to the HTML file containing the markup for each individual
data item.
The URL to the HTML file containing the HTML to display if there
are no data items. This is optional.
The URL to the HTML file containing the markup for the dividers
between groups of list items
The label to display for the Delete button
The label to display for the Cancel button
A name/value map of functions used to format data for display
The number of templates remaining to load before the list renders.
The coordinates of where a mouseDown event was detected
Completes the deletion of a row.
Checks if all templates have loaded
The array of items to display. Each element in the array
should have both a label and value attribute, e.g.
[{label: "Open", value: 1} , {label: "Delete", value: 2}]
The current SceneController widget.
paramters, only passed when a subsequent scene pops itself
off the stack and passes back data.
The list of scenes currently in existance in the app.
For `dijit.form.TextBox` this basically returns the value of the <input>.
For `dijit.form.MappedTextBox` subclasses, which have both
a "displayed value" and a separate "submit value",
This treats the "displayed value" as the master value, computing the
submit value from it via this.parse().
Sets the value of the widget to "value" which can be of
any type as determined by the widget.
visual element value is also set to a corresponding,
but not necessarily the same, value.
If true, an onChange event is fired immediately instead of
waiting for the next blur event.
If specified, used to set the visual element value,
otherwise a computed visual value is used.
Returns the displayed value (what the user sees on the screen),
after filtering (ie, trimming spaces etc.).
For some subclasses of TextBox (like ComboBox), the displayed value
is different from the serialized value that's actually
sent to the server (see dijit.form.ValidationTextBox.serialize)
Sets the value of the visual element to the string "value".
The widget value is also set to a corresponding,
but not necessarily the same, value.
For MappedTextBox subclasses, this is called twice
- once with the display value
- once the value as set/returned by attr('value', ...)
and attr('value'), ex: a Number for NumberTextBox.
In the latter case it does corrections like converting null to NaN. In
the former case the NumberTextBox.filter() method calls this.inherited()
to execute standard trimming code in TextBox.filter().
TODO: break this into two methods in 2.0
Removes leading and trailing whitespace if true. Default is false.
Converts all characters to uppercase if true. Default is false.
Converts all characters to lowercase if true. Default is false.
Converts the first character of each word to uppercase if true.
HTML INPUT tag maxLength declaration.
If true, all text will be selected when focused with mouse
Defines a hint to help users fill out the input field (as defined in HTML 5).
This should only contain plain text (no html markup).
For subclasses like ComboBox where the displayed value
(ex: Kentucky) and the serialized value (ex: KY) are different,
this represents the displayed value.
Setting 'displayedValue' through attr('displayedValue', ...)
updates 'value', and vice-versa. Otherwise 'value' is updated
from 'displayedValue' periodically, like onBlur etc.
TODO: move declaration to MappedTextBox?
Problem is that ComboBox references displayedValue,
for benefit of FilteringSelect.
if the textbox is blank, what value should be reported
Represents a single HTML element.
All these widgets should have these attributes just like native HTML input elements.
You can set them during widget construction or afterwards, via `dijit._WidgetBase.attr`.
They also share some common methods.
the new value
For a slider, for example, dragging the slider is priorityChange==false,
but on mouse up, it's priorityChange==true. If intermediateChanges==true,
onChange is only called form priorityChange=true events.
Name used when submitting form; same as "name" attribute or plain HTML elements
Corresponds to the native HTML <input> element's attribute.
Corresponds to the native HTML <input> element's attribute.
Corresponds to the native HTML <input> element's attribute.
Should this widget respond to user input?
In markup, this is specified as "disabled='disabled'", or just "disabled".
Fires onChange for each value change or only on demand
On focus, should this widget scroll into view?
Indicates that changes to the value should call onChange() callback.
This is false during widget initialization, to avoid calling onChange()
when the initial value is set.
Each _FormValueWidget represents a single input value, and has a (possibly hidden) <input> element,
to which it serializes it's input value, so that form submission (either normal submission or via FormBind?)
works as expected.
Sets the value of the widget.
If the value has changed, then fire onChange event, unless priorityChange
is specified as null (or false?)
optional
Should this widget respond to user input?
In markup, this is specified as "readOnly".
Similar to disabled except readOnly form values are submitted.
A string
length: Number, minlength: Number, maxlength: Number}
flags.length If set, checks if there are exactly flags.length number of characters.
flags.minlength If set, checks if there are at least flags.minlength number of characters.
flags.maxlength If set, checks if there are at most flags.maxlength number of characters.
A string
max:Number, min:Number, decimal:String}
flags.max A number, which the value must be less than or equal to for the validation to be true.
flags.min A number, which the value must be greater than or equal to for the validation to be true.
flags.decimal The character used for the decimal point. Default is ".".
Validates any sort of number based format. Use it for phone numbers,
social security numbers, zip-codes, etc. The value can be validated
against one format or one of multiple formats.
Format Definition
# Stands for a digit, 0-9.
? Stands for an optional digit, 0-9 or nothing.
All other characters must appear literally in the expression.
"(###) ###-####" -> (510) 542-9742
"(###) ###-#### x#???" -> (510) 542-9742 x153
"###-##-####" -> 506-82-1089 i.e. social security number
"#####-####" -> 98225-1649 i.e. zip code
// returns true:
dojox.validate.isNumberFormat("123-45", { format:"###-##" });
Check Multiple formats:
dojox.validate.isNumberFormat("123-45", {
format:["### ##","###-##","## ###"]
});
A string
FIXME: make pseudo-object for this
format: String
flags.format A string or an Array of strings for multiple formats.
Validate a String value against the Luhn algorithm to verify
its integrity.
returns an object that contains several methods summarizing the results of the validation
form to be validated
specifies how the form fields are to be validated
{trim:Array, uppercase:Array, lowercase:Array, ucfirst:Array, digit:Array,
required:Array, dependencies:Object, constraints:Object, confirm:Object}
The arrays are expected to be in the format of:
constraints:{
dojo.validate.check() profile that this evaluation is against.
The single [] array of function and arguments for the function.
form dom name of the field being validated.
form element field.
Checks if a credit card type matches the # scheme in a passed value, and if
the Luhn checksum is accurate (unless its an Enroute card, in which case
the checkSum is skipped), returning a Boolean to check against.
if(dojox.validate.isValidCreditCard("12345", "mc")){
console.log('inconceivable');
}
A Value (credit card number) to validate
A credit-card abbreviation.
CC #, white spaces and dashes are ignored
One of the abbreviation values in <code>dojox.validate._cardInfo</code> --
if Omitted, function returns a <code>|</code> delimited string of matching card types,
or false if no matches found.
An ISBN to validate
Boolean
Supports 5 formats for IPv4: dotted decimal, dotted hex, dotted octal, decimal and hexadecimal.
Supports 2 formats for Ipv6.
value A string.
flags An object. All flags are boolean with default = true.
flags.allowDottedDecimal Example, 207.142.131.235. No zero padding.
flags.allowDottedHex Example, 0x18.0x11.0x9b.0x28. Case insensitive. Zero padding allowed.
flags.allowDottedOctal Example, 0030.0021.0233.0050. Zero padding allowed.
flags.allowDecimal Example, 3482223595. A decimal number between 0-4294967295.
flags.allowHex Example, 0xCF8E83EB. Hexadecimal number between 0x0-0xFFFFFFFF.
Case insensitive. Zero padding allowed.
flags.allowIPv6 IPv6 address written as eight groups of four hexadecimal digits.
flags.allowHybrid IPv6 address written as six groups of four hexadecimal digits
followed by the usual 4 dotted decimal digit notation of IPv4. x:x:x:x:x:x:d.d.d.d
A string
An object
flags.scheme Can be true, false, or [true, false].
This means: required, not allowed, or either.
flags in regexp.host can be applied.
flags in regexp.ipAddress can be applied.
flags in regexp.tld can be applied.
A string
An object
flags.allowCruft Allow address like <mailto:foo@yahoo.com>. Default is false.
flags in regexp.host can be applied.
flags in regexp.ipAddress can be applied.
flags in regexp.tld can be applied.
A string
An object (same as dojo.validate.isEmailAddressList)
Module provides validation functions for Credit Cards, using account number
rules in conjunction with the Luhn algorigthm, with a plugable card info database.
to delete
This is the absolute id of the object
This is the service to register
This is the path that is used for all the ids for the objects returned by service
This is a JSON Schema object to associate with objects returned by this service
Initializes the storage systems and figures out the best available
storage options on this platform.
The full class name of this provider, such as
"dojox.storage.FlashStorageProvider".
An instance of this provider, which we will use to call
isAvailable() on.
Example-
dojox.storage.setProvider(
dojox.storage.IEStorageProvider)
Adds a listener to know when Dojo Offline can be used. This
ensures that the Dojo Offline framework is loaded and that the
local dojox.storage system is ready to be used. This method is
useful if you don't want to have a dependency on Dojo Events
when using dojox.storage.
A function to call when Dojo Offline is ready to go
Example-
dojox.storage.manager.supportsProvider(
"dojox.storage.InternetExplorerStorageProvider");
Example 1-
if(dojox.storage.manager.isInitialized() == false){
dojo.connect(dojox.storage.manager, "loaded", TestStorage, "initialize");
}else{
dojo.connect(dojo, "loaded", TestStorage, "initialize");
}
Example 2-
dojox.storage.manager.addOnLoad(someFunction);
This will return all files needed by all storage providers for
this particular environment type. For example, if we are in the
browser environment, then this will return the hidden SWF files
needed by the FlashStorageProvider, even if we don't need them
for the particular browser we are working within. This is meant
to faciliate Dojo Offline, which must retrieve all resources we
need offline into the offline cache -- we retrieve everything
needed, in case another browser that requires different storage
mechanisms hits the local offline cache. For example, if we
were to sync against Dojo Offline on Firefox 2, then we would
not grab the FlashStorageProvider resources needed for Safari.
The storage provider that was automagically chosen to do storage
on this platform, such as dojox.storage.FlashStorageProvider.
Store to add
This is the base query to should be used to load the items for
the store. Generally you want to load all the items that should be
available when offline.
dojox.rpc.Service must be loaded prior to any plugin services like dojox.rpc.Rest
dojox.rpc.JsonRpc in order for them to register themselves, otherwise you get
a "No match found" error.
dojox.rpc.Service must be loaded prior to any plugin services like dojox.rpc.Rest
dojox.rpc.JsonRpc in order for them to register themselves, otherwise you get
a "No match found" error.
Takes a number of properties as kwArgs for defining the service. It also
accepts a string. When passed a string, it is treated as a url from
which it should synchronously retrieve an smd file. Otherwise it is a kwArgs
object. It accepts serviceUrl, to manually define a url for the rpc service
allowing the rpc system to be used without an smd definition. strictArgChecks
forces the system to verify that the # of arguments provided in a call
matches those defined in the smd. smdString allows a developer to pass
a jsonString directly, which will be converted into an object or alternatively
smdObject is accepts an smdObject directly.
This function will create and return a sandbox object (see dojox.secure.__Sandbox)
for the provided element.
DOM element to use as the container for the sandbox
You can use the Reconnect module:
dojo.require("dojox.socket");
dojo.require("dojox.socket.Reconnect");
var socket = dojox.socket({url:"/comet"});
// add auto-reconnect support
socket = dojox.socket.Reconnect(socket);
to add reconnection support to.
An object that implements the WebSocket API
dojo.require("dojox.socket.LongPoll");
var socket = dojox.socket.LongPoll({url:"/comet"});
or:
dojo.require("dojox.socket.LongPoll");
dojox.socket.LongPoll.add();
var socket = dojox.socket({url:"/comet"});
This uses the same arguments as the other I/O functions in Dojo, with this addition:
args.interval:
Indicates the amount of time (in milliseconds) after a response was received
before another request is made. By default, a request is made immediately
after getting a response. The interval can be increased to reduce load on the
server or to do simple time-based polling where the server always responds
immediately.
args.transport:
Provide an alternate transport like dojo.io.script.get
An object that implements the WebSocket API
There are four ways to call this:
1) Straight SQL: dojox.sql("SELECT * FROM FOOBAR");
2) SQL with parameters: dojox.sql("INSERT INTO FOOBAR VALUES (?)", someParam)
3) Encrypting particular values:
dojox.sql("INSERT INTO FOOBAR VALUES (ENCRYPT(?))", someParam, "somePassword", callback)
4) Decrypting particular values:
dojox.sql("SELECT DECRYPT(SOMECOL1), DECRYPT(SOMECOL2) FROM
FOOBAR WHERE SOMECOL3 = ?", someParam,
"somePassword", callback)
For encryption and decryption the last two values should be the the password for
encryption/decryption, and the callback function that gets the result set.
Note: We only support ENCRYPT(?) statements, and
and DECRYPT(*) statements for now -- you can not have a literal string
inside of these, such as ENCRYPT('foobar')
Note: If you have multiple columns to encrypt and decrypt, you can use the following
convenience form to not have to type ENCRYPT(?)/DECRYPT(*) many times:
dojox.sql("INSERT INTO FOOBAR VALUES (ENCRYPT(?, ?, ?))",
someParam1, someParam2, someParam3,
"somePassword", callback)
dojox.sql("SELECT DECRYPT(SOMECOL1, SOMECOL2) FROM
FOOBAR WHERE SOMECOL3 = ?", someParam,
"somePassword", callback)
Taken from http://www.movable-type.co.uk/scripts/aes.html by
Chris Veness (CLA signed); adapted for Dojo and Google Gears Worker Pool
by Brad Neuberg, bkn3@columbia.edu
of worker pool to create to help with crypto
You can disable this storage provider with the following djConfig
variable:
var djConfig = { disableGearsStorage: true };
Authors of this storage provider-
Brad Neuberg, bkn3@columbia.edu
instance methods and properties
dojox.storage exposes the current available storage provider on this
platform. It gives you methods such as dojox.storage.put(),
dojox.storage.get(), etc.
For more details on dojox.storage, see the primary documentation
page at
http://manual.dojotoolkit.org/storage.html
Note for storage provider developers who are creating subclasses-
This is the base class for all storage providers Specific kinds of
Storage Providers should subclass this and implement these methods.
You should avoid initialization in storage provider subclass's
constructor; instead, perform initialization in your initialize()
method.
Example-
var resultsHandler = function(status, key, message, namespace){
alert("status="+status+", key="+key+", message="+message);
};
dojox.storage.put("test", "hello world", resultsHandler);
Arguments:
status - The status of the put operation, given by
dojox.storage.FAILED, dojox.storage.SUCCEEDED, or
dojox.storage.PENDING
key - The key that was used for the put
message - An optional message if there was an error or things failed.
namespace - The namespace of the key. This comes at the end since
it was added later.
Important note: if you are using Dojo Storage in conjunction with
Dojo Offline, then you don't need to provide
a resultsHandler; this is because for Dojo Offline we
use Google Gears to persist data, which has unlimited data
once the user has given permission. If you are using Dojo
Storage apart from Dojo Offline, then under the covers hidden
Flash might be used, which is both asychronous and which might
get denied; in this case you must provide a resultsHandler.
A string key to use when retrieving this value in the future.
A value to store; this can be any JavaScript type.
A callback function that will receive three arguments. The
first argument is one of three values: dojox.storage.SUCCESS,
dojox.storage.FAILED, or dojox.storage.PENDING; these values
determine how the put request went. In some storage systems
users can deny a storage request, resulting in a
dojox.storage.FAILED, while in other storage systems a storage
request must wait for user approval, resulting in a
dojox.storage.PENDING status until the request is either
approved or denied, resulting in another call back with
dojox.storage.SUCCESS.
The second argument in the call back is the key name that was being stored.
The third argument in the call back is an optional message that
details possible error messages that might have occurred during
the storage process.
Optional string namespace that this value will be placed into;
if left off, the value will be placed into dojox.storage.DEFAULT_NAMESPACE
A string key to get the value of.
Optional string namespace that this value will be retrieved from;
if left off, the value will be retrieved from dojox.storage.DEFAULT_NAMESPACE
return: Returns any JavaScript object type; null if the key is not present
Returns the maximum storage size
supported by this provider, in
thousands of bytes (i.e., if it
returns 60 then this means that 60K
of storage is supported).
If this provider can not determine
it's maximum size, then
dojox.storage.SIZE_NOT_AVAILABLE is
returned; if there is no theoretical
limit on the amount of storage
this provider can return, then
dojox.storage.SIZE_NO_LIMIT is
returned
Example-
var resultsHandler = function(status, key, message){
alert("status="+status+", key="+key+", message="+message);
};
dojox.storage.put(["test"], ["hello world"], resultsHandler);
Important note: if you are using Dojo Storage in conjunction with
Dojo Offline, then you don't need to provide
a resultsHandler; this is because for Dojo Offline we
use Google Gears to persist data, which has unlimited data
once the user has given permission. If you are using Dojo
Storage apart from Dojo Offline, then under the covers hidden
Flash might be used, which is both asychronous and which might
get denied; in this case you must provide a resultsHandler.
An array of string keys to use when retrieving this value in the future,
one per value to be stored
An array of values to store; this can be any JavaScript type, though the
performance of plain strings is considerably better
A callback function that will receive three arguments. The
first argument is one of three values: dojox.storage.SUCCESS,
dojox.storage.FAILED, or dojox.storage.PENDING; these values
determine how the put request went. In some storage systems
users can deny a storage request, resulting in a
dojox.storage.FAILED, while in other storage systems a storage
request must wait for user approval, resulting in a
dojox.storage.PENDING status until the request is either
approved or denied, resulting in another call back with
dojox.storage.SUCCESS.
The second argument in the call back is the key name that was being stored.
The third argument in the call back is an optional message that
details possible error messages that might have occurred during
the storage process.
Optional string namespace that this value will be placed into;
if left off, the value will be placed into dojox.storage.DEFAULT_NAMESPACE
An array of string keys to get the value of.
Optional string namespace that this value will be retrieved from;
if left off, the value will be retrieved from dojox.storage.DEFAULT_NAMESPACE
return: Returns any JavaScript object type; null if the key is not present
This method returns a list of URLs that this
storage provider depends on to do its work.
This list is used by the Dojo Offline Toolkit
to cache these resources to ensure the machinery
used by this storage provider is available offline.
What is returned is an array of URLs.
Note that Dojo Offline uses Gears as its native
storage provider, and does not support using other
kinds of storage providers while offline anymore.
Flag that indicates a put() call to a
storage provider was succesful.
Flag that indicates a put() call to
a storage provider failed.
Flag that indicates a put() call to a
storage provider is pending user approval.
Returned by getMaximumSize() if this storage provider can not determine
the maximum amount of data it can support.
Returned by getMaximumSize() if this storage provider has no theoretical
limit on the amount of data it can store.
The namespace for all storage operations. This is useful if several
applications want access to the storage system from the same domain but
want different storage silos.
The WHAT WG storage API is documented at
http://www.whatwg.org/specs/web-apps/current-work/#scs-client-side
You can disable this storage provider with the following djConfig
variable:
var djConfig = { disableWhatWGStorage: true };
Authors of this storage provider-
JB Boisseau, jb.boisseau@eutech-ssii.com
Brad Neuberg, bkn3@columbia.edu
INPUT DOM node
Complex Expression Pattern type. One of "FILE_PATH", "URL", "EMAIL", "XPATH"
Complex Expression Pattern type. One of "FILE_PATH", "URL", "EMAIL", "XPATH"
Each group (excluding the 0 group) is passed as a parameter. If the function returns
a value, it's added to the list of tokens.
Used as the "this" instance when calling parseDelim
The current length of the internal string.
DocTests are tests that are defined inside the comment.
A doctest looks as if it was copied from the shell (which it mostly is).
A doctest is executed when the following conditions match:
1) all lines are comments
2) the line always starts with spaces/tabs followed by "//"
and at least one space
3) the line(s) of the test to execute starts with ">>>"
preceeded by what is described in 2)
4) the first line after 3) starting without ">>>" is the exptected result.
preceeded by what is described in 2)
5) the test sequence is terminated by an empty line, or the next
test in the following line, or a new line that does not start as described in 2)
(simple said: is not a comment)
preceeded by what is described in 2)
I.e. the following is a simple doctest, that will actually also be run
if you run this class against this file here:
>>> 1+1 // A simple test case. Terminated by an empty line
2
>>> 1==2
false
>>> "a"+"b" // Also without the empty line before, this is a new test.
"ab"
>>> var anything = "anything" // Multiple commands for one test.
>>> "something"==anything
false
DocTests are great for inline documenting a class or method, they also
are very helpful in understanding what the class/method actually does.
They don't make sense everywhere, but sometimes they are really handy.
Boolean, if false "data" contains only the pure tests, comments already stripped.
doctest = new dojox.testing.DocTest();
doctest.run("dojox.testing.DocTest");
doctest.errors should finally be an empty array.
// The above is not a doctest, because it just would
// execute itself in a never ending loop.
>>> true==true // Test a new line terminating the test.
true
>>> true==true // Test a new test terminating the test.
true
>>> true==true // Test a "not a comment"-line, especially an empty line terminating the test.
true
Make sure that the types are compared properly. There used to be
the bug that a return value false was compared to "false" which
made the test fail. This is fixed and should be verified by the
following tests.
>>> false
false
>>> "false"
"false"
>>> true
true
>>> 1
1
>>> "s"
"s"
>>> dojo.toJson({one:1})
"{"one":1}"
This array will contain the sequence defines resolved, so that
ie. repeat:10 will result in 10 elements in the sequence, so
the repeat handling is easier and we don't need to handle that
many extra cases. Also the doneFunction, if given is added at the
end of the resolved-sequences.
The sequence of actions
The function to call when done
This can only interrupt the sequence not the last function that
had been started. If the last function was i.e. a slideshow
that is handled inside a function that you have given as
one sequence item it cant be stopped, since it is not controlled
by this object here. In this case it would be smarter to
run the slideshow using a sequence object so you can also stop
it using this method.
The resolved sequence, for easier handling.
The pause to wait before really going on.
interval in ms at which the output function is fired.
minimum: the minimum number of elements in the internal queue.
between function calls, in milliseconds.
interval, in milliseconds.
Calls the "onStart()" handler, if defined.
Note that the onTick() function is not called right away,
only after first interval passes.
Calls the "onStop()" handler, if defined.
dojox.timing.doLater(conditional) is testing if the call
should be done later. So it returns
true if the param is false.
arguments:
If the asserted condition is true, this method does nothing. If the
condition is false, we throw an error with a error message.
Must be true for the assertion to succeed.
A string describing the assertion.
throws: Throws an Error if 'booleanValue' is false.
The Nil UUID is described in section 4.1.7 of
RFC 4122: http://tools.ietf.org/html/rfc4122#section-4.1.7
examples:
var string = dojox.uuid.generateNilUuid();
var variant = dojox.uuid.getVariant("3b12f1df-5232-4804-897e-917bf397618a");
dojox.uuid.assert(variant == dojox.uuid.variant.DCE);
"3b12f1df-5232-4804-897e-917bf397618a"
^
(variant "10__" == DCE)
var version = dojox.uuid.getVersion("b4308fb0-86cd-11da-a72b-0800200c9a66");
dojox.uuid.assert(version == dojox.uuid.version.TIME_BASED);
Any of these five values: "string", String, "hex", "date", Date
Returns the timestamp value as a JavaScript Date object or a 15-character string of hex digits.
examples:
var uuidString = "b4308fb0-86cd-11da-a72b-0800200c9a66";
var date, string, hexString;
date = dojox.uuid.getTimestamp(uuidString); // returns a JavaScript Date
date = dojox.uuid.getTimestamp(uuidString, Date); //
string = dojox.uuid.getTimestamp(uuidString, String); // "Mon, 16 Jan 2006 20:21:41 GMT"
hexString = dojox.uuid.getTimestamp(uuidString, "hex"); // "1da86cdb4308fb0"
A typical generated value would be something like this:
"3b12f1df-5232-4804-897e-917bf397618a"
For more information about random UUIDs, see sections 4.4 and
4.5 of RFC 4122: http://tools.ietf.org/html/rfc4122#section-4.4
This generator function is designed to be small and fast,
but not necessarily good.
Small: This generator has a small footprint. Once comments are
stripped, it's only about 25 lines of code, and it doesn't
dojo.require() any other modules.
Fast: This generator can generate lots of new UUIDs fairly quickly
(at least, more quickly than the other dojo UUID generators).
Not necessarily good: We use Math.random() as our source
of randomness, which may or may not provide much randomness.
examples:
var string = dojox.uuid.generateRandomUuid();
This implementation is intended to match the sample implementation
in IETF RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
Any object that has toString() method that returns a 36-character string that conforms to the UUID spec.
Any object that has toString() method that returns a 36-character string that conforms to the UUID spec.
Any object that has toString() method that returns a 36-character string that conforms to the UUID spec.
A UUID generator function, such as dojox.uuid.generateTimeBasedUuid.
Any object that has toString() method that returns a 36-character string that conforms to the UUID spec.
var uuid = new dojox.uuid.Uuid("3b12f1df-5232-4804-897e-917bf397618a");
var variant = uuid.getVariant();
dojox.uuid.assert(variant == dojox.uuid.variant.DCE);
"3b12f1df-5232-4804-897e-917bf397618a"
^
(variant "10__" == DCE)
For more info, see
http://www.webdav.org/specs/draft-leach-uuids-guids-01.txt
http://www.infonuovo.com/dma/csdocs/sketch/instidid.htm
http://kruithof.xs4all.nl/uuid/uuidgen
http://www.opengroup.org/onlinepubs/009629399/apdxa.htm#tagcjh_20
http://jakarta.apache.org/commons/sandbox/id/apidocs/org/apache/commons/id/uuid/clock/Clock.html
The CNPJ/CGC number in ##.###.###/####-##, ########/####-##,
############-## or ############## format
The CGC number in ##.###.###/#### or ############ format
The CPF number in #########-## or ###########,
format
The CPF number in ######### format
Validates Canadian 9 digit social insurance number for several
common formats. This routine only pattern matches and does not
use the Luhn Algorithm to validate number.
Validates Canadian 6 digit postal code.
Canadian postal codes are in the format ANA NAN,
where A is a letter and N is a digit, with a space
separating the third and fourth characters.
A hash of valid CC abbreviations and regular expressions
Express
Club
Blanch
Supports 5 formats for IPv4: dotted decimal, dotted hex, dotted octal, decimal and hexadecimal.
Supports 2 formats for Ipv6.
flags An object. All flags are boolean with default = true.
flags.allowDottedDecimal Example, 207.142.131.235. No zero padding.
flags.allowDottedHex Example, 0x18.0x11.0x9b.0x28. Case insensitive. Zero padding allowed.
flags.allowDottedOctal Example, 0030.0021.0233.0050. Zero padding allowed.
flags.allowDecimal Example, 3482223595. A decimal number between 0-4294967295.
flags.allowHex Example, 0xCF8E83EB. Hexadecimal number between 0x0-0xFFFFFFFF.
Case insensitive. Zero padding allowed.
flags.allowIPv6 IPv6 address written as eight groups of four hexadecimal digits.
FIXME: ipv6 can be written multiple ways IIRC
flags.allowHybrid IPv6 address written as six groups of four hexadecimal digits
followed by the usual 4 dotted decimal digit notation of IPv4. x:x:x:x:x:x:d.d.d.d
A host is a named host (A-z0-9_- but not starting with -), a domain name or an IP address, possibly followed by a port number.
An object.
flags.allowNamed Allow a named host for local networks. Default is false.
flags.allowIP Allow an IP address for hostname. Default is true.
flags.allowLocal Allow the host to be "localhost". Default is false.
flags.allowPort Allow a port number to be present. Default is true.
flags in regexp.ipAddress can be applied.
An object
flags.scheme Can be true, false, or [true, false].
This means: required, not allowed, or match either one.
flags in regexp.host can be applied.
flags in regexp.ipAddress can be applied.
An object
flags.allowCruft Allow address like <mailto:foo@yahoo.com>. Default is false.
flags in regexp.host can be applied.
flags in regexp.ipAddress can be applied.
Use this method for phone numbers, social security numbers, zip-codes, etc.
The RE can match one format or one of multiple formats.
Format
# Stands for a digit, 0-9.
? Stands for an optional digit, 0-9 or nothing.
All other characters must appear literally in the expression.
Example
"(###) ###-####" -> (510) 542-9742
"(###) ###-#### x#???" -> (510) 542-9742 x153
"###-##-####" -> 506-82-1089 i.e. social security number
"#####-####" -> 98225-1649 i.e. zip code
An object
flags.format A string or an Array of strings for multiple formats.
A two character string
An object
flags.allowTerritories Allow Guam, Puerto Rico, etc. Default is true.
flags.allowMilitary Allow military 'states', e.g. Armed Forces Europe (AE). Default is true.
The telephone number string
Indicates if the drawing should not be animated (vs. the default of doing an animation)
Indicates if the drawing should not be animated (vs. the default of doing an animation)
These are standalone widgets with varying levels of stability. Some are useful,
some were created for demonstration purposes, and learning tools. The each maintain
their own .css file (typically dojox/widget/WidgetName/WidgetName.css)
using dojo.gfx (and thus either SVG or VML based on what is supported), this widget
builds a gauge component, used to display numerical data in a familiar format
usage:
<script type="text/javascript">
dojo.require("dojox.widget.AnalogGauge");
dojo.require("dijit.util.parser");
</script>
...
<div dojoType="dojox.widget.AnalogGauge"
id="testGauge"
width="300"
height="200"
cx=150
cy=175
radius=125
image="gaugeOverlay.png"
imageOverlay="false"
imageWidth="280"
imageHeight="155"
imageX="12"
imageY="38">
</div>
A value to be converted to an angle for this gauage.
A angle to be converted to a value for this gauge.
An angle, in degrees, to be converted to radians.
An angle, in radians, to be converted to degrees.
Draws the gauge by drawing the surface, the ranges, and the indicators.
Draws a range (colored area on the background of the gauge)
based on the given arguments.
A range is a dojox.widget.gauge.Range or an object
with similar parameters (low, high, hover, etc.).
The event object as received by the mouse handling functions below.
angle (in degrees) for start of gauge (default is -90)
angle (in degrees) for end of gauge (default is 90)
center of gauge x coordinate (default is gauge width / 2)
center of gauge x coordinate (default is gauge height / 2)
radius of gauge (default is smaller of cx-25 or cy-25)
of dojox.widget._Gauge._defaultIndicator
Adds automatic rotating to the dojox.widget.Rotator. The
AutoRotator has parameters that control how user input can
affect the rotator including a suspend when hovering over the
rotator and pausing when the user manually advances to another
pane.
Pause the rotator when the mouse hovers over it.
The time in milliseconds before transitioning to the next pane. The
default value is 4000 (4 seconds).
Starts the timer to transition children upon creation.
Pause the rotator when the pane is changed or a controller's next or
previous buttons are clicked.
Number of cycles before pausing.
Determines if the panes should cycle randomly.
Causes the rotator to rotate in reverse order.
Indicates if the drawing should not be animated (vs. the default of doing an animation)
Indicates if the drawing should not be animated (vs. the default of doing an animation)
using dojo.gfx (and thus either SVG or VML based on what is supported), this widget
builds a bar graph component, used to display numerical data in a familiar format.
usage:
<script type="text/javascript">
dojo.require("dojox.widget.BarGauge");
dojo.require("dijit.util.parser");
</script>
...
<div dojoType="dojox.widget.BarGauge"
id="testBarGauge"
barGaugeHeight="55"
dataY="25"
dataHeight="25"
dataWidth="225">
</div>
A value to be converted to a position for this bar graph.
A position to be converted to a value.
Draws the bar graph by drawing the surface, the ranges, and the indicators.
Draws a range (colored area on the background of the gauge)
based on the given arguments.
A range is either a dojox.widget.gauge.Range or an object
with similar parameters (low, high, hover, etc.).
The event object as received by the mouse handling functions below.
x position of data area (default 5)
y position of data area (default 5)
width of data area (default is bar graph width - 10)
height of data area (default is bar graph width - 10)
of dojox.widget._Gauge._defaultIndicator
The template to be used to construct the widget.
The list of mixin views available on this calendar.
Specifies if visual effects should be applied to the widget.
The default behavior of the widget does not contain any effects.
The dojox.widget.CalendarFx package is needed for these.
This widget is a container of other widgets, so this is true.
The currently selected Date
The date format of the date displayed in the footer. Can be
'short', 'medium', and 'long'
The template to be used to construct the widget.
Specifies how much to increment the displayed date when the user
clicks the array button to increment of decrement the view.
Specifies the type of day name to display. "narrow" causes just one letter to be shown.
The template to be used to construct the widget.
Specifies how much to increment the displayed date when the user
clicks the array button to increment of decrement the view.
The number of years to display at once.
The template to be used to construct the widget.
Specifies how much to increment the displayed date when the user
clicks the array button to increment of decrement the view.
Specifies the CSS class to apply to the header node for this view.
The template to be used to construct the widget.
Provides an interactive HSV ColorPicker similar to
PhotoShop's color selction tool. This is an enhanced
version of the default dijit.ColorPalette, though provides
no accessibility.
0..360
means stop, anything else is just how many times it was called.
node generating the event.
event.
means stop, anything else is just how many times it was called.
node generating the event.
event.
show/update RGB input nodes
show/update HSV input nodes
show/update Hex value field
deprecated? or just use a toggle to show/hide that node, too?
toggle to use slideTo (true) or just place the cursor (false) on click
time in ms picker node will slide to next location (non-dragging) when animatePoint=true
Set to true to fire onChange in an indeterminate way
Height of the hue picker, used to calculate positions
Height of the 2d picker, used to calculate positions
Width of the 2d picker, used to calculate positions
Height of the hue selector DOM node, used to calc offsets so that selection
is center of the image node.
Height of the saturation selector DOM node, used to calc offsets so that selection
is center of the image node.
Width of the saturation selector DOM node, used to calc offsets so that selection
is center of the image node.
Default color for this component. Only hex values are accepted as incoming/returned
values. Adjust this value with <code>.attr</code>, eg: dijit.byId("myPicker").attr("value", "#ededed");
to cause the points to adjust and the values to reflect the current color.
The node to attach the data presentation to.
kwArgs: Object (see above)
the type of presentation to be applied at the DOM attach point.
This can be 'chart', 'legend', 'grid', 'title', 'footer'. The
default type is 'chart'.
the type of chart to display. This can be 'clusteredbars',
'areas', 'stackedcolumns', 'stackedbars', 'stackedareas',
'lines', 'hybrid'. The default type is 'bar'.
true if the chart independant axis should be reversed.
if an object is supplied, then the chart bars or columns will animate
into place. If the object contains a field 'duration' then the value
supplied is the duration of the animation in milliseconds, otherwise
a default duration is used. A boolean value true can alternatively be
supplied to enable animation with the default duration.
The default is null (no animation).
the frequency of label annotations to be included on the
independent axis. 1=every label. 0=no labels. The default is 1.
tooltip: String | Function
a string pattern defining the tooltip text to be applied to chart
data points, or a function which takes a single parameter and returns
the tooltip text to be applied to chart data points. The string pattern
will have the following substitutions applied:
{0} - the type of chart element ('bar', 'surface', etc)
{1} - the name of the data series
{2} - the independent axis value at the tooltip data point
{3} - the series value at the tooltip data point point
The function, if supplied, will receive a single parameter exactly
as per the dojox.charting.action2D.Tooltip class. The default value
is to apply the default tooltip as defined by the
dojox.charting.action2D.Tooltip class.
| Number
true if the legend should be rendered horizontally, or a number if
the legend should be rendered as horizontal rows with that number of
items in each row, or false if the legend should be rendered
vertically (same as specifying 1). The default is true (legend
rendered horizontally).
theme: String|Theme
a theme to use for the chart, or the name of a theme.
chartNode: String|DomNode
an optional DOM node or the id of a DOM node to receive a
chart presentation of the data. Supply only when a chart is
required and the type is not 'chart'; when the type is
'chart' this property will be set to the widget attach point.
legendNode: String|DomNode
an optional DOM node or the id of a DOM node to receive a
chart legend for the data. Supply only when a legend is
required and the type is not 'legend'; when the type is
'legend' this property will be set to the widget attach point.
gridNode: String|DomNode
an optional DOM node or the id of a DOM node to receive a
grid presentation of the data. Supply only when a grid is
required and the type is not 'grid'; when the type is
'grid' this property will be set to the widget attach point.
titleNode: String|DomNode
an optional DOM node or the id of a DOM node to receive a
title for the data. Supply only when a title is
required and the type is not 'title'; when the type is
'title' this property will be set to the widget attach point.
footerNode: String|DomNode
an optional DOM node or the id of a DOM node to receive a
footer presentation of the data. Supply only when a footer is
required and the type is not 'footer'; when the type is
'footer' this property will be set to the widget attach point.
chartWidget: Object
the chart widget, if any
legendWidget: Object
the legend widget, if any
gridWidget: Object
the grid widget, if any
An HTML-capable Dialog widget with advanced sizing
options, animated show/hide and other useful options.
This Dialog is also very easy to apply custom styles to.
It works identically to a `dijit.Dialog` with several
additional parameters.
If true, fix the size of the dialog to the Viewport based on
viewportPadding value rather than the calculated or natural
stlye. If false, base the size on a passed dimension attribute.
Eitherway, the viewportPadding value is used if the the content
extends beyond the viewport size for whatever reason.
If sizeToViewport="true", this is the amount of padding in pixels to leave
between the dialog border and the viewport edge.
This value is also used when sizeToViewport="false" and dimensions exceeded
by dialog content to ensure dialog does not go outside viewport boundary
A two-element array of [widht,height] to animate the Dialog to if sizeToViewport="false"
Defaults to [300,300]
An easing function to apply to the sizing animation.
Time (in ms) to use in the Animation for sizing.
To be passed to dojox.fx.sizeTo, one of "chain" or "combine" to effect
the animation sequence.
Toogle to show or hide the Title area. Can only be set at startup.
Make the pane draggable. Differs from dijit.Dialog by setting default to false
simply over-ride the default from dijit.Dialog
If true, this Dialog instance will be truly modal and prevent closing until
explicitly told to by calling hide() - Defaults to false to preserve previous
behaviors.
resets so next show loads new href
url to the content you want to show, must be within the same domain as your mainpage
1. checks if content already loaded
2. if not, sends XHR to download new data
false if the contents are yet to be loaded from the HTTP request
location from where to fetch the contents
contents to diplay in the tooltip. Initialized to a loading icon.
Cache content retreived externally
The feed is displayed as
an unordered list of links. When a link is hovered over
by the mouse, it displays a summary in a tooltip.
Specifies whether the feed is to be loaded from the same domain as the
page, or a remote domain. If local is true, then the feed must be an
Atom feed. If it is false, it can be an Atom or RSS feed.
The number of results to display from the feed.
The URL of the feed to load. If this is different to the domain
of the HTML page, local should be set to false.
If true, when a link is clicked it will open in a new window.
If false, it will not.
If true, only a single item can be expanded at any given time.
It provides form items that the user can use to change the URL
for a feed to load into the FeedPortlet.
There are two forms that it can take. <br>
The first is to display a text field, with Load and Cancel buttons,
which is prepopulated with the enclosing FeedPortlet's URL.
If a <select> DOM node is used as the source node for this widget,
it displays a list of predefined URLs that the user can select from
to load into the enclosing FeedPortlet.
An array of JSON object specifying URLs to display in the
PortletFeedSettings object. Each object contains a 'url' and 'label'
attribute, e.g.
[{url:'http:google.com', label:'Google'}, {url:'http://dojotoolkit.org', label: 'Dojo'}]
The selected URL. Defaults to zero.
The template to be used to construct the widget.
Our file separator - it will be guessed if not set
The top directory string - it will be guessed if not set
the attribute to read for finding our parent directory
the attribute to read for getting the full path of our file
or int
Set this to a sane number - since we expect to mostly be using the
dojox.data.FileStore - which doesn't like loading lots of items
all at once.
whether or not we allow selection of directories - that is, whether or
our value can be set to a directory.
whether or not we allow selection of files - that is, we will disable
the file entries.
width of menu item (in pixels) in it's dormant state (when the mouse is far away)
height of menu item (in pixels) in it's dormant state (when the mouse is far away)
width of menu item (in pixels) in it's fully enlarged state (when the mouse is directly over it)
height of menu item (in pixels) in it's fully enlarged state (when the mouse is directly over it)
orientation of the menu, either "horizontal" or "vertical"
toggle to enable additional listener (window scroll) if FisheyeList is in a fixed postion
if true, don't start enlarging menu items until mouse is over an image;
if false, start enlarging menu items as the mouse moves near them.
controls how much reaction the menu makes, relative to the distance of the mouse from the menu
padding (in pixels) betweeen each menu item
controls the border that the menu items don't expand past;
for example, if set to "top", then the menu items will drop downwards as they expand.
values
"center", "left", "right", "top", "bottom".
controls were the labels show up in relation to the menu item icons
values
"center", "left", "right", "top", "bottom".
pathname to image file (jpg, gif, png, etc.) of icon for this menu item
label to print next to the icon, when it is moused-over
will be set to the id of the orginal div element
A Simple FisheyeList-like widget which (in the interest of
performance) relies on well-styled content for positioning,
and natural page layout for rendering.
use position:absolute/relative nodes to prevent layout
changes, and use caution when seleting properties to
scale. Negative scaling works, but some properties
react poorly to being set to negative values, IE being
particularly annoying in that regard.
quirk: uses the domNode as the target of the animation
unless it finds a node class="fisheyeTarget" in the container
being turned into a FisheyeLite instance
The Time (in ms) to run the hide animation
An object of "property":scale pairs, or "property":{} pairs.
defaults to font-size with a scale of 2.75
If a named property is an integer or float, the "scale multiplier"
is used. If the named property is an object, that object is mixed
into the animation directly. eg: height:{ end:20, units:"em" }
Sometimes, you need to specify a unit. Should be part of
properties attrib, but was trying to shorthand the logic there
location to the icon used.
string to use for progress loading
true to display a fixed loading message in TR cornder, false to unly provide
"Loader" topic to subscribe to for your own custom loading message.
time in ms to toggle in/out the visual load indicator
distance in px from the mouse pointer to show attachToPointer avatar
The url of the previous page icon
The url of the next page icon
A dojo.data Data store
data store for items
Either "horizontal or "vertical" to define the direction the pages will slide
or vertical
A string describing where to put the Pager "current page" indicator. Options are
"leading" or "trailing". In the case of horiztonal orientation, "leading" indicates
positioned above the PageItems. In the case of vertical, "leading" indicates "before".
TODOC
Time in milliseconds to transition the pages
Spacing between items? TODOC
TODOC
The full dotted named of a Class to use for the internal Pager Items.
The numbers of items to display in each "Page"
true if the replace happened, false if not
Also call destroy on any removed items.
The array of items that were actually removed
If true, when the Portlet is resized, any child widgets
with a 'resize' method have that method called.
If true, a close button is placed in the title bar,
and the Portlet can be hidden. If false, the Portlet
cannot be closed.
An array of all the StackContainer widgets that this Portlet
is contained in. These are used to determine if the portlet
is visible or not.
Cache of the previous size of the portlet, used to determine
if the size has changed and if the child widgets should be
resized.
To remove the drag capability.
This widget should be placed inside a dojox.widget.Portlet widget.
It is used to set some preferences for that Portlet. It is essentially
a ContentPane, and should contain other widgets and DOM nodes that
do the real work of setting preferences for the portlet.
The CSS class to apply to the icon in the Portlet title bar that is used
to toggle the visibility of this widget.
The CSS class to apply to the icon in the Portlet title bar that is used
to toggle the visibility of this widget when the mouse hovers over it.
The size of the dialog to display. This defaults to [300, 300]
The Roller widget takes an unordered-list of items, and converts
them to a single-area (the size of one list-item, however you so choose
to style it) and loops continually, fading between items.
In it's current state, it requires it be created from an unordered (or ordered)
list, though can contain complex markup.
You can manipulate the `items` array at any point during the cycle with
standard array manipulation techniques.
The class "dojoxRoller" is added to the UL element for styling purposes.
Interval between rolls
Toggle to control starup behavior. Call .start() manually
if set to <code>false</code>
A CSS selector to be used by <code>dojo.query</code> to find the children
items in this widget. Defaults to "> li", finding only first-children
list-items in the list, allowing for embedded lists to occur.
Speed (in ms) to apply to the "in" animation (show the node)
Speed (in ms) to apply to the "out" animation (hide the showing node)
If populated prior to instantiation, is used as the Items over the children
Index of the the currently visible item in the list of items[]
A mixin class used to provide a way to automate a "stop on hover" behavior,
while still allowing for ambigious subclassing for custom animations.
Simply mix this class into a `dojox.widget.Roller` variant, and instantiate
as you would. The hover connection is done automatically.
The "hover" functionality is as such: Stop rotation while the mouse is over the
instance, and resume again once leaving. Even if autoStart is disabled, the widget
will start if a mouse enters and leaves the node in this case.
| array
| array
our template
The pane that immediately precedes ours
the store we must use
an array of (possibly not-yet-loaded) items to display in this.
If this array is null, then the query and query options are used to
get the top-level items to use. This array is also used to watch and
see if the pane needs to be reloaded (store notifications are handled)
by the pane
a query to pass to the datastore. This is only used if items are null
query options to be passed to the datastore
the width (in px) for this pane
our template
The menu that we will call addChild() on for adding items
or int
an object with key-value-pairs. The values are boolean, if true,
the key is added as a class, if false, it is removed.
The template to be used to construct the widget.
an additional class (or space-separated classes) to add for our widget
the store we must use
a query to pass to the datastore. This is only used if items are null
query options to be passed to the datastore
one ore more attributes that holds children of a node
the attribute to read for finding our parent item (if any)
The value that has been selected
Set to true if you want to call onExecute when an item is
double-clicked, false if you want to call onExecute yourself. (mainly
used for popups to control how they want to be handled)
or int
if set to true, then onItems will be called only *after* all items have
been loaded (ie store.isLoaded will return true for all of them). If
false, then no preloading will occur. If set to an integer, preloading
will occur if the number of items is less than or equal to the value
of the integer. The onItems function will need to be aware of handling
items that may not be loaded
if set to true, then buttons for "OK" and "Cancel" will be provided
The string to use for the OK button - will use dijit's common "OK" string
if not set
The string to use for the Cancel button - will use dijit's common
"Cancel" string if not set
the minimum pane width (in px) for all child panes. If they are narrower,
the width will be increased to this value.
A small, fast, extensible, awesome rotator that cycles, with transitions,
through panes (child nodes) displaying only one at a time and ties into
controllers used to change state.
The Rotator does not rely on dijit. It is designed to be as lightweight
as possible. Controllers and transitions have been externalized
so builds can be as optimized with only the components you want to use.
For best results, each rotator pane should be the same height and width as
the Rotator container node and consider setting overflow to hidden.
While the Rotator will accept any DOM node for a rotator pane, a block
element or element with display:block is recommended.
Note: When the Rotator begins, it does not transition the first pane.
subscribed topics:
[id]/rotator/control - Controls the Rotator
Parameters:
/*string*/ action - The name of a method of the Rotator to run
/*anything?*/ args - One or more arguments to pass to the action
published topics:
[id]/rotator/update - Notifies controllers that a pane or state has changed.
Parameters:
/*string*/ type - the type of notification
/*dojox.widget.Rotator*/ rotator
- the rotator instance
/*object?*/ params - params
declarative dojo/method events (per pane):
onBeforeIn - Fired before the transition in starts.
onAfterIn - Fired after the transition in ends.
onBeforeOut - Fired before the transition out starts.
onAfterOut - Fired after the transition out ends.
The name of a function that is passed two panes nodes and a duration,
then returns a dojo.Animation object. The default value is
"dojox.widget.rotator.swap".
Parameters for the transition. The string is read in and eval'd as an
object. If the duration is absent, the default value will be used.
Array of panes to be created in the Rotator. Each array element
will be passed as attributes to a dojo.create() call.
The title in the header
In the event a parent container is expecting a title="" attribute, set it for the parent
via title, and the title of this widget via heading="" ... assuming you want different
titles for each. eg: TabContainer, AccordionContainer, etc.
Toggle sort order based on this value.
A list of the selected <li> nodes at any given time.
toggle to enable/disable sorting
boolean indicating if the widget is in 'show' state or not.
An array of style names to clone.
The event to halt
Object of form: {v: Number, h: Number} where v is vertical scrollbar width
and h is horizontal scrollbar width.
The text to set.
The color to set the background underlay to in #XXXXXX format..
The text to set.
The indicator to use, either 'image' or 'text'.
The template string defining out the basics of the widget. No need for an external
file.
The node that is the translucent underlay for the
image that blocks access to the target.
The image node where we attach and define the image to display.
Which node to use as the center node, the image or the text node.
The URL to the image to center in the overlay.
Text for the ALT tag.
Text/HTML to display in the center of the overlay
This is used if image center is disabled.
Property to define if the image and its alt text should be used, or
a simple Text/HTML node should be used. Allowable values are 'image'
and 'text'.
Default is 'image'.
Flag to indicate if the overlay is displayed or not.
Handle to interval function that checks the target for changes.
The color to set the overlay. Should be in #XXXXXX form.
Default color for the translucent overlay is light gray.
Integer defining how long the show and hide effects should take.
Trap flag to ensure startup only processes once.
Wrapping div for the widget, also used for IE 7 in dealing with the
zoom issue.
Control that lets you specify if the zIndex for the overlay
should be auto-computed based off parent zIndex, or should be set
to a particular value. This is useful when you want to overlay
things in digit.Dialogs, you can specify a base zIndex to append from.
A container which controls a series of `dijit.TitlePane`s,
allowing one to be visible and hiding siblings. Behaves similarly
to a `dijit.layout.AccordionContainer` in that the children
are all stacked, though merges the TitlePane behavior of
variable height
A widget reference to add
An optional index or position to pass. defaults to "last"
the message. If this is a function, it will be called with this toaster widget as the only argument.
type of message; possible values in messageTypes enumeration ("message", "warning", "error", "fatal")
duration in milliseconds to display message before removing it. Widget has default value.
Name of topic; anything published to this topic will be displayed as a message.
Message format is either String or an object like
{message: "hello word", type: "error", duration: 500}
If message type isn't specified (see "messageTopic" parameter),
then display message as this type.
Possible values in messageTypes enumeration ("message", "warning", "error", "fatal")
Position from which message slides into screen, one of
["br-up", "br-left", "bl-up", "bl-right", "tr-down", "tr-left", "tl-down", "tl-right"]
Possible values for positionDirection parameter
Number of milliseconds to show message
Number of milliseconds for the slide animation, increasing will cause the Toaster
to slide in more slowly.
String used to separate messages if consecutive calls are made to setContent before previous messages go away
You can insert custom validations to trigger the UpgradeBar
to display. An evaluation of 'true' shows the bar (as this
version *is* less than it should be). Multiple validations
may be checked, although only the first in the list will be
displayed.
Markup and programmatic are supported. Markup is a little
cleaner, since a majority of the parameters are the HTML
snippets to be displayed. In markup, the validate code should
be an expression that will evaluate to true or false. This
expression is wrapped in a try/catch, so if it blows up, it
is assumed to be true and trigger the bar.
In programmtic, a function should be used that returns true
or false. You would need to use your own try/catch in that.
An array of objects that hold the criteria for upgrades.
message: String
The message to display in the bar. Can be HTML.
validate:Function
The expression to evaluate to determine if the
bar should show or not. Should be a simple expression
if used in HTML:
<div validate="!google.gears">
<div validate="dojo.isIE<8">
The HTML tip show when hovering over the close button.
The text link shown that when clicked, permanently dismisses
the message (sets a cookie). If this string is blank, this
link is not displayed.
Label override for the "Next" button.
Label override for the "Previous" button.
Label override for the "Cancel" button.
Label override for the "Done" button.
Name of function to call if user presses cancel button.
Cancel button is not displayed if function is not specified.
If true, disabled buttons are hidden; otherwise, they are assigned the
"WizardButtonDisabled" CSS class
An extended ContentPane with additional hooks for passing named
functions to prevent the pane from going either forward or
backwards.
If true, then can move back to a previous panel (by clicking the "Previous" button)
Name of function that checks if it's OK to advance to the next panel.
If it's not OK (for example, mandatory field hasn't been entered), then
returns an error message (String) explaining the reason. Can return null (pass)
or a Boolean (true == pass)
Name of function that is run if you press the "Done" button from this panel
using dojo.gfx (and thus either SVG or VML based on what is supported), this widget
builds a gauge component, used to display numerical data in a familiar format
usage:
this widget is not to be used alone. it is meant to be subclassed, such as
dojox.widget.BarGauge or dojox.widget.AnalogGauge
Sets the background using the given object. Must be the same 'type' of object
as the original background argument.
object in one of the two forms:
{'color': 'color-name'}
OR
(for a gradient:)
{'type': 'linear', 'colors': [{offset: 0, color:'#C0C0C0'}, {offset: 1, color: '#E0E0E0'}] }
If background is null or undefined, this will set the fill to this._backgroundDefault
Creates a range (colored area on the background of the gauge)
based on the given arguments.
A range is either a dojox.widget.gauge.Range object, or a object
with similar parameters (low, high, hover, etc.).
Creates a range (colored area on the background of the gauge)
based on the given arguments.
range:
A range is either a dojox.widget.gauge.Range object, or a object
with similar parameters (low, high, hover, etc.).
This method adds an indicator, such as a tick mark or needle,
to the bar graph.
A dojox.widget.gauge._Indicator or an object with similar parameters
(value, color, offset, etc.).
A dojox.widget.gauge._Indicator or an object with similar parameters
(value, color, offset, etc.).
The text to be drawn
The x coordinate at which to place the text
The y coordinate at which to place the text
align?: String
Indicates how to align the text
Valid value is 'right', otherwise text is left-aligned
vAlign?: String
Indicates how to align the text vertically.
Valid value is 'top', otherwise text is bottom-aligned
color?: String
Indicates the color of the text
font?: Object
A font object, generally of the following format:
{family: "Helvetica", style: "italic", variant: 'small-caps', weight: 'bold', size: "18pt"}
The text to remove.
The text to put in the tooltip.
The event object
The event object
The event object
The event object
The event object
width of the mark
length: The length of the mark
interval: The interval the ticks should be added on
color: The color of the mark and text
font: an object with any/all of the following parameters:
{family: "Helvetica", style: "italic", variant: 'small-caps', weight: 'bold', size: "18pt"}
the height of the gauge (default is 200)
the color of the background. This must be an object of one of two forms:
{'color': 'color-name'}
OR
(for a gradient:)
{'type': 'linear', 'x1': 0, 'x2': 0, 'y1': 0, 'y2': 200, 'colors': [{offset: 0, color:'#C0C0C0'}, {offset: 1, color: '#E0E0E0'}] }
The minimum value of the gauge. Normally not set explicitly, as it will be determined by
the ranges that are added.
The maximum value of the gauge. Normally not set explicitly, as it will be determined by
the ranges that are added.
background image for gauge (default is no image)
indicates whether to use given css classes (dojoxGaugeRangeXX)
to determine the color (and other style attributes?) of the ranges
this value should be the number of dojoxGaugeRange classes that are
defined, starting at dojoxGaugeRange1 (0 indicates falling to default
hardcoded colors)
indicates whether tooltips should be displayed for ranges, indicators, etc.
An object representing the tick marks that should be added to the gauge. Major tick marks have a text label
indicating the value. The object can have the following attributes (required are marked with a *):
offset: the distance from the 'center' of the gauge. Used differently for Analog vs. Bar
An object of the same format as majorTicks, indicating where the minor (label-less) marks should be placed
The font parameter is ignored if provided since minor tick marks have no text label.
Should be overridden by any extending classes and used to indicate what the 'default' indicator is.
This object is used as the indicator when creating tick marks or when an anonmyous object is passed into
addIndicator.
Set of default colors to color ranges with.
The SVG/VML surface that the shapes are drawn on. Can be accessed/used by indicators to draw themselves
indicates whether the text boxes showing the value of the indicator (as text
content) should be hidden or shown. Default is not hidden, aka shown.
a range widget, which has given properties. drawn by a _Gauge.
usage:
<script type="text/javascript">
dojo.require("dojox.widget.AnalogGauge");
dojo.require("dijit.util.parser");
</script>
...
<div dojoType="dojox.widget.AnalogGauge"
id="testGauge"
width="300"
height="200"
cx=150
cy=175
radius=125
image="gaugeOverlay.png"
imageOverlay="false"
imageWidth="280"
imageHeight="155"
imageX="12"
imageY="38">
<div dojoType="dojox.widget.gauge.Range"
low=5
high=10
hover="5 - 10"
></div>
<div dojoType="dojox.widget.gauge.Range"
low=10
high=20
hover="10 - 20"
></div>
</div>
the low value of the range
the high value of the range
the text to put in the tooltip for the gauge
the color of the range. This must be an object of one of two forms:
{'color': 'color-name'}
OR
(for a gradient:)
{'type': 'linear', 'colors': [{offset: 0, color:'#C0C0C0'}, {offset: 1, color: '#E0E0E0'}] }
for a circular gauge (such as an AnalogGauge), this dictates the size of the arc
an indicator widget, which has given properties. drawn by a gauge.
usage:
<script type="text/javascript">
dojo.require("dojox.widget.AnalogGauge");
dojo.require("dijit.util.parser");
</script>
...
<div dojoType="dojox.widget.AnalogGauge"
id="testGauge"
width="300"
height="200"
cx=150
cy=175
radius=125
image="gaugeOverlay.png"
imageOverlay="false"
imageWidth="280"
imageHeight="155"
imageX="12"
imageY="38">
<div dojoType="dojox.widget.gauge.Indicator"
value=17
type="arrow"
length=135
width=3
hover="Value: 17"
onDragMove="handleDragMove">
</div>
</div>
Indicates if the drawing should not be animated (rather than teh default, to animate)
The value (on the gauge) that this indicator should be placed at
The type of indicator to draw. Varies by gauge type. Some examples include
"line", "arrow", and "bar"
The color of the indicator.
The text label for the indicator.
The length of the indicator. In the above example, the radius of the AnalogGauge
is 125, but the length of the indicator is 135, meaning it would project beyond
the edge of the AnalogGauge
The width of the indicator.
The offset of the indicator
The string to put in the tooltip when this indicator is hovered over.
Keep this indicator at the front
indicates the easing function to be used when animating the of an indicator.
indicates how long an animation of the indicator should take
indicates whether the indicator's value can be changed. Useful for
a static target indicator. Default is false (that the value can be changed).
The title of the indicator, to be displayed next to it's input box for the text-representation.
Displays a series of controls that send actions to a Rotator or
AutoRotator. The Controller supports the following controls:
* Next pane
* Previous pane
* Play/Pause toggler
* Numbered tabs
* Titled tabs
* Information
You may specify any of these controls in any order. You may also
have multiple Controllers tied to a single Rotator instance.
The Controller's DOM node may also be styled for positioning or
other styled preferences.
A comma-separated list of commands. Valid commands are:
prev An icon button to go to the previous pane.
next An icon button to go to the next pane.
play/pause A play and pause toggle icon button.
info Displays the current and total panes. (ie "1 / 4")
# Displays a number button for each pane. (ie "1 2 3 4")
titles Displays each pane's title as a tab. (ie "Home Services Contact Blog")
The ThumbnailController will look at each of the rotator's panes and
only if the node is an <img> tag, then it will create an thumbnail of
the pane's image using the <img> tag's "thumbsrc" or "src" attribute.
The size of the thumbnails and the style of the selected thumbnail is
controlled using CSS.
An instance of a Rotator widget.
A class or full qualified class name
A key property of arguments to create a Wire
The class is loaded by dojo.require() and returned
by dojo.getObject().
A class name
A class
If 'args' specifies 'wireClass', it is used as a class or full
qualified class name to create a Wire with 'args' as arguments.
Otherwise, a Wire class is determined by other proeprties of 'args'
checking if 'args' specifies a key property for a Wire class.
If no key property found, the default Wire class is used.
Arguments to create a Wire
A Wire
If the specified object is a Wire, true is returned.
Otherwise, false is returned.
An object to check
True if the object is a Wire, otherwise false
If 'source' and/or 'target' are not Wires, Wires are created with
them as arguments.
A value is got through the source Wire and set through the target
Wire.
'defaultObject' is passed to Wires as a default root object.
If 'defaultTargetObject' is specified, it is passed to the target
Wire as a default root object, instead of 'defaultObject'.
A Wire or arguments to create a Wire for a source value
A Wire or arguments to create a Wire for a target value
defaultTargetObject; Optional default root objects passed to Wires
If 'trigger' specifies 'topic', the topic is subscribed to transer
a value on the topic.
Otherwise, the event specified to 'event' of 'trigger' is listened
to transfer a value.
On the specified event or topic, transfer() is called with
'source', 'target' and the arguments of the event or topic (as
default root objects).
An event or topic to trigger a transfer
A Wire or arguments to create a Wire for a source value
A Wire or arguments to create a Wire for a target value
A connection handle for disconnect()
If 'handle' has 'topic', the topic is unsubscribed.
Otherwise, the listener to an event is removed.
A connection handle returned by connect()
This class has multiple child Wires for object properties or array
elements.
When an object with Wires is specified to 'children' property, they
are used to get or set an object with property values.
When an array of Wiares is specified to 'children' property, they
are used to get or set an array with element values.
If object properties or array elements specified in 'children'
property are not Wires, Wires are created from them as
arguments, with 'parent' property set to this Wire instance.
Arguments to initialize properties
children:
An object or array containing child Wires
This method calls getValue() method of the child Wires with
'object' argument and returns an object with the values as
properties or an arary of the values as elements.
A root object
An object or array with values
A root object
An object or array with values to set
'object'
If object properties or array elements specified in 'children'
argument are not Wires, Wires are created from them as
arguments, with 'parent' property set to this Wire instance.
An object or array containing child Wires
This class accesses item attributes of data stores with a dotted
notation of attribute names specified to 'attribute' property,
using data APIs of a data store specified to 'dataStore' property.
The root object for this class must be an item of the data store.
Intermediate attribute names in the dotted notation specify
attributes for child items, which are used for repeated calls to
data APIs until reached to a descendant attribute.
Attribute names may have an array index, such as "a[0]", to
identify an array element of the attribute value.
If 'dataStore' property is not specified, but 'parent' property
is specified, 'dataStore' property is copied from the parent.
Arguments to initialize properties
This method uses a root item passed in 'object' argument and
'attribute' property to call getValue() method of
'dataStore'.
If an attribute name have an array suffix ("[]"), getValues()
method is called, instead.
If an index is specified in the array suffix, an array element
for the index is returned, instead of the array itself.
A root item
A value found, otherwise 'undefined'
This method uses a root item passed in 'object' argument and
'attribute' property to identify an item.
Then, setValue() method of 'dataStore' is called with a leaf
attribute name and 'value' argument.
If an attribute name have an array suffix ("[]"), setValues()
method is called, instead.
If an index is specified in the array suffix, an array element
for the index is set to 'value', instead of the array itself.
A root item
A value to set
'object', or 'undefined' for invalid attribute
This method uses an item passed in 'item' argument and
'attribute' argument to call getValue() method of 'dataStore'.
If an attribute name have an array suffix ("[]"), getValues()
method is called, instead.
If an index is specified in the array suffix, an array element
for the index is returned, instead of the array itself.
An item
attribute
An attribute name
A value found, otherwise 'undefined'
This method uses an item passed in 'item' argument and
'attribute' argument to call setValue() method of 'dataStore'
with 'value' argument.
If an attribute name have an array suffix ("[]"), setValues()
method is called, instead.
If an index is specified in the array suffix, an array element
for the index is set to 'value', instead of the array itself.
An item
An attribute name
A value to set
data store
attribute:
A dotted notation to a descendant attribute
This class has multiple child Wires for object properties or array
elements of a table row.
The root object for this class must be an array.
When an object with Wires is specified to 'columns' property, they
are used to get a row object with property values.
When an array of Wires is specified to 'columns' property, they
are used to get a row array with element values.
The row values are returned in an array.
This class only supports getValue(), but not setValue().
If object properties or array elements specified in 'columns'
property are not Wires, Wires are created from them as
arguments, with 'parent' property set to this Wire instance.
Arguments to initialize properties
columns:
An object or array containing child Wires for column values
This method iterates over an array specified to 'object'
argument and calls getValue() method of the child Wires with
each element of the array to get a row object or array.
Finally, an array with the row objects or arrays are retuned.
A root array
An array of table row value
This method calls getValue() method of the child Wires to
create a row object or array.
An array or object for a table row
This class has multiple child Wires for text segment values.
Wires in 'segments' property are used to get text segments and
values are concatenated with an optional delimiter string specified
to 'delimiter' property.
If array elements specified in 'segments' are not Wires, Wires
are created from them as arguments, with 'parent' property set
to this Wire instance.
Arguments to initialize properties
segments:
An array containing child Wires for text segment values
This method calls getValue() method of the child Wires wuth
'object' argument and concatenate the values with 'delimiter'
property to return.
arg:
A root object
A concatinated text
This method add a text segment specified to 'segment' argument
to a base text specified to 'text', with 'delimiter' property.
A base text
A text segment to add
A concatinated text
delimiter string
This class has multiple child Wires for tree nodes, their title and
child nodes.
The root object for this class must be an array.
'node' Wires in 'nodes' property is used to identify an object
representing a node.
'title' Wires in 'nodes' property is used to get the title string
of a node.
'children' Wires in 'nodes' property is used to iterate over child
node objects.
The node values are returned in an array as follows:
[
{title: title1,
children: [
{title: title2,
child: ...},
{title: title3,
child: ...},
...
]},
...
]
This class only supports getValue(), but not setValue().
If object properties ('node', 'title' and 'children') of array
elements specified in 'nodes' property are not Wires, Wires are
created from them as arguments, with 'parent' property set to
this Wire instance.
Arguments to initialize properties
nodes:
An array containing objects for child Wires for node values
This method iterates over an array specified to 'object'
argument and calls getValue() method of 'node' Wires with each
element of the array to get object(s) that represetns nodes.
(If 'node' Wires are omitted, the array element is used for
further processing.)
Then, getValue() method of 'title' Wires are called to get
title strings for nodes.
(If 'title' Wires are omitted, the objects representing nodes
are used as title strings.)
And if an array of objects with 'node' and 'title' Wires is
specified to 'children', it is used to gather child nodes and
their title strings in the same way recursively.
Finally, an array of the top-level node objects are retuned.
A root array
An array of tree node values
If 'node' or 'title' properties of array elements specified in
'children' argument are not Wires, Wires are created from them
as arguments, with 'parent' property set to this Wire instance.
If an array element has 'children' property, this method is
called recursively with it.
An array of objects containing child Wires
This method calls getValue() method of 'node' Wires with
'object' argument to get object(s) that represents nodes.
(If 'node' Wires are omitted, 'object' is used for further
processing.)
Then, getValue() method of 'title' Wires are called to get
title strings for nodes.
(If 'title' Wires are omitted, the objects representing nodes
are used as title strings.)
And if an array of objects with 'node' and 'title' Wires is
specified to 'children', it is used to gather child nodes and
their title strings in the same way recursively.
Finally, an array of node objects are returned.
An object
An object with child Wires
This class accesses a property of an object with a dotted notation
specified to 'property' property, such as "a.b.c", which identifies
a descendant property, "object.a.b.c".
Property names in the dotted notation may have an array index, such
as "a[0]", to identify an array element, literally, "object.a[0]".
When a notation start with an array index, such as "[0].a", it
specifies an array element of the root object (array),
"object[0].a".
This class also serves as a base class for other Wire classes,
preparing a root object and converting a return value, so that
sub-classes just can implement _getValue() and _setValue() called
from getValue() and setValue() implemented by this calss.
If 'converter' property is specified and is a string for
a converter class, an instanceof the converter class is
created.
Arguments to initialize properties
object:
A root object (or another Wire to access a root object)
property:
A dotted notation to a descendant property
type:
A type of the return value (for the source Wire)
This method first determins a root object as follows:
1. If 'object' property specified,
1.1 If 'object' is a Wire, its getValue() method is called to
obtain a root object.
1.2 Otherwise, use 'object' as a root object.
2. Otherwise, use 'defaultObject' argument.
3. If 'property' is specified, it is used to get a property
value.
Then, if a sub-class implements _getValue() method, it is
called with the root object to get the return value.
Otherwise, the root object (typically, a property valye) is
used for the return value.
Finally, if 'type' property is specified, the return value is
converted to the specified primitive type ("string", "number",
"boolean" and "array").
If 'converter' property is specified, its convert() method is
called to convert the value.
A default root object
A value found
This method first determins a root object as follows:
1. If 'object' property specified,
1.1 If 'object' is a Wire, its getValue() method is called to
obtain a root object.
1.2 Otherwise, use 'object' as a root object.
2. Otherwise, use 'defaultObject' argument.
3. If 'property' is specified, it is used to get a property
value.
Then, if a sub-class implements _setValue() method, it is
called with the root object and 'value' argument to set
the value.
Otherwise, 'value' is set to a property specified with
'property' property.
If the root object is undefined and 'object' property is a Wire
and a new object is created and returned by _setValue() it is
set through 'object' (setValue() method).
A value to set
A default root object
A value for 'property' of 'object' is returned.
If 'property' ends with an array index, it is used to indentify
an element of an array property.
If 'object' implements getPropertyValue(), it is called with
'property' to obtain the property value.
If 'object' implements a getter for the property, it is called
to obtain the property value.
A default root object
A property name
A value found, otherwise 'undefined'
'value' is set to 'property' of 'object'.
If 'property' ends with an array index, it is used to indentify
an element of an array property to set the value.
If 'object' implements setPropertyValue(), it is called with
'property' and 'value' to set the property value.
If 'object' implements a setter for the property, it is called
with 'value' to set the property value.
An object
A property name
A value to set
target object to set the property of.
target object to set the property of.
target object to set the property of.
converter object (or class name) to convert the return
value (for the source Wire)
This class accesses XML nodes or value with a simplified XPath
specified to 'path' property.
The root object for this class must be an DOM document or element
node.
"@name" accesses to an attribute value of an element and "text()"
accesses to a text value of an element.
The hierarchy of the elements from the root node can be specified
with slash-separated list, such as "a/b/@c", which specifies
the value of an attribute named "c" of an element named "b" as
a child of another element named "a" of a child of the root node.
'args' is just mixed in with no further processing.
Arguments to initialize properties
path:
A simplified XPath to an attribute, a text or elements
This method first uses a root node passed in 'object' argument
and 'path' property to identify an attribute, a text or
elements.
If 'path' starts with a slash (absolute), the first path
segment is ignored assuming it point to the root node.
(That is, "/a/b/@c" and "b/@c" against a root node access
the same attribute value, assuming the root node is an element
with a tag name, "a".)
A root node
A value found, otherwise 'undefined'
This method first uses a root node passed in 'object' argument
and 'path' property to identify an attribute, a text or
elements.
If an intermediate element does not exist, it creates
an element of the tag name in the 'path' segment as a child
node of the current node.
Finally, 'value' argument is set to an attribute or a text
(a child node) of the leaf element.
A root node
A value to set
If 'exp' starts with '@', an attribute value of the specified
attribute is returned.
If 'exp' is "text()", a child text value is returned.
Otherwise, an array of child elements, the tag name of which
match 'exp', is returned.
A node
An expression for attribute, text or elements
A value found, otherwise 'undefined'
If 'exp' starts with '@', 'value' is set to the specified
attribute.
If 'exp' is "text()", 'value' is set to a child text.
A node
An expression for attribute or text
A value to set
A child element of the tag name specified with 'name' is
returned.
If 'name' ends with an array index, it is used to pick up
the corresponding element from multiple child elements.
A parent node
A tag name
A child node
If 'node' is specified, a DOM document of the node is returned.
Otherwise, a DOM document is created.
A DOM document
This method obtains an object by an ID of a widget or an DOM
element.
If 'source' specifies a dotted notation to its property, a Wire is
used to get the object property.
If 'source' starts with "arguments", 'args' is used as a root
object for the Wire.
A string to specify an object and its property
An optional arguments array
A value
This method stores a value by an ID of a widget or an DOM
element with a dotted notation to its property, using a Wire.
A string to specify an object and its property
A value
This widget represents a controller task to be run when an event
(a function) or a topic is issued.
Sub-classes must implement _run() method to implement their tasks.
'trigger' specifies an event scope, an ID of a widget or an DOM
element, or its property with the optional dotted notation.
If this widget has child ActionFilter widgets, their filter()
methods are called with the arguments to the event or the topic.
If one of filter() methods returns false, run() won't be invoked.
This widget also can serve as a composite task to run child
Actions on an event or a topic specified to this widget.
See _connect().
If 'triggerEvent' and 'trigger' are specified, connect() is
used to set up run() to be called on the event.
If 'triggerTopic' is specified, subscribe() is used to set up
run() to be called on the topic.
If 'triggerEvent' and 'trigger' are specified, disconnect() is
used to set up run() not to be called on the event.
If 'triggerTopic' is specified, unsubscribe() is used to set up
run() not to be called on the topic.
This method calls filter() method of child ActionFilter
widgets.
If one of them returns false, this method returns.
Otherwise, _run() method is called.
If this widget has child Action widgets, their run() methods
are called.
event scope
event (function) name
topic name
This base class checks a required property specified with
'required' attribute.
If 'message' is specified, the message is set to a property
specified with 'error'.
Subclasses may implement their own filter() method.
If a value is undefined for a property, specified with
'required', this method returns false.
If the value for a property is defined, but there isn't a requiredValue for it
then any non-false value will cause the method to return true.
if requiredValue is set, then filter compares that value with the value from
the required property and returns true if and only if they match.
The type option just allows for a way to convert the required property values
into a proper form for comparison (boolean, number, etc).
If 'message' is specified, it is set to a proeprty specified
with 'error' or shown with alert().
If 'required' starts with "arguments", a property of
the method arguments are checked.
True if a required property is specified (and if requiredValue is specified,
that they match), otherwise false
property required
A specific value the property is required to have. If this isn't provided
than any non-false/non-null value of the required propery will cause this filter
to pass.
A specific type to compare the values as (if requiredValue is set)
Valid values for type are boolean, int, string. Default is string.
error message to emit if the filter doesn't execute due to property mismatch.
property to store an error due to property mismatch.
This widget represents an object with '_properties' property.
If child 'DataProperty' widgets exist, they are used to initialize
propertiy values of '_properties' object.
See _initializeProperties().
If this widget has child DataProperty widgets, their getValue()
methods are called and set the return value to a property
specified by 'name' attribute of the child widgets.
A boolean to reset current properties
This method returns the value of a property, specified with
'property' argument, in '_properties' object.
A property name
A property value
This method stores 'value' as a property, specified with
'property' argument, in '_properties' object.
A property name
A property value
Attributes of this widget are used to add a property to the parent
Data widget.
'type' attribute specifies one of "string", "number", "boolean",
"array", "object" and "element" (DOM Element)
(default to "string").
If 'type' is "array" or "object", child DataProperty widgets are
used to initialize the array elements or the object properties.
If 'type' is specified, 'value' attribute is converted to
the specified type and returned.
Otherwise, 'value' attribute is returned as is.
A property value
property name
property type name
property value
This widget represents a data store of 'storeClass' attribute.
See _createStore().
A data store
See dojo.data.api.Read.getFeatures().
A features object
See dojo.data.api.Read.fetch().
A request object
A request object
See dojo.data.api.Write.save().
A save arguments object
See dojo.data.api.Write.newItem().
A new item arguments object
A new item
See dojo.data.api.Write.deleteItem().
A boolean
See dojo.data.api.Write.revert().
A boolean
class name of a data store
This widget represents a controller task to invoke a method or
publish a topic when an event (a function) or a topic is issued.
If 'topic' is specified, the topic is published with arguments
specified to 'parameters'.
If 'method' and 'object' are specified, the method is invoked
with arguments specified to 'parameters' and set the return
value to a property specified to 'result'.
'object', 'parameters' and 'result' can specify properties of
a widget or an DOM element with the dotted notation.
If 'parameters' are omitted, the arguments to this method are
passed as is.
If 'result' attribute is specified, the result object also set
to the specified property.
The return value of a method or undefined for a topic
If 'error' attribute is specified, the error object also set to
the specified property.
The exception or error occurred
This method retunrs an array of arguments specified by
'parameters' attribute, a comma-separated list of IDs and
their properties in a dotted notation.
If 'parameters' are omitted, the original arguments are
used.
Arguments to a trigger event or topic
scope of a method to invoke
name of a method to invoke
name of a topic to publish
for the method or the topic
property to store a return value of the method call
property to store an error on the method call
This widget represents a service defined by a service description
specified with 'url' attribute.
If 'serviceType' and 'serviceUrl' attributes are specified, 'url'
attribute can be omitted.
See _createHandler().
A service handler
method name
array parameters
URL to a service description
URL to a service
service type
service handler class name
This class serves as a base REST service.
Sub-classes may override _getContent() and _getResult() to handle
specific content types.
A service is called with a URL generated by _getUrl() and
an HTTP method specified with 'method'.
For "POST" and "PUT", a content is generated by _getContent().
When data is loaded, _getResult() is used to pass the result to
Deferred.callback().
method name
array of parameters
URL for the method
If 'method' is "GET" or "DELETE", a query string is generated
from a query object specified to the first parameter in
'parameters' and appended to 'url'.
If 'url' contains variable seguments ("{parameter_name}"),
they are replaced with corresponding parameter values, instead.
A method name
An array of parameters
A base URL
A URL
If 'method' is "POST" or "PUT", the first parameter in
'parameters' is returned.
A method name
An array of parameters
A request content
A response data is returned as is.
A response data returned by a service
A result object
This class provides XML handling for a REST service.
If 'method' is "POST" or "PUT", the first parameter in
'parameters' is used to generate an XML content.
A method name
An array of parameters
A request content
A response data (XML Document) is returned wrapped with
XmlElement.
A response data returned by a service
A result object
This class provides JSON handling for a REST service.
If 'method' is "POST" or "PUT", the first parameter in
'parameter' is used to generate a JSON content.
A method name
An array of parameters
A request content
This widget represents a controller task to transfer a value from
a source to a target, through a source and a target Wires, when
an event (a function) or a topic is issued.
If this widget has child ChildWire widgets, their _addWire()
methods are called to add Wire arguments to a source or a target
Wire.
First, Wires for a source and a target are created from attributes.
Then, a value is obtained by getValue() of the source Wire is set
by setValue() of the target Wire.
The arguments to this method is passed to getValue() and setValue()
of Wires, so that they can be used to identify the root objects off
the arguments.
Arguments object for a source or a target Wire, specified by
'which' argument, are build from corresponding attributes,
including '*Store' (for 'dataStore'), '*Attribute'
(for 'attribute), '*Path' (for 'path'), 'type' and 'converter'.
'source' or 'target' attribute is parsed as:
"object_id.property_name[.sub_property_name...]"
If 'source' or 'target' starts with "arguments", 'object'
argument for a Wire is set to null, so that the root object is
given as an event or topic arguments.
If this widget has child ChildWire widgets with a corresponding
'which' attribute, their _addWire() methods are called to add
additional Wire arguments and nested Wire is created,
specifying the Wire defined by this widget to 'object' argument.
Which Wire arguments to build, "source" or "target"
Wire arguments object
source object and/or property
data store for a source data item
attribute of a source data item
simplified XPath to a source property of an XML element
type of the value to be transferred
class name of a converter for the value to be transferred
target object and/or property
data store for a target data item
attribute of a target data item
simplified XPath to a target property of an XML element
Attributes of this widget are used to add a child Wire to
a composite Wire of the parent Transfer widget.
If 'name' attribute is specified, a child Wire is added as
the named property of 'children' object of 'args'.
Otherwise, a child Wire is added to 'children' array of 'args'.
A parent Transfer widget
Wire arguments
Arguments object for a child Wire are build from attributes,
including 'object', 'property', 'type', 'converter',
'attribute' and 'path'.
A parent Transfer widget
Wire arguments object
Wire to add a child Wire, "source" or "target", default to
"source"
root object for the value
property for the value
type of the value
class name of a converter for the value
data item attribute for the value
simplified XPath for the value
composite property name
Attributes of this widget are used to add a column Wire to
a TableAdapter of the parent Transfer widget.
If 'column' attribute is specified, a column Wire is added as
the named property of 'columns' object of 'args'.
Otherwise, a column Wire is added to 'columns' array of 'args'.
A parent Transfer widget
Wire arguments
column name
Attributes of this widget are used to add node Wires to
a TreeAdapter of the parent Transfer widget.
Node Wires are added to 'nodes' array of 'args'.
A parent Transfer widget
Wire arguments
Arguments object for 'node' Wire are build from attributes,
including 'object', 'property', 'type', 'converter',
'attribute' and 'path'.
Arguments object for 'title' Wire are build from another set of
attributes, 'titleProperty', 'titleAttribute' and 'titlePath'.
If this widget has child NodeWire widgets, their _getWires()
methods are called recursively to build 'children' array of
'args'.
A parent Transfer widget
Wire arguments object
property for the node title
data item attribute for the node title
simplified XPath for the node title
Attributes of this widget are used to add a segment Wire to
a TextAdapter of the parent Transfer widget.
A segment Wire is added to 'segments' array of 'args'.
If 'parent' has 'delimiter' attribute, it is used for
'delimiter' property of 'args'.
A parent Transfer widget
Wire arguments
This class represents an XML element.
An XML element or a tag name
If 'property' starts with '@', the attribute value is returned.
If 'property' specifies "text()", the value of the first child
text is returned.
Otherwise, child elements of the tag name specified with
'property' are returned.
A property name
A property value
If 'property' starts with '@', 'value' is set to the attribute.
If 'property' specifies "text()", 'value' is set as the first
child text.
If 'value' is a string, a child element of the tag name
specified with 'property' is created and 'value' is set as
the first child text of the child element.
Otherwise, 'value' is set to as child elements.
A property name
A property value
A value of the first text child of the element is returned.
A value of the first text child of the element
An object with properties for child elements, attributes and
text is returned.
An object representation of the element
If 'element' is specified, a DOM document of the element is
returned.
Otherwise, a DOM document is created.
A DOM document
Optional text to create the document from. If not provided, an empty XML document will be created.
If str is empty string "", then a new empty document will be created.
Optional mimetype of the text. Typically, this is text/xml. Will be defaulted to text/xml if not provided.
Implementation of the DOM Level 3 attribute; scan node for text
This function can also update the text of a node by replacing all child
content of the node.
The node to get the text off of or set the text on.
Optional argument of the text to apply to the node.
Removes all children of node and appends newChild. All the existing
children will be destroyed.
The node to modify the children on
The children to add to the node. It can either be a single Node or an
array of Nodes.
The node to remove all the children from.
The node from which to generate the XML text representation.
used when 'ask' attribute is absent on a roster item
number of iframes to use for transmission
function called when the first iframe is
loaded. Generally used to signal when to send
login information
rid of the message being sent.