The following browsers have been tested and are supported in this release. If a browser version is not listed as supported, it still may work, especially on browsers with rapid release cycles (Chrome, Firefox). Future minor releases of dojo might include fixes to support future releases of these browsers, but we cannot guarantee it.

Dojo now fully supports asynchronous loading of AMD modules. Asynchronous loading mode can be entered by setting the dojo config of “async” to true:

<script data-dojo-config="async: true"src="dojo.js"></script>

Note that in async mode many modules which were implicitly loaded before now need to be explicitly loaded. Be sure to list all the modules you are directly using in the require() list (including dojo/parser when using parseOnLoad). For example:

Note that many core and dijit modules have been converted to use minimal dependencies in 1.7, to support lighter footprint when used in conjunction with async loading, and AMD module format and async loading is now a fully supported feature in 1.7; however, as part of this effort, exported objects returned from dojo core modules should be treated as subject to change. Work on tightening exported module return values/APIs will continue through 1.8.

Some existing Dojo <1.7 modules were designed such that they only work in sync loading mode. These modules continue to be supported in synchronous mode using the compatibility support but are not supported in asynchronous loading mode. The community is looking at potential replacements in the 2.0 time frame:

DTL (dojox.dtl - Django Templating): While the dojox.dtl engine implementation is written with the assumption of a synchronous loader, the module has been updated so that it is compatible with the amd loader async mode, provided all tags and filters libraries are explicitly required. This restriction applies to both user-defined libraries and the dojox.dtl default ones defined (in dojox/dtl/tag and dojox/dtl/filter).

The following table lists the default tag libraries and their corresponding tags:

Note Also because of the way the dependencies are done for Dijit, if you do a build of code that includes a legacy layer that includes Dijits, you must explicitly include dijit._base. For example, your layer should look something like this:

This also sheds some of the legacy keypress event handling code (best practice is to use keydown instead), and reduces code size.

This API is planned to replace the existing dojo.connect API in Dojo 2.0. The arguments passed to event handlers for non-DOM events and the event names used for non-DOM events are expected to change in Dojo 2.0, so Dojo 1.x applications that connect to non-DOM events should not necessarily migrate existing code to dojo/on if it is being done in an attempt to be future-proof.

This new module provides access to the DOM querying functionality (like dojo.query). This module can also be loaded with alternate selector engines like Sizzle, Slick, or the new Dojo lite query selector engine or with minimum CSS compliance levels for auto selector engine selection. In asynchronous mode (see new Dojo config settings), when dojo/main is not loaded, dojo/query will load the lite engine to use native browser querySelectAll, and only load the full acme selector engine if needed. dojo/query works with the new has() branching functionality to make it easy to create browser specific builds with the minimal selector engine needed for the browser.

This module has been updated to broadcast notifications originating from the underlying object store if that store is “Observable”. If the underlying object store provides an observe() method on results (usually be wrapping with dojo.store.Observable), than the dojo/data/ObjectStore wrapper can listen to changes in the object store and send out dojo.data notification events.

Note there is no support for deprecated attribute prop as an attribute of the type="dojo/watch" script tag. The parser only recognizes the attribute data-dojo-prop.

Reminder: when operating in asynchronous mode, you need to explicitly load dojo/parser in order for parseOnLoad:true to operate. (In non-async mode, it will be required automatically with a deprecation warning.) Technically, dojo/parser was never automatically loaded, but prior to 1.7, it would be transitively loaded in many cases, due to it being loaded by dijit/_Templated, which was relied upon by many widgets.

Dijit widgets should now “just work” on supported mobile devices, with the exception of the Editor widget. This is intended to allow web apps built for desktop browsers to continue to be functional when browsed on mobile devices.

For Dialog your app must set draggable=false in order for the [x] close icon (in the Dialog’s upper right hand corner) to work. This limitation will be removed in a future release.

A new mixin called _TemplatedMixin has been added. It’s lighter weight than _Templated and supports templated widgets which don’t have widgets in templates. New widgets should be built using _TemplatedMixin. Additionally, widgets that need the widgetsInTemplate functionality should also mixin _WidgetsInTemplateMixin.

The focus, place, and popup modules in dijit/_base have been promoted to dijit/, so they can be included explicitly by applications that don’t want to include all of dijit/_base.

There are a few API changes in the top level modules compared to the ones in dijit/_base (although for backwards compatibility the modules in dijit/_base maintain their old API):

Popup.around() (analogous to dijit.popup.placeAroundElement()) takes a position parameter like [“before”, “after”] rather than a set of tuples like {BL: “TL”, ...}. In other words, popup.around() replaces dijit.popup.placeAroundElement() but instead of dijit.getPopupAroundAlignment(xyz), just pass in xzy directly.

New zoom, pan, data indicator interactions have been committed in the action2d package. They allow users to interact with the chart using either mouse or touch gestures.

Various improvement to improve performances on particular on mobile devices (new enableCache parameter on most plot type to allow caching and reuse of gfx shapes)

use of AMD module format

Bidi text support has been added through two BidiSupport classes (one for dojox.charting, one for dojox.charting.widget). This classes need to be required by your application in order for Bidi text support to be enabled.

Also the touch & gesture demo shows how dijit/form/HorizontalSlider and dojo/dnd are now running well on iOS4+ with the new dojo/touch and dojox/gesture. Besides a tap gesture, the demo also shows how easy it is to write a new rotate gesture with multiple touch support.

Dojo Mobile is now considered a first class Mobile library, fully supporting lightweight (baseless) AMD loading and the new Dojo Build System. A new reference guide has been written for the Dojo Mobile project, and full API docs are now available.

New Tooltip widget to popup a container for either simple text or another widget.

New Overlay widget to slide up form the bottom another input widget, and then slides down when done.

New Opener widget adds runtime screen-size detection and uses Tooltip for the larger mobile devices, and Overlay on small-screen devices.

New ComboBox widget (still experimental) that combines searchable text input similar to dijit.form.ComboBox.

New ExpandingTextarea widget grows and shrinks vertically as needed to accommodate the end-user text.

New Slider widget to enable users to easily adjust a value with touch/dragging gestures.

New HTML form input widget wrappers (Textarea, CheckBox, RadioButton) to allow simple form constructs to be used with various dijit container/dialog widgets.

Limitations:

The transition animations use the capability of the CSS 3 transition or the CSS 3 animation, and their behavior highly depends on device and browser. Thus some transition animations do not work smoothly on Android and BlackBerry devices.

ScrollableView often freezes on HTC Android devices, such as HTC Evo, HTC Desire, etc. The problem occurs especially when you perform another scroll operation while the screen is still scrolling. This is not a dojo-specific issue because other JavaScript toolkits have the same problem. There are no workarounds available at present.

Sometimes touching an html form control, such as an input field or a button, placed in ScrollableView on Android devices cannot set focus to it. Sometimes it is successful if you try a couple of times.

dojox.mvc is a new experimental dojox project about separation of MVC concerns on the client, thereby easing the development of data-rich applications using Dojo (enterprise apps, IT apps, CRUD scenarios, patterns like master-detail and others). This first release contains:

The Build Tools have been completely reimplemented in Dojo 1.7, to take full advantage of AMD and has() and optionally Node.js and Closure Compiler, while still being fully backward compatible with the old build tools. A complete reference guide has being prepared here with all the information:

As part of this reimplementation, two important changes have been made:

Due to increased flexibility in the new loader, the “clean” action is now a no-op in order to avoid any
unintentional file deletion. Cleaning the destination directory before a build must now be done manually.

The discard option has been replaced with an exclude option. Instead of creating a layer with the
discard flag, use exclude on your existing layers to explicitly exclude modules from them. See
the writeAmd documentation for details on these options.

Previously you may have been loading modules or layers via script tags, for example:

<script src="/mysite/app/MyWidget.js">

Although this idiom will still work with the standard, built distribution, it is deprecated. Further, it no longer
works with unbuilt versions of the toolkit (e.g. the source distribution), and will result in the program failing to
load and give “multipleDefine” errors in the console. Instead you must load it through dojo.require():

Prior to v1.7, it was possible to define global functions within a module by writing something like this:

dojo.provide("my.module");
function myOnClick(){ ... }

On some browsers, in some cases, myOnClick() would be defined in the global space.

Starting with v1.7, all modules are evaluated within a closing function which results in the definition above residing within
the closure–not the global space. If you really want to add a function in the global space from within a module, then use dojo.global:

Note that the acme query engine is no longer automatically built into dojo.js by default, which will typically
result in an extra network request for dojo/selector/acme.js when dojo/query or Dojo base is loaded.
To include acme in dojo.js, specify selectorEngine:"acme" in the build profile or selectorEngine=acme
on the command line. You can see an example of this in standard.profile.js in Dojo 1.7.1.

Previously, dijit/_base was automatically pulled in as a dependency of dijit/_Widget. As of 1.7, it is now
conditionally pulled in only if the legacy loader is in use, for backwards-compatibility. However, due to this
change, the builder no longer sees dijit/_base as a dependency of dijit/_Widget, and does not pull it in as
a result.

This may lead to additional network requests observed in applications with custom layers affected by this change.
To resolve this, add "dijit._base" as an explicit dependency of the layer.

Dojo 1.7 currently has a limitation where it is unable to properly load local modules which use the legacy
dojo.require syntax alongside dojo.js from another domain. Currently the only workarounds are to update
the local modules to use AMD syntax, or download the Dojo Toolkit and run all modules from the same host.
See defect #14459.

dojo._setOpacity() has been removed, use dojo.style(node, “opacity”, ...) instead

dojo.hasClass crashes if passed a DomNode which is a Text node; application code should make sure it doesn’t pass in text nodes. (They don’t have class settings anyway.)

The private dojo._setMarginBox() and dojo._setContentSize() have been removed, and replaced with public dojo.setMarginBox() and dojo.setContentSize() functions. The new API’s take a hash (like dojo.marginBox() and dojo.contentBox()), ex: dojo.setMarginBox(node, {h: 50, w: 30}), rather than a list of arguments like the previous private functions, ex: dojo._setMarginBox(node, NaN, NaN, 50, 30).

Many widgets which used to extend _Templated now extend _TemplatedMixin. If you have custom widgets that extend standard widgets, and use widgetsInTemplate: true, you may need to also mixin dijit._WidgetsInTemplate

The dijit.Calendar template has been modified to have ${!dayCellsHtml} and ${!dateRowsHtml} variables for the M-F (days of week) row, and the 1-31 days-of-the-month cells. Custom calendar templates should be updated to contain these variables rather than markup for those sections. If custom versions of Calendar need to modify the structure of days-of-week or days-of-month cells, they can override the new Calendar attributes: dowTemplateString, dateTemplateString, and weekTemplateString.

For ComboBox/FilteringSelect, if you need to set the store after creation, be sure to use the set(“store”, myStore) API rather than just setting it directly (myCombo.store = myStore). The latter will fail when myStore is an old dojo.data store rather than the new dojo.store API.

If you have specified a custom labelFunc() for a dijit.form.ComboBox/FilteringSelect, it will be passed an item and store of the new dojo.store API. This generally won’t be a problem unless you are depending on internals of the item (ex: depending on item being a DOMNode rather than a JavaScript hash), or accessing the store as a global variable rather than as the second parameter to the labelFunc() callback.

If you want to allow for rich text saving with back/forward actions, you must add a text area to your page with the id==dijit._scopeName + ”._editor.RichText.value” (typically “dijit._editor.RichText.value). For example: