[Pkg-javascript-commits] [dojo] 09/11: Imported Upstream version 1.11.0+dfsg
David Prévot
taffit at moszumanska.debian.org
Thu Mar 24 04:03:40 UTC 2016
This is an automated email from the git hooks/post-receive script.
taffit pushed a commit to branch master
in repository dojo.
commit cdad10dcb92bcf14e62f9ae14f13276b3c4d27d1
Merge: ff3735c afd327d
Author: David Prévot <david at tilapin.org>
Date: Wed Mar 23 23:19:52 2016 -0400
Imported Upstream version 1.11.0+dfsg
dijit/CONTRIBUTING.md | 5 +++--
dijit/_WidgetBase.js | 2 +-
dijit/bower.json | 4 ++--
dijit/package.json | 4 ++--
dijit/tests/_Widget-lifecycle.html | 25 +++++++++++++++++++++-
dijit/tests/layout/robot/TabContainer_a11y.html | 3 ++-
dijit/themes/dijit.css | 4 ++++
dojo/CONTRIBUTING.md | 5 +++--
dojo/_base/kernel.js | 4 ++--
dojo/bower.json | 2 +-
dojo/package.json | 4 ++--
dojox/CONTRIBUTING.md | 5 +++--
dojox/bower.json | 6 +++---
dojox/package.json | 6 +++---
{dojo => themes}/CONTRIBUTING.md | 28 +++++++------------------
{util => themes}/LICENSE | 2 +-
themes/bower.json | 4 ++--
themes/package.json | 6 +++---
util/CONTRIBUTING.md | 9 ++++----
util/LICENSE | 2 +-
util/bower.json | 10 ++++-----
util/build/version.js | 4 ++--
util/buildscripts/LICENSE | 4 ++--
util/docscripts/LICENSE | 4 ++--
util/doh/LICENSE | 4 ++--
util/doh/_nodeRunner.js | 2 +-
util/doh/_rhinoRunner.js | 2 +-
util/doh/mobileRunner.html | 2 +-
util/doh/package.json | 2 +-
util/doh/runner.html | 2 +-
util/jsdoc/LICENSE | 4 ++--
util/package.json | 2 +-
32 files changed, 96 insertions(+), 76 deletions(-)
diff --cc dijit/CONTRIBUTING.md
index 2f2686d,0000000..d2387d9
mode 100644,000000..100644
--- a/dijit/CONTRIBUTING.md
+++ b/dijit/CONTRIBUTING.md
@@@ -1,227 -1,0 +1,228 @@@
+_Do you have a contribution? We welcome contributions, but please ensure that you read the following information
+before issuing a pull request. Also refer back to this document as a checklist before issuing your pull request.
+This will save time for everyone._
+
+# Before You Start
+
+## Understanding the Basics
+
+If you don't understand what a *pull request* is, or how to submit one, please refer to the [help documentation][]
+provided by GitHub.
+
+## Is It Really a Support Issue
+
+If you aren't sure if your contribution is needed or necessary, please visit the [support forum][] before attempting to
+submit a pull request or a ticket.
+
+## Search Dojo Toolkit's Bug Database
+
+We require every commit to be tracked via our [bug database][]. It is useful, before you get too far, that you have
+checked that your issue isn't already known, otherwise addressed? If you think it is a valid defect or enhancement,
+please open a new ticket before submitting your pull request.
+
+## Discuss Non-Trivial Contributions with the Committers
+
+If your desired contribution is more than a non-trivial fix, you should discuss it on the
+[contributor's mailing list][dojo-contrib]. If you currently are not a member, you can request to be added.
+
+## Contributor License Agreement
+
+We require all contributions, to be covered under the Dojo Foundation's [Contributor License Agreement][cla]. This can
+be done electronically and essentially ensures that you are making it clear that your contributions are your
- contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
++contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
+Foundation.
+
+If you are an unfamiliar contributor to the committer assessing your pull request, it is best to make it clear how
+you are covered by a CLA in the notes of the pull request. The committer will [verify][claCheck] your status.
+
+If your GitHub user id you are submitting your pull request from differs from the Dojo Community ID or e-mail address
+which you have signed your CLA under, you should specifically note what you have your CLA filed under (and for CCLA
+that you are listed under your companies authorised contributors).
+
+# Submitting a Pull Request
+
+The following are the general steps you should follow in creating a pull request. Subsequent pull requests only need
+to follow step 3 and beyond:
+
+1. Fork the repository on GitHub
+2. Clone the forked repository to your machine
+3. Create a "feature" branch in your local repository
+4. Make your changes and commit them to your local repository
+5. Rebase and push your commits to your GitHub remote fork/repository
+6. Issue a Pull Request to the official repository
+7. Your Pull Request is reviewed by a committer and merged into the repository
+
+*Note* While there are other ways to accomplish the steps using other tools, the examples here will assume the most
+actions will be performed via the `git` command line.
+
+## 1. Fork the Repository
+
+When logged into your GitHub account, and you are viewing one of the main repositories, you will see the *Fork* button.
+Clicking this button will show you which repositories your can fork to. Choose your own account. Once the process
+finishes, you will have your own repository that is "forked" from the GitHub one.
+
+Forking is a GitHub term and not a git term. Git is a wholly distributed source control system and simply worries
+about local and remote repositories and allows you to manage your code against them. GitHub then adds this additional
+layer of structure of how repositories can relate to each other.
+
+## 2. Clone the Forked Repository
+
+Once you have successfully forked your repository, you will need to clone it locally to your machine:
+
+```bash
+$ git clone --recursive git at github.com:username/dijit.git
+```
+
+This will clone your fork to your current path in a directory named `dijit`.
+
+It is important that you clone recursively for ``dojox``, ``demos`` or ``util``because some of the code is contained in
+submodules. You won't be able to submit your changes to the repositories that way though. If you are working on any of
+these sub-projects, you should contact those project leads to see if their workflow differs.
+
+You should also setup the `upstream` repository. This will allow you to take changes from the "master" repository
+and merge them into your local clone and then push them to your GitHub fork:
+
+```bash
+$ cd dojo
+$ git remote add upstream git at github.com:dojo/dijit.git
+$ git fetch upstream
+```
+
+Then you can retrieve upstream changes and rebase on them into your code like this:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+For more information on maintaining a fork, please see the GitHub Help article [Fork a Repo][] and information on
+[rebasing][] from git.
+
+## 3. Create a Branch
+
+The easiest workflow is to keep your master branch in sync with the upstream branch and do not locate any of your own
+commits in that branch. When you want to work on a new feature, you then ensure you are on the master branch and create
+a new branch from there. While the name of the branch can be anything, it can often be easy to use the ticket number
+you might be working on. For example:
+
+```bash
+$ git checkout -b t12345 master
+Switched to a new branch 't12345'
+```
+
+You will then be on the feature branch. You can verify what branch you are on like this:
+
+```bash
+$ git status
+# On branch t12345
+nothing to commit, working directory clean
+```
+
+## 4. Make Changes and Commit
+
+Now you just need to make your changes. Once you have finished your changes (and tested them) you need to commit them
+to your local repository (assuming you have staged your changes for committing):
+
+```bash
+$ git status
+# On branch t12345
+# Changes to be committed:
+# (use "git reset HEAD <file>..." to unstage)
+#
+# modified: somefile.js
+#
+$ git commit -m "Corrects some defect, fixes #12345, refs #12346"
+[t12345 0000000] Corrects some defect, fixes #12345, refs #12346
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+```
+
+## 5. Rebase and Push Changes
+
+If you have been working on your contribution for a while, the upstream repository may have changed. You may want to
+ensure your work is on top of the latest changes so your pull request can be applied cleanly:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+When you are ready to push your commit to your GitHub repository for the first time on this branch you would do the
+following:
+
+```bash
+$ git push -u origin t12345
+```
+
+After the first time, you simply need to do:
+
+```bash
+$ git push
+```
+
+## 6. Issue a Pull Request
+
+In order to have your commits merged into the main repository, you need to create a pull request. The instructions for
+this can be found in the GitHub Help Article [Creating a Pull Request][]. Essentially you do the following:
+
+1. Go to the site for your repository.
+2. Click the Pull Request button.
+3. Select the feature branch from your repository.
+4. Enter a title and description of your pull request mentioning the corresponding [bug database][] ticket in the description.
+5. Review the commit and files changed tabs.
+6. Click `Send Pull Request`
+
+You will get notified about the status of your pull request based on your GitHub settings.
+
+## 7. Request is Reviewed and Merged
+
+Your request will be reviewed. It may be merged directly, or you may receive feedback or questions on your pull
+request.
+
+# What Makes a Successful Pull Request?
+
+Having your contribution accepted is more than just the mechanics of getting your contribution into a pull request,
+there are several other things that are expected when contributing to the Dojo Toolkit which are covered below.
+
+## Coding Style and Linting
+
+Dojo has a very specific [coding style][styleguide]. All pull requests should adhere to this.
+
+## Inline Documentation
+
+Dojo has an inline API documentation called [DojoDoc][]. Any pull request should ensure it has updated the inline
+documentation appropriately or added the appropriate inline documentation.
+
+## Test Cases
+
+If the pull request changes the functional behaviour or is fixing a defect, the unit test cases should be modified to
+reflect this. The committer reviewing your pull request is likely to request the appropriate changes in the test
- cases. Dojo utilises its own test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository.
++cases. Dojo utilises [Intern][] for all new tests, and has legacy support for its previous generation test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository. All new tests should be authored using Intern.
+
+It is expected that you will have tested your changes against the existing test cases and appropriate platforms prior to
+submitting your pull request.
+
+## Licensing
+
+All of your submissions are licensed under a dual "New" BSD/AFL license.
+
+## Expect Discussion and Rework
+
+Unless you have been working with contributing to Dojo for a while, expect a significant amount of feedback on your
+pull requests. We are a very passionate community and even the committers often will provide robust feedback to each
+other about their code. Don't be offended by such feedback or feel that your contributions aren't welcome, it is just
+that we are quite passionate and Dojo has a long history with many things that are the "Dojo-way" which may be
+unfamiliar to those who are just starting to contribute.
+
+[help documentation]: http://help.github.com/send-pull-requests
+[bug database]: http://bugs.dojotoolkit.org/
+[support forum]: http://dojotoolkit.org/community/
+[dojo-contrib]: http://mail.dojotoolkit.org/mailman/listinfo/dojo-contributors
+[cla]: http://dojofoundation.org/about/cla
+[claCheck]: http://dojofoundation.org/about/claCheck
+[Creating a Pull Request]: https://help.github.com/articles/creating-a-pull-request
+[Fork a Repo]: https://help.github.com/articles/fork-a-repo
++[Intern]: http://theintern.io/
+[styleguide]: http://dojotoolkit.org/reference-guide/developer/styleguide.html
+[DojoDoc]: http://dojotoolkit.org/reference-guide/developer/markup.html
+[D.O.H.]: http://dojotoolkit.org/reference-guide/util/doh.html
+[dojo/util]: https://github.com/dojo/util
+[interactive rebase]: http://git-scm.com/book/en/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages
+[rebasing]: http://git-scm.com/book/en/Git-Branching-Rebasing
diff --cc dijit/_WidgetBase.js
index ddac57b,0000000..2396953
mode 100644,000000..100644
--- a/dijit/_WidgetBase.js
+++ b/dijit/_WidgetBase.js
@@@ -1,1222 -1,0 +1,1222 @@@
+define([
+ "require", // require.toUrl
+ "dojo/_base/array", // array.forEach array.map
+ "dojo/aspect",
+ "dojo/_base/config", // config.blankGif
+ "dojo/_base/connect", // connect.connect
+ "dojo/_base/declare", // declare
+ "dojo/dom", // dom.byId
+ "dojo/dom-attr", // domAttr.set domAttr.remove
+ "dojo/dom-class", // domClass.add domClass.replace
+ "dojo/dom-construct", // domConstruct.destroy domConstruct.place
+ "dojo/dom-geometry", // isBodyLtr
+ "dojo/dom-style", // domStyle.set, domStyle.get
+ "dojo/has",
+ "dojo/_base/kernel",
+ "dojo/_base/lang", // mixin(), isArray(), etc.
+ "dojo/on",
+ "dojo/ready",
+ "dojo/Stateful", // Stateful
+ "dojo/topic",
+ "dojo/_base/window", // win.body()
+ "./Destroyable",
+ "dojo/has!dojo-bidi?./_BidiMixin",
+ "./registry" // registry.getUniqueId(), registry.findWidgets()
+], function(require, array, aspect, config, connect, declare,
+ dom, domAttr, domClass, domConstruct, domGeometry, domStyle, has, kernel,
+ lang, on, ready, Stateful, topic, win, Destroyable, _BidiMixin, registry){
+
+ // module:
+ // dijit/_WidgetBase
+
+ // Flag to make dijit load modules the app didn't explicitly request, for backwards compatibility
+ has.add("dijit-legacy-requires", !kernel.isAsync);
+
+ // Flag to enable support for textdir attribute
+ has.add("dojo-bidi", false);
+
+
+ // For back-compat, remove in 2.0.
+ if(has("dijit-legacy-requires")){
+ ready(0, function(){
+ var requires = ["dijit/_base/manager"];
+ require(requires); // use indirection so modules not rolled into a build
+ });
+ }
+
+ // Nested hash listing attributes for each tag, all strings in lowercase.
+ // ex: {"div": {"style": true, "tabindex" true}, "form": { ...
+ var tagAttrs = {};
+
+ function getAttrs(obj){
+ var ret = {};
+ for(var attr in obj){
+ ret[attr.toLowerCase()] = true;
+ }
+ return ret;
+ }
+
+ function nonEmptyAttrToDom(attr){
+ // summary:
+ // Returns a setter function that copies the attribute to this.domNode,
+ // or removes the attribute from this.domNode, depending on whether the
+ // value is defined or not.
+ return function(val){
+ domAttr[val ? "set" : "remove"](this.domNode, attr, val);
+ this._set(attr, val);
+ };
+ }
+
+ function isEqual(a, b){
+ // summary:
+ // Function that determines whether two values are identical,
+ // taking into account that NaN is not normally equal to itself
+ // in JS.
+
+ return a === b || (/* a is NaN */ a !== a && /* b is NaN */ b !== b);
+ }
+
+ var _WidgetBase = declare("dijit._WidgetBase", [Stateful, Destroyable], {
+ // summary:
+ // Future base class for all Dijit widgets.
+ // description:
+ // Future base class for all Dijit widgets.
+ // _Widget extends this class adding support for various features needed by desktop.
+ //
+ // Provides stubs for widget lifecycle methods for subclasses to extend, like postMixInProperties(), buildRendering(),
+ // postCreate(), startup(), and destroy(), and also public API methods like set(), get(), and watch().
+ //
+ // Widgets can provide custom setters/getters for widget attributes, which are called automatically by set(name, value).
+ // For an attribute XXX, define methods _setXXXAttr() and/or _getXXXAttr().
+ //
+ // _setXXXAttr can also be a string/hash/array mapping from a widget attribute XXX to the widget's DOMNodes:
+ //
+ // - DOM node attribute
+ // | _setFocusAttr: {node: "focusNode", type: "attribute"}
+ // | _setFocusAttr: "focusNode" (shorthand)
+ // | _setFocusAttr: "" (shorthand, maps to this.domNode)
+ // Maps this.focus to this.focusNode.focus, or (last example) this.domNode.focus
+ //
+ // - DOM node innerHTML
+ // | _setTitleAttr: { node: "titleNode", type: "innerHTML" }
+ // Maps this.title to this.titleNode.innerHTML
+ //
+ // - DOM node innerText
+ // | _setTitleAttr: { node: "titleNode", type: "innerText" }
+ // Maps this.title to this.titleNode.innerText
+ //
+ // - DOM node CSS class
+ // | _setMyClassAttr: { node: "domNode", type: "class" }
+ // Maps this.myClass to this.domNode.className
+ //
+ // - Toggle DOM node CSS class
+ // | _setMyClassAttr: { node: "domNode", type: "toggleClass" }
+ // Toggles myClass on this.domNode by this.myClass
+ //
+ // If the value of _setXXXAttr is an array, then each element in the array matches one of the
+ // formats of the above list.
+ //
+ // If the custom setter is null, no action is performed other than saving the new value
+ // in the widget (in this).
+ //
+ // If no custom setter is defined for an attribute, then it will be copied
+ // to this.focusNode (if the widget defines a focusNode), or this.domNode otherwise.
+ // That's only done though for attributes that match DOMNode attributes (title,
+ // alt, aria-labelledby, etc.)
+
+ // id: [const] String
+ // 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.
+ id: "",
+ _setIdAttr: "domNode", // to copy to this.domNode even for auto-generated id's
+
+ // lang: [const] String
+ // 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).
+ lang: "",
+ // set on domNode even when there's a focus node. but don't set lang="", since that's invalid.
+ _setLangAttr: nonEmptyAttrToDom("lang"),
+
+ // dir: [const] String
+ // 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.
+ dir: "",
+ // set on domNode even when there's a focus node. but don't set dir="", since that's invalid.
+ _setDirAttr: nonEmptyAttrToDom("dir"), // to set on domNode even when there's a focus node
+
+ // class: String
+ // HTML class attribute
+ "class": "",
+ _setClassAttr: { node: "domNode", type: "class" },
+
+ // Override automatic assigning type --> focusNode, it causes exception on IE6-8.
+ // Instead, type must be specified as ${type} in the template, as part of the original DOM.
+ _setTypeAttr: null,
+
+ // style: String||Object
+ // HTML style attributes as cssText string or name/value hash
+ style: "",
+
+ // title: String
+ // 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. In this case it's
+ // interpreted as HTML.
+ title: "",
+
+ // tooltip: String
+ // 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.
+ tooltip: "",
+
+ // baseClass: [protected] String
+ // Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
+ // widget state.
+ baseClass: "",
+
+ // srcNodeRef: [readonly] DomNode
+ // pointer to original DOM node
+ srcNodeRef: null,
+
+ // domNode: [readonly] DomNode
+ // This is our visible representation of the widget! Other DOM
+ // Nodes may by assigned to other properties, usually through the
+ // template system's data-dojo-attach-point syntax, but the domNode
+ // property is the canonical "top level" node in widget UI.
+ domNode: null,
+
+ // containerNode: [readonly] DomNode
+ // 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 data-dojo-type=myWidget>
+ // | <b> here's a plain DOM node
+ // | <span data-dojo-type=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 data-dojo-type=subWidget>and a widget</span>
+ // | <i> and another plain DOM node </i>
+ //
+ // In templated widgets, "containerNode" is set via a
+ // data-dojo-attach-point 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.
+ containerNode: null,
+
+ // ownerDocument: [const] Document?
+ // The document this widget belongs to. If not specified to constructor, will default to
+ // srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
+ ownerDocument: null,
+ _setOwnerDocumentAttr: function(val){
+ // this setter is merely to avoid automatically trying to set this.domNode.ownerDocument
+ this._set("ownerDocument", val);
+ },
+
+ /*=====
+ // _started: [readonly] Boolean
+ // startup() has completed.
+ _started: false,
+ =====*/
+
+ // attributeMap: [protected] Object
+ // Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
+ // for each XXX attribute to be mapped to the DOM.
+ //
+ // attributeMap sets up a "binding" between attributes (aka properties)
+ // of the widget and the widget's DOM.
+ // Changes to widget attributes listed in attributeMap will be
+ // reflected into the DOM.
+ //
+ // For example, calling set('title', 'hello')
+ // on a TitlePane will automatically cause the TitlePane's DOM to update
+ // with the new title.
+ //
+ // attributeMap is a hash where the key is an attribute of the widget,
+ // and the value reflects a binding to a:
+ //
+ // - DOM node attribute
+ // | focus: {node: "focusNode", type: "attribute"}
+ // Maps this.focus to this.focusNode.focus
+ //
+ // - DOM node innerHTML
+ // | title: { node: "titleNode", type: "innerHTML" }
+ // Maps this.title to this.titleNode.innerHTML
+ //
+ // - DOM node innerText
+ // | title: { node: "titleNode", type: "innerText" }
+ // Maps this.title to this.titleNode.innerText
+ //
+ // - DOM node CSS class
+ // | myClass: { node: "domNode", type: "class" }
+ // Maps this.myClass to this.domNode.className
+ //
+ // If the value is an array, then each element in the array matches one of the
+ // formats of the above list.
+ //
+ // There are also some shorthands for backwards compatibility:
+ //
+ // - string --> { node: string, type: "attribute" }, for example:
+ //
+ // | "focusNode" ---> { node: "focusNode", type: "attribute" }
+ //
+ // - "" --> { node: "domNode", type: "attribute" }
+ attributeMap: {},
+
+ // _blankGif: [protected] String
+ // Path to a blank 1x1 image.
+ // Used by `<img>` nodes in templates that really get their image via CSS background-image.
+ _blankGif: config.blankGif || require.toUrl("dojo/resources/blank.gif"),
+
+ // textDir: String
+ // Bi-directional support, the main variable which is responsible for the direction of the text.
+ // The text direction can be different than the GUI direction by using this parameter in creation
+ // of a widget.
+ //
+ // This property is only effective when `has("dojo-bidi")` is defined to be true.
+ //
+ // Allowed values:
+ //
+ // 1. "" - default value; text is same direction as widget
+ // 2. "ltr"
+ // 3. "rtl"
+ // 4. "auto" - contextual the direction of a text defined by first strong letter.
+ textDir: "",
+
+ //////////// INITIALIZATION METHODS ///////////////////////////////////////
+
+ /*=====
+ constructor: function(params, srcNodeRef){
+ // summary:
+ // Create the widget.
+ // params: Object|null
+ // Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
+ // and functions, typically callbacks like onClick.
+ // The hash can contain any of the widget's properties, excluding read-only properties.
+ // srcNodeRef: DOMNode|String?
+ // 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
+ },
+ =====*/
+
+ _introspect: function(){
+ // summary:
+ // Collect metadata about this widget (only once per class, not once per instance):
+ //
+ // - list of attributes with custom setters, storing in this.constructor._setterAttrs
+ // - generate this.constructor._onMap, mapping names like "mousedown" to functions like onMouseDown
+
+ var ctor = this.constructor;
+ if(!ctor._setterAttrs){
+ var proto = ctor.prototype,
+ attrs = ctor._setterAttrs = [], // attributes with custom setters
+ onMap = (ctor._onMap = {});
+
+ // Items in this.attributeMap are like custom setters. For back-compat, remove for 2.0.
+ for(var name in proto.attributeMap){
+ attrs.push(name);
+ }
+
+ // Loop over widget properties, collecting properties with custom setters and filling in ctor._onMap.
+ for(name in proto){
+ if(/^on/.test(name)){
+ onMap[name.substring(2).toLowerCase()] = name;
+ }
+
+ if(/^_set[A-Z](.*)Attr$/.test(name)){
+ name = name.charAt(4).toLowerCase() + name.substr(5, name.length - 9);
+ if(!proto.attributeMap || !(name in proto.attributeMap)){
+ attrs.push(name);
+ }
+ }
+ }
+
+ // Note: this isn't picking up info on properties like aria-label and role, that don't have custom setters
+ // but that set() maps to attributes on this.domNode or this.focusNode
+ }
+ },
+
+ postscript: function(/*Object?*/params, /*DomNode|String*/srcNodeRef){
+ // summary:
+ // Kicks off widget instantiation. See create() for details.
+ // tags:
+ // private
+
+ // Note that we skip calling this.inherited(), i.e. dojo/Stateful::postscript(), because 1.x widgets don't
+ // expect their custom setters to get called until after buildRendering(). Consider changing for 2.0.
+
+ this.create(params, srcNodeRef);
+ },
+
+ create: function(params, srcNodeRef){
+ // summary:
+ // Kick off the life-cycle of a widget
+ // description:
+ // Create calls a number of widget methods (postMixInProperties, buildRendering, postCreate,
+ // etc.), some of which of you'll want to override. See http://dojotoolkit.org/reference-guide/dijit/_WidgetBase.html
+ // 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.
+ // params: Object|null
+ // Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
+ // and functions, typically callbacks like onClick.
+ // The hash can contain any of the widget's properties, excluding read-only properties.
+ // srcNodeRef: DOMNode|String?
+ // 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
+ // tags:
+ // private
+
+ // First time widget is instantiated, scan prototype to figure out info about custom setters etc.
+ this._introspect();
+
+ // store pointer to original DOM tree
+ this.srcNodeRef = dom.byId(srcNodeRef);
+
+ // No longer used, remove for 2.0.
+ this._connects = [];
+ this._supportingWidgets = [];
+
+ // this is here for back-compat, remove in 2.0 (but check NodeList-instantiate.html test)
- if(this.srcNodeRef && (typeof this.srcNodeRef.id == "string")){
++ if(this.srcNodeRef && this.srcNodeRef.id && (typeof this.srcNodeRef.id == "string")){
+ this.id = this.srcNodeRef.id;
+ }
+
+ // mix in our passed parameters
+ if(params){
+ this.params = params;
+ lang.mixin(this, params);
+ }
+ this.postMixInProperties();
+
+ // Generate an id for the widget if one wasn't specified, or it was specified as id: undefined.
+ // Do this before buildRendering() because it might expect the id to be there.
+ if(!this.id){
+ this.id = registry.getUniqueId(this.declaredClass.replace(/\./g, "_"));
+ if(this.params){
+ // if params contains {id: undefined}, prevent _applyAttributes() from processing it
+ delete this.params.id;
+ }
+ }
+
+ // The document and <body> node this widget is associated with
+ this.ownerDocument = this.ownerDocument || (this.srcNodeRef ? this.srcNodeRef.ownerDocument : document);
+ this.ownerDocumentBody = win.body(this.ownerDocument);
+
+ registry.add(this);
+
+ this.buildRendering();
+
+ var deleteSrcNodeRef;
+
+ if(this.domNode){
+ // Copy attributes listed in attributeMap into the [newly created] DOM for the widget.
+ // Also calls custom setters for all attributes with custom setters.
+ this._applyAttributes();
+
+ // If srcNodeRef was specified, then swap out original srcNode for this widget's DOM tree.
+ // For 2.0, move this after postCreate(). postCreate() shouldn't depend on the
+ // widget being attached to the DOM since it isn't when a widget is created programmatically like
+ // new MyWidget({}). See #11635.
+ var source = this.srcNodeRef;
+ if(source && source.parentNode && this.domNode !== source){
+ source.parentNode.replaceChild(this.domNode, source);
+ deleteSrcNodeRef = true;
+ }
+
+ // Note: for 2.0 may want to rename widgetId to dojo._scopeName + "_widgetId",
+ // assuming that dojo._scopeName even exists in 2.0
+ this.domNode.setAttribute("widgetId", this.id);
+ }
+ this.postCreate();
+
+ // If srcNodeRef has been processed and removed from the DOM (e.g. TemplatedWidget) then delete it to allow GC.
+ // I think for back-compatibility it isn't deleting srcNodeRef until after postCreate() has run.
+ if(deleteSrcNodeRef){
+ delete this.srcNodeRef;
+ }
+
+ this._created = true;
+ },
+
+ _applyAttributes: function(){
+ // summary:
+ // Step during widget creation to copy widget attributes to the
+ // DOM according to attributeMap and _setXXXAttr objects, and also to call
+ // custom _setXXXAttr() methods.
+ //
+ // 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.
+ //
+ // For backwards-compatibility reasons attributeMap overrides _setXXXAttr when
+ // _setXXXAttr is a hash/string/array, but _setXXXAttr as a functions override attributeMap.
+ // tags:
+ // private
+
+ // Call this.set() for each property that was either specified as parameter to constructor,
+ // or is in the list found above. For correlated properties like value and displayedValue, the one
+ // specified as a parameter should take precedence.
+ // Particularly important for new DateTextBox({displayedValue: ...}) since DateTextBox's default value is
+ // NaN and thus is not ignored like a default value of "".
+
+ // Step 1: Save the current values of the widget properties that were specified as parameters to the constructor.
+ // Generally this.foo == this.params.foo, except if postMixInProperties() changed the value of this.foo.
+ var params = {};
+ for(var key in this.params || {}){
+ params[key] = this._get(key);
+ }
+
+ // Step 2: Call set() for each property with a non-falsy value that wasn't passed as a parameter to the constructor
+ array.forEach(this.constructor._setterAttrs, function(key){
+ if(!(key in params)){
+ var val = this._get(key);
+ if(val){
+ this.set(key, val);
+ }
+ }
+ }, this);
+
+ // Step 3: Call set() for each property that was specified as parameter to constructor.
+ // Use params hash created above to ignore side effects from step #2 above.
+ for(key in params){
+ this.set(key, params[key]);
+ }
+ },
+
+ postMixInProperties: function(){
+ // summary:
+ // Called after the parameters to the widget have been read-in,
+ // but before the widget template is instantiated. Especially
+ // useful to set properties that are referenced in the widget
+ // template.
+ // tags:
+ // protected
+ },
+
+ buildRendering: function(){
+ // summary:
+ // Construct the UI for this widget, setting this.domNode.
+ // Most widgets will mixin `dijit._TemplatedMixin`, which implements this method.
+ // tags:
+ // protected
+
+ if(!this.domNode){
+ // Create root node if it wasn't created by _TemplatedMixin
+ this.domNode = this.srcNodeRef || this.ownerDocument.createElement("div");
+ }
+
+ // baseClass is a single class name or occasionally a space-separated list of names.
+ // Add those classes to the DOMNode. If RTL mode then also add with Rtl suffix.
+ // TODO: make baseClass custom setter
+ if(this.baseClass){
+ var classes = this.baseClass.split(" ");
+ if(!this.isLeftToRight()){
+ classes = classes.concat(array.map(classes, function(name){
+ return name + "Rtl";
+ }));
+ }
+ domClass.add(this.domNode, classes);
+ }
+ },
+
+ postCreate: function(){
+ // summary:
+ // Processing after the DOM fragment is created
+ // description:
+ // 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.
+ // tags:
+ // protected
+ },
+
+ startup: function(){
+ // summary:
+ // Processing after the DOM fragment is added to the document
+ // description:
+ // 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().
+ //
+ // Note that startup() may be called while the widget is still hidden, for example if the widget is
+ // inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
+ // For widgets that need to do layout, it's best to put that layout code inside resize(), and then
+ // extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
+ if(this._started){
+ return;
+ }
+ this._started = true;
+ array.forEach(this.getChildren(), function(obj){
+ if(!obj._started && !obj._destroyed && lang.isFunction(obj.startup)){
+ obj.startup();
+ obj._started = true;
+ }
+ });
+ },
+
+ //////////// DESTROY FUNCTIONS ////////////////////////////////
+
+ destroyRecursive: function(/*Boolean?*/ preserveDom){
+ // summary:
+ // Destroy this widget and its descendants
+ // description:
+ // 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.
+ // preserveDom:
+ // If true, this method will leave the original DOM structure
+ // alone of descendant Widgets. Note: This will NOT work with
+ // dijit._TemplatedMixin widgets.
+
+ this._beingDestroyed = true;
+ this.destroyDescendants(preserveDom);
+ this.destroy(preserveDom);
+ },
+
+ destroy: function(/*Boolean*/ preserveDom){
+ // summary:
+ // Destroy this widget, but not its descendants. Descendants means widgets inside of
+ // this.containerNode. Will also destroy any resources (including widgets) registered via this.own().
+ //
+ // This method will also destroy internal widgets such as those created from a template,
+ // assuming those widgets exist inside of this.domNode but outside of this.containerNode.
+ //
+ // For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
+ // depend on the current ability to destroy a widget without destroying its descendants. Generally
+ // they should use destroyRecursive() for widgets with children.
+ // preserveDom: Boolean
+ // If true, this method will leave the original DOM structure alone.
+ // Note: This will not yet work with _TemplatedMixin widgets
+
+ this._beingDestroyed = true;
+ this.uninitialize();
+
+ function destroy(w){
+ if(w.destroyRecursive){
+ w.destroyRecursive(preserveDom);
+ }else if(w.destroy){
+ w.destroy(preserveDom);
+ }
+ }
+
+ // Back-compat, remove for 2.0
+ array.forEach(this._connects, lang.hitch(this, "disconnect"));
+ array.forEach(this._supportingWidgets, destroy);
+
+ // Destroy supporting widgets, but not child widgets under this.containerNode (for 2.0, destroy child widgets
+ // here too). if() statement is to guard against exception if destroy() called multiple times (see #15815).
+ if(this.domNode){
+ array.forEach(registry.findWidgets(this.domNode, this.containerNode), destroy);
+ }
+
+ this.destroyRendering(preserveDom);
+ registry.remove(this.id);
+ this._destroyed = true;
+ },
+
+ destroyRendering: function(/*Boolean?*/ preserveDom){
+ // summary:
+ // Destroys the DOM nodes associated with this widget.
+ // preserveDom:
+ // If true, this method will leave the original DOM structure alone
+ // during tear-down. Note: this will not work with _Templated
+ // widgets yet.
+ // tags:
+ // protected
+
+ if(this.bgIframe){
+ this.bgIframe.destroy(preserveDom);
+ delete this.bgIframe;
+ }
+
+ if(this.domNode){
+ if(preserveDom){
+ domAttr.remove(this.domNode, "widgetId");
+ }else{
+ domConstruct.destroy(this.domNode);
+ }
+ delete this.domNode;
+ }
+
+ if(this.srcNodeRef){
+ if(!preserveDom){
+ domConstruct.destroy(this.srcNodeRef);
+ }
+ delete this.srcNodeRef;
+ }
+ },
+
+ destroyDescendants: function(/*Boolean?*/ preserveDom){
+ // summary:
+ // Recursively destroy the children of this widget and their
+ // descendants.
+ // preserveDom:
+ // If true, the preserveDom attribute is passed to all descendant
+ // widget's .destroy() method. Not for use with _Templated
+ // widgets.
+
+ // get all direct descendants and destroy them recursively
+ array.forEach(this.getChildren(), function(widget){
+ if(widget.destroyRecursive){
+ widget.destroyRecursive(preserveDom);
+ }
+ });
+ },
+
+ uninitialize: function(){
+ // summary:
+ // Deprecated. Override destroy() instead to implement custom widget tear-down
+ // behavior.
+ // tags:
+ // protected
+ return false;
+ },
+
+ ////////////////// GET/SET, CUSTOM SETTERS, ETC. ///////////////////
+
+ _setStyleAttr: function(/*String||Object*/ value){
+ // summary:
+ // Sets the style attribute of the widget according to value,
+ // which is either a hash like {height: "5px", width: "3px"}
+ // or a plain string
+ // description:
+ // Determines which node to set the style on based on style setting
+ // in attributeMap.
+ // tags:
+ // protected
+
+ var mapNode = this.domNode;
+
+ // Note: technically we should revert any style setting made in a previous call
+ // to his method, but that's difficult to keep track of.
+
+ if(lang.isObject(value)){
+ domStyle.set(mapNode, value);
+ }else{
+ if(mapNode.style.cssText){
+ mapNode.style.cssText += "; " + value;
+ }else{
+ mapNode.style.cssText = value;
+ }
+ }
+
+ this._set("style", value);
+ },
+
+ _attrToDom: function(/*String*/ attr, /*String*/ value, /*Object?*/ commands){
+ // summary:
+ // Reflect a widget attribute (title, tabIndex, duration etc.) to
+ // the widget DOM, as specified by commands parameter.
+ // If commands isn't specified then it's looked up from attributeMap.
+ // Note some attributes like "type"
+ // cannot be processed this way as they are not mutable.
+ // attr:
+ // Name of member variable (ex: "focusNode" maps to this.focusNode) pointing
+ // to DOMNode inside the widget, or alternately pointing to a subwidget
+ // tags:
+ // private
+
+ commands = arguments.length >= 3 ? commands : this.attributeMap[attr];
+
+ array.forEach(lang.isArray(commands) ? commands : [commands], function(command){
+
+ // Get target node and what we are doing to that node
+ var mapNode = this[command.node || command || "domNode"]; // DOM node
+ var type = command.type || "attribute"; // class, innerHTML, innerText, or attribute
+
+ switch(type){
+ case "attribute":
+ if(lang.isFunction(value)){ // functions execute in the context of the widget
+ value = lang.hitch(this, value);
+ }
+
+ // Get the name of the DOM node attribute; usually it's the same
+ // as the name of the attribute in the widget (attr), but can be overridden.
+ // Also maps handler names to lowercase, like onSubmit --> onsubmit
+ var attrName = command.attribute ? command.attribute :
+ (/^on[A-Z][a-zA-Z]*$/.test(attr) ? attr.toLowerCase() : attr);
+
+ if(mapNode.tagName){
+ // Normal case, mapping to a DOMNode. Note that modern browsers will have a mapNode.set()
+ // method, but for consistency we still call domAttr
+ domAttr.set(mapNode, attrName, value);
+ }else{
+ // mapping to a sub-widget
+ mapNode.set(attrName, value);
+ }
+ break;
+ case "innerText":
+ mapNode.innerHTML = "";
+ mapNode.appendChild(this.ownerDocument.createTextNode(value));
+ break;
+ case "innerHTML":
+ mapNode.innerHTML = value;
+ break;
+ case "class":
+ domClass.replace(mapNode, value, this[attr]);
+ break;
+ case "toggleClass":
+ domClass.toggle(mapNode, command.className || attr, value);
+ break;
+ }
+ }, this);
+ },
+
+ get: function(name){
+ // summary:
+ // Get a property from a widget.
+ // name:
+ // The property to get.
+ // description:
+ // 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 properties `foo` and `bar`
+ // and a method named `_getFooAttr()`, calling:
+ // `myWidget.get("foo")` would be equivalent to calling
+ // `widget._getFooAttr()` and `myWidget.get("bar")`
+ // would be equivalent to the expression
+ // `widget.bar2`
+ var names = this._getAttrNames(name);
+ return this[names.g] ? this[names.g]() : this._get(name);
+ },
+
+ set: function(name, value){
+ // summary:
+ // Set a property on a widget
+ // name:
+ // The property to set.
+ // value:
+ // The value to set in the property.
+ // description:
+ // Sets named properties on a widget which may potentially be handled by a
+ // setter in the widget.
+ //
+ // For example, if the widget has properties `foo` and `bar`
+ // and a method named `_setFooAttr()`, calling
+ // `myWidget.set("foo", "Howdy!")` would be equivalent to calling
+ // `widget._setFooAttr("Howdy!")` and `myWidget.set("bar", 3)`
+ // would be equivalent to the statement `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)`
+
+ if(typeof name === "object"){
+ for(var x in name){
+ this.set(x, name[x]);
+ }
+ return this;
+ }
+ var names = this._getAttrNames(name),
+ setter = this[names.s];
+ if(lang.isFunction(setter)){
+ // use the explicit setter
+ var result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
+ }else{
+ // Mapping from widget attribute to DOMNode/subwidget attribute/value/etc.
+ // Map according to:
+ // 1. attributeMap setting, if one exists (TODO: attributeMap deprecated, remove in 2.0)
+ // 2. _setFooAttr: {...} type attribute in the widget (if one exists)
+ // 3. apply to focusNode or domNode if standard attribute name, excluding funcs like onClick.
+ // Checks if an attribute is a "standard attribute" by whether the DOMNode JS object has a similar
+ // attribute name (ex: accept-charset attribute matches jsObject.acceptCharset).
+ // Note also that Tree.focusNode() is a function not a DOMNode, so test for that.
+ var defaultNode = this.focusNode && !lang.isFunction(this.focusNode) ? "focusNode" : "domNode",
+ tag = this[defaultNode] && this[defaultNode].tagName,
+ attrsForTag = tag && (tagAttrs[tag] || (tagAttrs[tag] = getAttrs(this[defaultNode]))),
+ map = name in this.attributeMap ? this.attributeMap[name] :
+ names.s in this ? this[names.s] :
+ ((attrsForTag && names.l in attrsForTag && typeof value != "function") ||
+ /^aria-|^data-|^role$/.test(name)) ? defaultNode : null;
+ if(map != null){
+ this._attrToDom(name, value, map);
+ }
+ this._set(name, value);
+ }
+ return result || this;
+ },
+
+ _attrPairNames: {}, // shared between all widgets
+ _getAttrNames: function(name){
+ // summary:
+ // Helper function for get() and set().
+ // Caches attribute name values so we don't do the string ops every time.
+ // tags:
+ // private
+
+ var apn = this._attrPairNames;
+ if(apn[name]){
+ return apn[name];
+ }
+ var uc = name.replace(/^[a-z]|-[a-zA-Z]/g, function(c){
+ return c.charAt(c.length - 1).toUpperCase();
+ });
+ return (apn[name] = {
+ n: name + "Node",
+ s: "_set" + uc + "Attr", // converts dashes to camel case, ex: accept-charset --> _setAcceptCharsetAttr
+ g: "_get" + uc + "Attr",
+ l: uc.toLowerCase() // lowercase name w/out dashes, ex: acceptcharset
+ });
+ },
+
+ _set: function(/*String*/ name, /*anything*/ value){
+ // summary:
+ // Helper function to set new value for specified property, and call handlers
+ // registered with watch() if the value has changed.
+ var oldValue = this[name];
+ this[name] = value;
+ if(this._created && !isEqual(oldValue, value)){
+ if(this._watchCallbacks){
+ this._watchCallbacks(name, oldValue, value);
+ }
+ this.emit("attrmodified-" + name, {
+ detail: {
+ prevValue: oldValue,
+ newValue: value
+ }
+ });
+ }
+ },
+
+ _get: function(/*String*/ name){
+ // summary:
+ // Helper function to get value for specified property stored by this._set(),
+ // i.e. for properties with custom setters. Used mainly by custom getters.
+ //
+ // For example, CheckBox._getValueAttr() calls this._get("value").
+
+ // future: return name in this.props ? this.props[name] : this[name];
+ return this[name];
+ },
+
+ emit: function(/*String*/ type, /*Object?*/ eventObj, /*Array?*/ callbackArgs){
+ // summary:
+ // Used by widgets to signal that a synthetic event occurred, ex:
+ // | myWidget.emit("attrmodified-selectedChildWidget", {}).
+ //
+ // Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
+ // Also calls onType() method, if present, and returns value from that method.
+ // By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
+ // Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
+ // tags:
+ // protected
+
+ // Specify fallback values for bubbles, cancelable in case they are not set in eventObj.
+ // Also set pointer to widget, although since we can't add a pointer to the widget for native events
+ // (see #14729), maybe we shouldn't do it here?
+ eventObj = eventObj || {};
+ if(eventObj.bubbles === undefined){
+ eventObj.bubbles = true;
+ }
+ if(eventObj.cancelable === undefined){
+ eventObj.cancelable = true;
+ }
+ if(!eventObj.detail){
+ eventObj.detail = {};
+ }
+ eventObj.detail.widget = this;
+
+ var ret, callback = this["on" + type];
+ if(callback){
+ ret = callback.apply(this, callbackArgs ? callbackArgs : [eventObj]);
+ }
+
+ // Emit event, but avoid spurious emit()'s as parent sets properties on child during startup/destroy
+ if(this._started && !this._beingDestroyed){
+ on.emit(this.domNode, type.toLowerCase(), eventObj);
+ }
+
+ return ret;
+ },
+
+ on: function(/*String|Function*/ type, /*Function*/ func){
+ // summary:
+ // Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
+ // type:
+ // Name of event (ex: "click") or extension event like touch.press.
+ // description:
+ // Call specified function when event `type` occurs, ex: `myWidget.on("click", function(){ ... })`.
+ // Note that the function is not run in any particular scope, so if (for example) you want it to run in the
+ // widget's scope you must do `myWidget.on("click", lang.hitch(myWidget, func))`.
+
+ // For backwards compatibility, if there's an onType() method in the widget then connect to that.
+ // Remove in 2.0.
+ var widgetMethod = this._onMap(type);
+ if(widgetMethod){
+ return aspect.after(this, widgetMethod, func, true);
+ }
+
+ // Otherwise, just listen for the event on this.domNode.
+ return this.own(on(this.domNode, type, func))[0];
+ },
+
+ _onMap: function(/*String|Function*/ type){
+ // summary:
+ // Maps on() type parameter (ex: "mousemove") to method name (ex: "onMouseMove").
+ // If type is a synthetic event like touch.press then returns undefined.
+ var ctor = this.constructor, map = ctor._onMap;
+ if(!map){
+ map = (ctor._onMap = {});
+ for(var attr in ctor.prototype){
+ if(/^on/.test(attr)){
+ map[attr.replace(/^on/, "").toLowerCase()] = attr;
+ }
+ }
+ }
+ return map[typeof type == "string" && type.toLowerCase()]; // String
+ },
+
+ toString: function(){
+ // summary:
+ // Returns a string that represents the widget.
+ // description:
+ // 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.
+ return '[Widget ' + this.declaredClass + ', ' + (this.id || 'NO ID') + ']'; // String
+ },
+
+ getChildren: function(){
+ // summary:
+ // Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
+ // is this widget. Note that it does not return all descendants, but rather just direct children.
+ // Analogous to [Node.childNodes](https://developer.mozilla.org/en-US/docs/DOM/Node.childNodes),
+ // except containing widgets rather than DOMNodes.
+ //
+ // The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
+ // outside of this.containerNode.
+ //
+ // Note that the array returned is a simple array. Application code should not assume
+ // existence of methods like forEach().
+
+ return this.containerNode ? registry.findWidgets(this.containerNode) : []; // dijit/_WidgetBase[]
+ },
+
+ getParent: function(){
+ // summary:
+ // Returns the parent widget of this widget.
+
+ return registry.getEnclosingWidget(this.domNode.parentNode);
+ },
+
+ connect: function(/*Object|null*/ obj, /*String|Function*/ event, /*String|Function*/ method){
+ // summary:
+ // Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
+ //
+ // Connects specified obj/event to specified method of this object
+ // and registers for disconnect() on widget destroy.
+ //
+ // 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.
+ // returns:
+ // A handle that can be passed to `disconnect` in order to disconnect before
+ // the widget is destroyed.
+ // example:
+ // | var btn = new 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());
+ // | });
+ // tags:
+ // protected
+
+ return this.own(connect.connect(obj, event, this, method))[0]; // handle
+ },
+
+ disconnect: function(handle){
+ // summary:
+ // Deprecated, will be removed in 2.0, use handle.remove() instead.
+ //
+ // Disconnects handle created by `connect`.
+ // tags:
+ // protected
+
+ handle.remove();
+ },
+
+ subscribe: function(t, method){
+ // summary:
+ // Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
+ //
+ // Subscribes to the specified topic and calls the specified method
+ // of this object and registers for unsubscribe() on widget destroy.
+ //
+ // Provide widget-specific analog to dojo.subscribe, except with the
+ // implicit use of this widget as the target object.
+ // t: String
+ // The topic
+ // method: Function
+ // The callback
+ // example:
+ // | var btn = new 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);
+ // | });
+ // tags:
+ // protected
+ return this.own(topic.subscribe(t, lang.hitch(this, method)))[0]; // handle
+ },
+
+ unsubscribe: function(/*Object*/ handle){
+ // summary:
+ // Deprecated, will be removed in 2.0, use handle.remove() instead.
+ //
+ // Unsubscribes handle created by this.subscribe.
+ // Also removes handle from this widget's list of subscriptions
+ // tags:
+ // protected
+
+ handle.remove();
+ },
+
+ isLeftToRight: function(){
+ // summary:
+ // Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
+ // tags:
+ // protected
+ return this.dir ? (this.dir.toLowerCase() == "ltr") : domGeometry.isBodyLtr(this.ownerDocument); //Boolean
+ },
+
+ isFocusable: function(){
+ // summary:
+ // Return true if this widget can currently be focused
+ // and false if not
+ return this.focus && (domStyle.get(this.domNode, "display") != "none");
+ },
+
+ placeAt: function(/*String|DomNode|DocumentFragment|dijit/_WidgetBase*/ reference, /*String|Int?*/ position){
+ // summary:
+ // Place this widget somewhere in the DOM based
+ // on standard domConstruct.place() conventions.
+ // description:
+ // 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.
+ // reference:
+ // Widget, DOMNode, DocumentFragment, or id of widget or DOMNode
+ // position:
+ // If reference is a widget (or id of widget), and that widget has an ".addChild" method,
+ // it will be called passing this widget instance into that method, supplying the optional
+ // position index passed. In this case position (if specified) should be an integer.
+ //
+ // If reference is a DOMNode (or id matching a DOMNode but not a widget),
+ // the position argument can be a numeric index or a string
+ // "first", "last", "before", or "after", same as dojo/dom-construct::place().
+ // returns: dijit/_WidgetBase
+ // 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.
+ // example:
+ // | // create a Button with no srcNodeRef, and place it in the body:
+ // | var button = new Button({ label:"click" }).placeAt(win.body());
+ // | // now, 'button' is still the widget reference to the newly created button
+ // | button.on("click", function(e){ console.log('click'); }));
+ // example:
+ // | // create a button out of a node with id="src" and append it to id="wrapper":
+ // | var button = new Button({},"src").placeAt("wrapper");
+ // example:
+ // | // place a new button as the first element of some div
+ // | var button = new Button({ label:"click" }).placeAt("wrapper","first");
+ // example:
+ // | // create a contentpane and add it to a TabContainer
+ // | var tc = dijit.byId("myTabs");
+ // | new ContentPane({ href:"foo.html", title:"Wow!" }).placeAt(tc)
+
+ var refWidget = !reference.tagName && registry.byId(reference);
+ if(refWidget && refWidget.addChild && (!position || typeof position === "number")){
+ // Adding this to refWidget and can use refWidget.addChild() to handle everything.
+ refWidget.addChild(this, position);
+ }else{
+ // "reference" is a plain DOMNode, or we can't use refWidget.addChild(). Use domConstruct.place() and
+ // target refWidget.containerNode for nested placement (position==number, "first", "last", "only"), and
+ // refWidget.domNode otherwise ("after"/"before"/"replace"). (But not supported officially, see #14946.)
+ var ref = refWidget && ("domNode" in refWidget) ?
+ (refWidget.containerNode && !/after|before|replace/.test(position || "") ?
+ refWidget.containerNode : refWidget.domNode) : dom.byId(reference, this.ownerDocument);
+ domConstruct.place(this.domNode, ref, position);
+
+ // Start this iff it has a parent widget that's already started.
+ // TODO: for 2.0 maybe it should also start the widget when this.getParent() returns null??
+ if(!this._started && (this.getParent() || {})._started){
+ this.startup();
+ }
+ }
+ return this;
+ },
+
+ defer: function(fcn, delay){
+ // summary:
+ // Wrapper to setTimeout to avoid deferred functions executing
+ // after the originating widget has been destroyed.
+ // Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
+ // fcn: Function
+ // Function reference.
+ // delay: Number?
+ // Delay, defaults to 0.
+ // tags:
+ // protected
+
+ var timer = setTimeout(lang.hitch(this,
+ function(){
+ if(!timer){
+ return;
+ }
+ timer = null;
+ if(!this._destroyed){
+ lang.hitch(this, fcn)();
+ }
+ }),
+ delay || 0
+ );
+ return {
+ remove: function(){
+ if(timer){
+ clearTimeout(timer);
+ timer = null;
+ }
+ return null; // so this works well: handle = handle.remove();
+ }
+ };
+ }
+ });
+
+ if(has("dojo-bidi")){
+ _WidgetBase.extend(_BidiMixin);
+ }
+
+ return _WidgetBase;
+});
diff --cc dijit/bower.json
index 3ba33e9,0000000..b327276
mode 100644,000000..100644
--- a/dijit/bower.json
+++ b/dijit/bower.json
@@@ -1,22 -1,0 +1,22 @@@
+{
+ "name": "dijit",
+ "main": "main.js",
+ "moduleType": [ "amd" ],
+ "licenses": [ "BSD-3-Clause", "AFL-2.1" ],
+ "ignore": [
+ ".*",
+ "tests"
+ ],
+ "keywords": [ "JavaScript", "Dojo", "Toolkit", "Dijit" ],
+ "authors": [],
+ "homepage": "http://dojotoolkit.org/",
+ "repository":{
+ "type": "git",
+ "url": "https://github.com/dojo/dijit.git"
+ },
+ "dependencies": {
- "dojo": "1.11.0-rc3"
++ "dojo": "1.11.0"
+ },
+ "devDependencies": {
- },
++ }
+}
diff --cc dijit/package.json
index 0260064,0000000..d0a2ed5
mode 100644,000000..100644
--- a/dijit/package.json
+++ b/dijit/package.json
@@@ -1,21 -1,0 +1,21 @@@
+{
+ "name": "dijit",
- "version": "1.11.0-rc3",
++ "version": "1.11.0",
+ "directories": {
+ "lib": "."
+ },
+ "main": "main",
+ "dependencies": {
- "dojo": "1.11.0-rc3"
++ "dojo": "1.11.0"
+ },
+ "description": "Dijit provides a complete collection of user interface controls based on Dojo, giving you the power to create web applications that are highly optimized for usability, performance, internationalization, accessibility, but above all deliver an incredible user experience.",
+ "license" : "BSD-3-Clause OR AFL-2.1",
+ "bugs": "http://bugs.dojotoolkit.org/",
+ "keywords": [ "JavaScript", "Dojo", "Widget" ],
+ "homepage": "http://dojotoolkit.org/",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/dojo/dijit.git"
+ },
+ "dojoBuild": "dijit.profile.js"
+}
diff --cc dijit/tests/_Widget-lifecycle.html
index 9a92dde,0000000..369e37c
mode 100644,000000..100644
--- a/dijit/tests/_Widget-lifecycle.html
+++ b/dijit/tests/_Widget-lifecycle.html
@@@ -1,133 -1,0 +1,156 @@@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+ "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+
+ <title>_WidgetBase lifecycle unit test</title>
+
+ <script src="boilerplate.js"></script>
+
+ <script type="text/javascript">
+ require([
+ "doh/runner",
+ "dojo/_base/declare", "dojo/dom",
+ "dijit/registry", "dijit/_WidgetBase",
+ "dojo/domReady!"
+ ], function(doh, declare, dom, registry, _WidgetBase){
+
+ var obj = {
+ foo: function(){
+ // summary: empty function that we connect to
+ }
+ };
+
+ // Number of times foo was called while TestWidget existed
+ var calls = 0;
+
+ declare("TestWidget", _WidgetBase, {
+ postMixInProperties: function(){
+ // make sure we can call set for parameters that don't touch the DOM
+ this.set("foo", "bar");
+ },
+ postCreate: function(){
+ // Rather odd call to this.connect() For testing the connections are dropped on destroy()
+ this.connect(obj, "foo", function(){
+ calls++;
+ });
+ }
+ });
+
+ var w;
+
+ doh.register("create and destroy", [
+ {
+ name: "create",
+ runTest: function(t){
+ w = new TestWidget({id: "w1"}, "w1");
+
+ doh.t(registry.byId("w1"), "widget in registry");
+
+ // since there's no template, the widget just points to the srcNodeRef
+ doh.is(w.domNode, dom.byId("w1"), "srcNodeRef read in");
+
+ // test the connection
+ doh.is(0, calls, "foo() not called yet");
+ obj.foo();
+ doh.is(1, calls, "foo() called");
+ }
+ },
+ {
+ name: "destroy",
+ runTest: function(t){
+ w.destroy();
+
+ doh.f(registry.byId("w1"), "widget no longer in registry");
+
+ // test the connection was destroyed
+ calls = 0;
+ obj.foo();
+ doh.is(0, calls, "connection was deleted");
+
+ // test the DOM node was removed
+ doh.f(dom.byId("w1"), "DOM Node removed");
+ }
+ },
+ {
+ name: "destroy(true) (preserving DOM node)",
+ runTest: function(t){
+ w = new TestWidget({id: "w2"}, "w2");
+
+ doh.t(registry.byId("w2"), "widget in registry");
+ w.destroy(true);
+
+ doh.f(registry.byId("w2"), "widget no longer in registry");
+
+ // test the DOM node *wasn't* removed
+ doh.t(dom.byId("w2"), "DOM Node left");
+ }
+ },
+ {
+ name: "create with undefined id",
+ runTest: function(t){
+ // If id is "specified" as undefined, generate a new one
+ w = new TestWidget({id: undefined});
+
+ doh.isNot(undefined, w.id)
+ }
- }
++ },
++ {
++ name: "create where id specified in prototype",
++ runTest: function(t){
++ declare("TestWidgetWithId", _WidgetBase, {
++ id: "id-in-prototype"
++ });
++
++ // Creating without an id should use the id in the prototype
++ w = new TestWidgetWithId();
++ w.placeAt(document.body);
++ doh.t(registry.byId("id-in-prototype"), "widget in registry");
++ doh.is(w.domNode, dom.byId("id-in-prototype"), "id on domnode");
++ w.destroy();
++
++ // Then try overriding id
++ w = new TestWidgetWithId({id: "override"});
++ w.placeAt(document.body);
++ doh.t(registry.byId("override"), "widget in registry");
++ doh.is(w.domNode, dom.byId("override"), "id on domnode");
++ w.destroy();
++ }
++ },
++
+ ]);
+
+ doh.register("setter calls on creation", function(){
+ // Make sure setters are called even for anonymous classes (#12122),
+ // and even when there's no value explicitly specified in the parameters
+ var fooSetterCalled,
+ MyWidget = declare(_WidgetBase, {
+ foo: 345,
+ _setFooAttr: function(val){
+ fooSetterCalled = val;
+ this._set("foo", val);
+ }
+ });
+
+ new MyWidget();
+
+ doh.is(345, fooSetterCalled, "fooSetterCalled");
+ });
+
+ doh.register("tweaking params in postMixInProperties", function(){
+ // Tests that property changes in postMixInProperties() are not lost (#16080)
+ var Test = declare(_WidgetBase, { foo: "bar", postMixInProperties: function(){ this.foo = "baz"; } });
+ var t = new Test({ foo: "blah" });
+ doh.is("baz", t.foo);
+ });
+
+ doh.run();
+ });
+
+ </script>
+</head>
+<body>
+ <div id="w1"></div>
+ <div id="w2"></div>
+</body>
+</html>
diff --cc dijit/tests/layout/robot/TabContainer_a11y.html
index 2d47a5e,0000000..54b7ac2
mode 100644,000000..100644
--- a/dijit/tests/layout/robot/TabContainer_a11y.html
+++ b/dijit/tests/layout/robot/TabContainer_a11y.html
@@@ -1,590 -1,0 +1,591 @@@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+ "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+ <head>
+ <title>robot TabContainer A11Y Test</title>
+
+ <style>
+ @import "../../../../util/doh/robot/robot.css";
+ </style>
+
+ <!-- required: dojo.js -->
+ <script type="text/javascript" src="../../../../dojo/dojo.js"
+ data-dojo-config="isDebug: true"></script>
+
+ <script type="text/javascript">
+ require([
+ "doh/runner", "dojo/robotx",
+ "dojo/dom", "dojo/keys", "dojo/query", "dojo/sniff", "dojo/window",
+ "dijit/tests/helpers"
+ ], function(doh, robot, dom, keys, query, has, winUtils, helpers){
+
+ robot.initRobot('../test_TabContainer.html');
+
+ var registry;
+
+ doh.register("setup", [
+ function setup(){
+ // get pointers to singletons loaded on test page
+ registry = robot.window.require("dijit/registry");
+ }
+ ]);
+
+ doh.register("aria", [
+ {
+ name: "tab container attributes",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+ var tc = registry.byId("mainTabContainer");
+
+ doh.is("tabpanel", tc.containerNode.children[0].getAttribute("role"), "containerNode child role");
+ doh.is("mainTabContainer_tablist_tab1", tc.containerNode.children[0].getAttribute("aria-labelledby"), "containerNode.child (the tabpanel) labelledby");
+
+ var tablist = tc.tablist;
+
+ // The tablist that stretches across the top
+ doh.is("tablist", tablist.containerNode.getAttribute("role"), "tablist role");
+ doh.is("tab", tablist.getChildren()[0].focusNode.getAttribute("role"), "tablist child's role should be tab");
+
+ // Now the drop down button
+ doh.is("button", tablist._menuBtn.domNode.getAttribute("role"), "_menuBtn role");
+ doh.f(tablist._menuBtn.domNode.getAttribute("aria-expanded"), "aria-expanded should initially be absent");
+ doh.f(tablist._menuBtn.domNode.getAttribute("aria-owns"), "aria-owns should initially be absent");
+
+ // Now open the drop down to verify changes in aria-expanded, aria-owns, and aria-labelledby
+ tablist._menuBtn.focus();
+ robot.keyPress(keys.ENTER, 500, {});
+
+ robot.sequence(d.getTestCallback(function(){
+ doh.t(tablist._menuBtn.domNode.getAttribute("aria-expanded"), "aria-expanded with open dropdown");
+ doh.is("mainTabContainer_menu", tablist._menuBtn.domNode.getAttribute("aria-owns"), "menuBtn should own the menu dropdown");
+
+ var menu = registry.byId("mainTabContainer_menu");
+ doh.is("menu", menu.domNode.getAttribute("role"), "the dropdown role");
+ doh.is("mainTabContainer_tablist_menuBtn", menu.domNode.getAttribute("aria-labelledby"), "aria-labelledby on menu dropdown");
+
+ }), 500);
+
+ return d;
+ }
+ }
+ ]);
+
+ doh.register("basic navigation", [
+ {
+ name: "focus on button before TabContainer",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ // Note: for this to work, focus needs to start somewhere else; otherwise there will be no
+ // focus event.
+ helpers.onFocus(d.getTestCallback(function(node){
+ }));
+
+ query("button")[0].focus();
+
+ return d;
+ }
+ },
+ {
+ name: "tab into main TabContainer",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is("mainTabContainer_tablist_tab2", node.id, "focus");
+ }));
+
+ robot.keyPress(keys.TAB, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "move to tab 3 with RIGHT arrow",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ var tc = registry.byId("mainTabContainer");
+ doh.is('mainTabContainer_tablist_tab3', node.id, "currently chosen tab");
+ doh.is("tab3", tc.selectedChildWidget.id, "currently displayed pane");
+ }));
+
+ robot.keyPress(keys.RIGHT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "move to tab 2 with LEFT arrow",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ var tc = registry.byId("mainTabContainer");
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_tab2', node.id, "currently chosen tab");
+ doh.is("tab2", tc.selectedChildWidget.id, "currently chosen pane");
+ }));
+
+ robot.keyPress(keys.LEFT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+
+ {
+ name: "move to tab 3 again with RIGHT arrow",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ }));
+
+ robot.keyPress(keys.RIGHT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "move to inlined subcontainer tab with RIGHT arrow",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ }));
+
+ robot.keyPress(keys.RIGHT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+
+ {
+ name: "TAB focus to nested tab",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('inlined_tablist_tab2href', node.id);
+ }));
+
+ robot.keyPress(keys.TAB, 750);
+
+ return d;
+ }
+ },
+
+ {
+ name: "move to second nested tab button",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ }));
+
+ robot.keyPress(keys.RIGHT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "shift-TAB to parent tabs from nested tabs",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ }));
+
+ robot.keyPress(keys.TAB, 750, {shift:true});
+
+ return d;
+ }
+ },
+ {
+ name: "left arrow to tab 3",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_tab3', node.id);
+ }));
+
+ robot.keyPress(keys.LEFT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "right arrow to inline subtabcontainer",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ }));
+
+ robot.keyPress(keys.RIGHT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "verify nested tablist keeps it's state",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ //verify that the third nested tab is still selected
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('inlined_tablist_subtab3', node.id);
+ }));
+
+ robot.keyPress(keys.TAB, 750, {}); // give IE8 time to complete slide animation
+
+ return d;
+ }
+ }
+ ]);
+
+ doh.register("HOME/END keys", [
+ {
+ name: "focus tab 3",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ registry.byId("mainTabContainer").selectChild(registry.byId("tab3"), false);
+
+ setTimeout(d.getTestErrback(function(){
+ // on IE the focus event lands after control releases (after the NEXT test has set its focus handler) so do 0 timeout to let focus happen
+ dom.byId("mainTabContainer_tablist_tab3href").focus();
+ setTimeout(d.getTestCallback(function(){}),0);
+ }), 500);
+
+ return d;
+ }
+ },
+ {
+ name: "home key",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_tab1', node.id);
+ }));
+
+ robot.keyPress(keys.HOME, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "end key",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_embedded', node.id);
+ }));
+
+ robot.keyPress(keys.END, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "verify left/right arrows still work",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_tab4href', node.id);
+ }));
+
+ robot.keyPress(keys.LEFT_ARROW, 500, {});
+
+ return d;
+ }
+ }
+ ]);
+
+ doh.register("disabled tabs",[
+ {
+ name: "setup",
+ runTest: function(){
+
+ // disable first, last, and middle tab
+ registry.byId("tab1").set("disabled", true);
+ registry.byId("tab3").set("disabled", true);
+ registry.byId("embedded").set("disabled", true);
+
+ // set second tab as selected
+ registry.byId("mainTabContainer").selectChild(registry.byId("tab2"));
+ }
+ },
+
+ {
+ name: "focus on button before TabContainer",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ }));
+
+ query("button")[0].focus();
+
+ return d;
+ }
+ },
+ {
+ name: "tab into main TabContainer",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is("mainTabContainer_tablist_tab2", node.id, "focus");
+ }));
+
+ robot.keyPress(keys.TAB, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "skip over tab 3 with RIGHT arrow",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ var tc = registry.byId("mainTabContainer");
+ doh.is('mainTabContainer_tablist_inlined', node.id, "currently chosen tab");
+ doh.is("inlined", tc.selectedChildWidget.id, "currently displayed pane");
+ }));
+
+ robot.keyPress(keys.RIGHT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "skip over tab 3 with LEFT arrow",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ var tc = registry.byId("mainTabContainer");
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_tab2', node.id, "currently chosen tab");
+ doh.is("tab2", tc.selectedChildWidget.id, "currently chosen pane");
+ }));
+
+ robot.keyPress(keys.LEFT_ARROW, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "end key should skip disabled tab",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_tab4href', node.id);
+ }));
+
+ robot.keyPress(keys.END, 500, {});
+
+ return d;
+ }
+ },
+ {
+ name: "home key should skip disabled tab",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('mainTabContainer_tablist_tab2', node.id);
+ }));
+
+ robot.keyPress(keys.HOME, 500, {});
+
+ return d;
+ }
+ },
+
+ {
+ name: "teardown",
+ runTest: function(){
+ // disable first, last, and middle tab
+ registry.byId("tab1").set("disabled", false);
+ registry.byId("tab3").set("disabled", false);
+ registry.byId("embedded").set("disabled", false);
+ }
+ }
+ ]);
+
+ doh.register("closing tabs", [
+ {
+ name: "close tab with DELETE button",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ var tc = registry.byId("mainTabContainer");
+
+ // Select "SplitContainer from href tab"
+ tc.selectChild("tab4href");
+
+ // Go to "Embedded layout widgets" tab, and close it.
+ // This puts focus back on "SplitContainer from href".
+ robot.keyPress(keys.RIGHT_ARROW, 500, {});
+ robot.keyPress(keys.DELETE, 750, {});
+
+ robot.sequence(d.getTestCallback(function(){
+ doh.is(6, tc.getChildren().length, "six tabs left");
+ doh.is("tab4href", tc.selectedChildWidget.id, "selection moved to previous tab");
+ }), 500);
+
+ return d;
+ }
+ },
+ {
+ name: "close tab with CTRL-W button",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ robot.sequence(function(){
+ dom.byId("mainTabContainer_tablist_tab1").focus();
+ }, 500);
+
+ // Go to "Tab 3", and close it.
+ // This puts the focus back on "Tab 2".
+ robot.keyPress(keys.LEFT_ARROW, 500, {});
+ robot.keyPress(keys.LEFT_ARROW, 750, {});
+ robot.keyPress(keys.LEFT_ARROW, 750, {});
+ if(has("chrome")){
+ // on chrome ctrl+w isn't trapped, and closes the whole browser!
+ robot.keyPress(keys.DELETE, 750, {});
+ }else{
+ robot.keyPress("w", 750, {ctrl:true});
+ }
+
+ var tc = registry.byId("mainTabContainer");
+ robot.sequence(d.getTestCallback(function(){
+ doh.is(5, tc.getChildren().length);
+ doh.is("tab2", tc.selectedChildWidget.id, "selection moved to previous tab");
+ }), 500);
+ return d;
+ }
+ }
+ ]);
+
+ // Run test about opening context menu via keyboard, except on:
+ // - safari/mac where it doesn't work unless VoiceOver is turned on (#9927)
+ // - webkit/win, where in suite mode (runTests.html), F10 triggers context menu
+ // in both the iframe and the outer window
+ if(!has("webkit")){
+ doh.register("closing tabs via context menu", {
+ name: "close tab through context menu",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ var tc = registry.byId("ttabs");
+ winUtils.scrollIntoView(tc.domNode);
++ doh.is(4, tc.getChildren().length, "num tabs before trying to close one");
+
+ dom.byId("ttabs_tablist_ttab1").focus();
+
+ // Open context menu via keyboard
+ if(has("mac")){
+ robot.keyPress(keys.SPACE, 500, {
+ ctrl: true
+ });
+ }else{
+ robot.keyPress(keys.F10, 500, {
+ shift: true
+ });
+ }
+
+ // Close tab
+ robot.keyPress(keys.ENTER, 500, {});
+
+ robot.sequence(d.getTestCallback(function(){
- doh.is(2, tc.getChildren().length, "remaining tabs");
++ doh.is(3, tc.getChildren().length, "remaining tabs");
+ doh.is("ttab2", tc.selectedChildWidget.id,
+ "selection moved to next tab (since first tab was deleted)");
+ }), 500);
+
+ return d;
+ }
+ });
+ }
+
+ doh.register("up/down arrows", [
+ {
+ name: "move to tab with DOWN button",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ var tc = registry.byId("ltabs");
+ winUtils.scrollIntoView(tc.domNode);
+
+ dom.byId("ltabs_tablist_HanselGretel1").focus();
+ setTimeout(d.getTestErrback(function(){
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('ltabs_tablist_GreenTwigs1', node.id, "currently chosen tab");
+ doh.is("GreenTwigs1", tc.selectedChildWidget.id, "currently displayed pane");
+ }));
+
+ robot.keyPress(keys.DOWN_ARROW, 500, {});
+ }), 0);
+
+ return d;
+ }
+ },
+ {
+ name: "move to tab with UP button",
+ timeout: 10000,
+ runTest: function(t){
+ var d = new doh.Deferred();
+
+ var tc = registry.byId("ltabs");
+ helpers.onFocus(d.getTestCallback(function(node){
+ doh.is('ltabs_tablist_HanselGretel1', node.id, "currently chosen tab");
+ doh.is("HanselGretel1", tc.selectedChildWidget.id, "currently chosen pane");
+ }));
+
+ robot.keyPress(keys.UP_ARROW, 500, {});
+
+ return d;
+ }
+ }
+ ]);
+
+ doh.run();
+ });
+ </script>
+ </head>
+</html>
diff --cc dijit/themes/dijit.css
index 6218359,0000000..3d2118e
mode 100644,000000..100644
--- a/dijit/themes/dijit.css
+++ b/dijit/themes/dijit.css
@@@ -1,2244 -1,0 +1,2248 @@@
+/*
+ Essential styles that themes can inherit.
+ In other words, works but doesn't look great.
+*/
+
+
+
+/****
+ GENERIC PIECES
+ ****/
+
+.dijitReset {
+ /* Use this style to null out padding, margin, border in your template elements
+ so that page specific styles don't break them.
+ - Use in all TABLE, TR and TD tags.
+ */
+ margin:0;
+ border:0;
+ padding:0;
+ font: inherit;
+ line-height:normal;
+ color: inherit;
+}
+.dj_a11y .dijitReset {
+ -moz-appearance: none; /* remove predefined high-contrast styling in Firefox */
+}
+
+.dijitInline {
+ /* To inline block elements.
+ Similar to InlineBox below, but this has fewer side-effects in Moz.
+ Also, apparently works on a DIV as well as a FIELDSET.
+ */
+ display:inline-block; /* webkit and FF3 */
+ #zoom: 1; /* set hasLayout:true to mimic inline-block */
+ #display:inline; /* don't use .dj_ie since that increases the priority */
+ border:0;
+ padding:0;
+ vertical-align:middle;
+ #vertical-align: auto; /* makes TextBox,Button line up w/native counterparts on IE6 */
+}
+
+table.dijitInline {
+ /* To inline tables with a given width set */
+ display:inline-table;
+ box-sizing: content-box; -moz-box-sizing: content-box;
+}
+
+.dijitHidden {
+ /* To hide unselected panes in StackContainer etc. */
+ position: absolute; /* remove from normal document flow to simulate display: none */
+ visibility: hidden; /* hide element from view, but don't break scrolling, see #18612 */
+}
++.dijitHidden * {
++ visibility: hidden !important; /* hide visibility:visible descendants of class=dijitHidden nodes, see #18799 */
++}
+
+.dijitVisible {
+ /* To show selected pane in StackContainer etc. */
+ display: block !important; /* override user's display:none setting via style setting or indirectly via class */
+ position: relative; /* to support setting width/height, see #2033 */
++ visibility: visible;
+}
+
+.dj_ie6 .dijitComboBox .dijitInputContainer,
+.dijitInputContainer {
+ /* for positioning of placeHolder */
+ #zoom: 1;
+ overflow: hidden;
+ float: none !important; /* needed to squeeze the INPUT in */
+ position: relative;
+}
+.dj_ie7 .dijitInputContainer {
+ float: left !important; /* needed by IE to squeeze the INPUT in */
+ clear: left;
+ display: inline-block !important; /* to fix wrong text alignment in textdir=rtl text box */
+}
+
+.dj_ie .dijitSelect input,
+.dj_ie input.dijitTextBox,
+.dj_ie .dijitTextBox input {
+ font-size: 100%;
+}
+.dijitSelect .dijitButtonText {
+ float: left;
+ vertical-align: top;
+}
+TABLE.dijitSelect {
+ padding: 0 !important; /* messes up border alignment */
+ border-collapse: separate; /* so jsfiddle works with Normalized CSS checked */
+}
+.dijitTextBox .dijitSpinnerButtonContainer,
+.dijitTextBox .dijitArrowButtonContainer,
+.dijitValidationTextBox .dijitValidationContainer {
+ float: right;
+ text-align: center;
+}
+.dijitSelect input.dijitInputField,
+.dijitTextBox input.dijitInputField {
+ /* override unreasonable user styling of buttons and icons */
+ padding-left: 0 !important;
+ padding-right: 0 !important;
+}
+.dijitValidationTextBox .dijitValidationContainer {
+ display: none;
+}
+
+.dijitTeeny {
+ font-size:1px;
+ line-height:1px;
+}
+
+.dijitOffScreen { /* these class attributes should supersede any inline positioning style */
+ position: absolute !important;
+ left: -10000px !important;
+ top: -10000px !important;
+}
+
+/*
+ * Popup items have a wrapper div (dijitPopup)
+ * with the real popup inside, and maybe an iframe too
+ */
+.dijitPopup {
+ position: absolute;
+ background-color: transparent;
+ margin: 0;
+ border: 0;
+ padding: 0;
+ -webkit-overflow-scrolling: touch;
+}
+
+.dijitPositionOnly {
+ /* Null out all position-related properties */
+ padding: 0 !important;
+ border: 0 !important;
+ background-color: transparent !important;
+ background-image: none !important;
+ height: auto !important;
+ width: auto !important;
+}
+
+.dijitNonPositionOnly {
+ /* Null position-related properties */
+ float: none !important;
+ position: static !important;
+ margin: 0 0 0 0 !important;
+ vertical-align: middle !important;
+}
+
+.dijitBackgroundIframe {
+ /* iframe used to prevent problems with PDF or other applets overlaying menus etc */
+ position: absolute;
+ left: 0;
+ top: 0;
+ width: 100%;
+ height: 100%;
+ z-index: -1;
+ border: 0;
+ padding: 0;
+ margin: 0;
+}
+
+.dijitDisplayNone {
+ /* hide something. Use this as a class rather than element.style so another class can override */
+ display:none !important;
+}
+
+.dijitContainer {
+ /* for all layout containers */
+ overflow: hidden; /* need on IE so something can be reduced in size, and so scrollbars aren't temporarily displayed when resizing */
+}
+
+/****
+ A11Y
+ ****/
+.dj_a11y .dijitIcon,
+.dj_a11y div.dijitArrowButtonInner, /* is this only for Spinner? if so, it should be deleted */
+.dj_a11y span.dijitArrowButtonInner,
+.dj_a11y img.dijitArrowButtonInner,
+.dj_a11y .dijitCalendarIncrementControl,
+.dj_a11y .dijitTreeExpando {
+ /* hide icon nodes in high contrast mode; when necessary they will be replaced by character equivalents
+ * exception for input.dijitArrowButtonInner, because the icon and character are controlled by the same node */
+ display: none;
+}
+.dijitSpinner div.dijitArrowButtonInner {
+ display: block; /* override previous rule */
+}
+
+.dj_a11y .dijitA11ySideArrow {
+ display: inline !important; /* display text instead */
+ cursor: pointer;
+}
+
+/*
+ * Since we can't use shading in a11y mode, and since the underline indicates today's date,
+ * use a border to show the selected date.
+ * Avoid screen jitter when switching selected date by compensating for the selected node's
+ * border w/padding on other nodes.
+ */
+.dj_a11y .dijitCalendarDateLabel {
+ padding: 1px;
+ border: 0px !important;
+}
+.dj_a11y .dijitCalendarSelectedDate .dijitCalendarDateLabel {
+ border-style: solid !important;
+ border-width: 1px !important;
+ padding: 0;
+}
+.dj_a11y .dijitCalendarDateTemplate {
+ padding-bottom: 0.1em !important; /* otherwise bottom border doesn't appear on IE */
+ border: 0px !important;
+}
+.dj_a11y .dijitButtonNode {
+ border: black outset medium !important;
+
+ /* In claro, hovering a toolbar button reduces padding and adds a border.
+ * Not needed in a11y mode since Toolbar buttons always have a border.
+ */
+ padding: 0 !important;
+}
+.dj_a11y .dijitArrowButton {
+ padding: 0 !important;
+}
+
+.dj_a11y .dijitButtonContents {
+ margin: 0.15em; /* Margin needed to make focus outline visible */
+}
+
+.dj_a11y .dijitTextBoxReadOnly .dijitInputField,
+.dj_a11y .dijitTextBoxReadOnly .dijitButtonNode {
+ border-style: outset!important;
+ border-width: medium!important;
+ border-color: #999 !important;
+ color:#999 !important;
+}
+
+/* button inner contents - labels, icons etc. */
+.dijitButtonNode * {
+ vertical-align: middle;
+}
+.dijitSelect .dijitArrowButtonInner,
+.dijitButtonNode .dijitArrowButtonInner {
+ /* the arrow icon node */
+ background: no-repeat center;
+ width: 12px;
+ height: 12px;
+ direction: ltr; /* needed by IE/RTL */
+}
+
+/****
+ 3-element borders: ( dijitLeft + dijitStretch + dijitRight )
+ These were added for rounded corners on dijit.form.*Button but never actually used.
+ ****/
+
+.dijitLeft {
+ /* Left part of a 3-element border */
+ background-position:left top;
+ background-repeat:no-repeat;
+}
+
+.dijitStretch {
+ /* Middle (stretchy) part of a 3-element border */
+ white-space:nowrap; /* MOW: move somewhere else */
+ background-repeat:repeat-x;
+}
+
+.dijitRight {
+ /* Right part of a 3-element border */
+ #display:inline; /* IE7 sizes to outer size w/o this */
+ background-position:right top;
+ background-repeat:no-repeat;
+}
+
+/* Buttons */
+.dj_gecko .dj_a11y .dijitButtonDisabled .dijitButtonNode {
+ opacity: 0.5;
+}
+
+.dijitToggleButton,
+.dijitButton,
+.dijitDropDownButton,
+.dijitComboButton {
+ /* outside of button */
+ margin: 0.2em;
+ vertical-align: middle;
+}
+
+.dijitButtonContents {
+ display: block; /* to make focus border rectangular */
+}
+td.dijitButtonContents {
+ display: table-cell; /* but don't affect Select, ComboButton */
+}
+
+.dijitButtonNode img {
+ /* make text and images line up cleanly */
+ vertical-align:middle;
+ /*margin-bottom:.2em;*/
+}
+
+.dijitToolbar .dijitComboButton {
+ /* because Toolbar only draws a border around the hovered thing */
+ border-collapse: separate;
+}
+
+.dijitToolbar .dijitToggleButton,
+.dijitToolbar .dijitButton,
+.dijitToolbar .dijitDropDownButton,
+.dijitToolbar .dijitComboButton {
+ margin: 0;
+}
+
+.dijitToolbar .dijitButtonContents {
+ /* just because it used to be this way */
+ padding: 1px 2px;
+}
+
+
+.dj_webkit .dijitToolbar .dijitDropDownButton {
+ padding-left: 0.3em;
+}
+.dj_gecko .dijitToolbar .dijitButtonNode::-moz-focus-inner {
+ padding:0;
+}
+
+.dijitSelect {
+ border:1px solid gray;
+}
+.dijitButtonNode {
+ /* Node that is acting as a button -- may or may not be a BUTTON element */
+ border:1px solid gray;
+ margin:0;
+ line-height:normal;
+ vertical-align: middle;
+ #vertical-align: auto;
+ text-align:center;
+ white-space: nowrap;
+}
+.dj_webkit .dijitSpinner .dijitSpinnerButtonContainer {
+ /* apparent WebKit bug where messing with the font coupled with line-height:normal X 2 (dijitReset & dijitButtonNode)
+ can be different than just a single line-height:normal, visible in InlineEditBox/Spinner */
+ line-height:inherit;
+}
+.dijitTextBox .dijitButtonNode {
+ border-width: 0;
+}
+
+.dijitSelect,
+.dijitSelect *,
+.dijitButtonNode,
+.dijitButtonNode * {
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+
+.dj_ie .dijitButtonNode {
+ /* ensure hasLayout */
+ zoom: 1;
+}
+
+.dj_ie .dijitButtonNode button {
+ /*
+ disgusting hack to get rid of spurious padding around button elements
+ on IE. MSIE is truly the web's boat anchor.
+ */
+ overflow: visible;
+}
+
+div.dijitArrowButton {
+ float: right;
+}
+
+/******
+ TextBox related.
+ Everything that has an <input>
+*******/
+
+.dijitTextBox {
+ border: solid black 1px;
+ #overflow: hidden; /* #6027, #6067 */
+ width: 15em; /* need to set default size on outer node since inner nodes say <input style="width:100%"> and <td width=100%>. user can override */
+ vertical-align: middle;
+}
+
+.dijitTextBoxReadOnly,
+.dijitTextBoxDisabled {
+ color: gray;
+}
+.dj_safari .dijitTextBoxDisabled input {
+ color: #B0B0B0; /* because Safari lightens disabled input/textarea no matter what color you specify */
+}
+.dj_safari textarea.dijitTextAreaDisabled {
+ color: #333; /* because Safari lightens disabled input/textarea no matter what color you specify */
+}
+.dj_gecko .dijitTextBoxReadOnly input.dijitInputField, /* disable arrow and validation presentation inputs but allow real input for text selection */
+.dj_gecko .dijitTextBoxDisabled input {
+ -moz-user-input: none; /* prevent focus of disabled textbox buttons */
+}
+
+.dijitPlaceHolder {
+ /* hint text that appears in a textbox until user starts typing */
+ color: #AAAAAA;
+ font-style: italic;
+ position: absolute;
+ top: 0;
+ left: 0;
+ #filter: ""; /* make this show up in IE6 after the rendering of the widget */
+ white-space: nowrap;
+ pointer-events: none; /* so cut/paste context menu shows up when right clicking */
+}
+
+.dijitTimeTextBox {
+ width: 8em;
+}
+
+/* rules for webkit to deal with fuzzy blue focus border */
+.dijitTextBox input:focus {
+ outline: none; /* blue fuzzy line looks wrong on combobox or something w/validation icon showing */
+}
+.dijitTextBoxFocused {
+ outline: 5px -webkit-focus-ring-color;
+}
+
+.dijitSelect input,
+.dijitTextBox input {
+ float: left; /* needed by IE to remove secret margin */
+}
+.dj_ie6 input.dijitTextBox,
+.dj_ie6 .dijitTextBox input {
+ float: none;
+}
+.dijitInputInner {
+ /* for when an <input> is embedded inside an inline-block <div> with a size and border */
+ border:0 !important;
+ background-color:transparent !important;
+ width:100% !important;
+ /* IE dislikes horizontal tweaking combined with width:100% so punish everyone for consistency */
+ padding-left: 0 !important;
+ padding-right: 0 !important;
+ margin-left: 0 !important;
+ margin-right: 0 !important;
+}
+.dj_a11y .dijitTextBox input {
+ margin: 0 !important;
+}
+.dijitValidationTextBoxError input.dijitValidationInner,
+.dijitSelect input,
+.dijitTextBox input.dijitArrowButtonInner {
+ /* <input> used to display arrow icon/validation icon, or in arrow character in high contrast mode.
+ * The css below is a trick to hide the character in non-high-contrast mode
+ */
+ text-indent: -2em !important;
+ direction: ltr !important;
+ text-align: left !important;
+ height: auto !important;
+ #text-indent: 0 !important;
+ #letter-spacing: -5em !important;
+ #text-align: right !important;
+}
+.dj_ie .dijitSelect input,
+.dj_ie .dijitTextBox input,
+.dj_ie input.dijitTextBox {
+ overflow-y: visible; /* inputs need help expanding when padding is added or line-height is adjusted */
+ line-height: normal; /* strict mode */
+}
+.dijitSelect .dijitSelectLabel span {
+ line-height: 100%;
+}
+.dj_ie .dijitSelect .dijitSelectLabel {
+ line-height: normal;
+}
+.dj_ie6 .dijitSelect .dijitSelectLabel,
+.dj_ie7 .dijitSelect .dijitSelectLabel,
+.dj_ie8 .dijitSelect .dijitSelectLabel,
+.dj_iequirks .dijitSelect .dijitSelectLabel,
+.dijitSelect td,
+.dj_ie6 .dijitSelect input,
+.dj_iequirks .dijitSelect input,
+.dj_ie6 .dijitSelect .dijitValidationContainer,
+.dj_ie6 .dijitTextBox input,
+.dj_ie6 input.dijitTextBox,
+.dj_iequirks .dijitTextBox input.dijitValidationInner,
+.dj_iequirks .dijitTextBox input.dijitArrowButtonInner,
+.dj_iequirks .dijitTextBox input.dijitSpinnerButtonInner,
+.dj_iequirks .dijitTextBox input.dijitInputInner,
+.dj_iequirks input.dijitTextBox {
+ line-height: 100%; /* IE7 problem where the icon is vertically way too low w/o this */
+}
+.dj_a11y input.dijitValidationInner,
+.dj_a11y input.dijitArrowButtonInner {
+ /* (in high contrast mode) revert rules from above so character displays */
+ text-indent: 0 !important;
+ width: 1em !important;
+ #text-align: left !important;
+ color: black !important;
+}
+.dijitValidationTextBoxError .dijitValidationContainer {
+ display: inline;
+ cursor: default;
+}
+
+/* ComboBox & Spinner */
+
+.dijitSpinner .dijitSpinnerButtonContainer,
+.dijitComboBox .dijitArrowButtonContainer {
+ /* dividing line between input area and up/down button(s) for ComboBox and Spinner */
+ border-width: 0 0 0 1px !important; /* !important needed due to wayward ".theme .dijitButtonNode" rules */
+}
+.dj_a11y .dijitSelect .dijitArrowButtonContainer,
+.dijitToolbar .dijitComboBox .dijitArrowButtonContainer {
+ /* overrides above rule plus mirror-image rule in dijit_rtl.css to have no divider when ComboBox in Toolbar */
+ border-width: 0 !important;
+}
+
+.dijitComboBoxMenu {
+ /* Drop down menu is implemented as <ul> <li/> <li/> ... but we don't want circles before each item */
+ list-style-type: none;
+}
+.dijitSpinner .dijitSpinnerButtonContainer .dijitButtonNode {
+ /* dividing line between input area and up/down button(s) for ComboBox and Spinner */
+ border-width: 0;
+}
+.dj_ie .dj_a11y .dijitSpinner .dijitSpinnerButtonContainer .dijitButtonNode {
+ clear: both; /* IE workaround */
+}
+
+.dj_ie .dijitToolbar .dijitComboBox {
+ /* make combobox buttons align properly with other buttons in a toolbar */
+ vertical-align: middle;
+}
+
+/* Spinner */
+
+.dijitTextBox .dijitSpinnerButtonContainer {
+ width: 1em;
+ position: relative !important;
+ overflow: hidden;
+}
+.dijitSpinner .dijitSpinnerButtonInner {
+ width:1em;
+ visibility:hidden !important; /* just a sizing element */
+ overflow-x:hidden;
+}
+.dijitComboBox .dijitButtonNode,
+.dijitSpinnerButtonContainer .dijitButtonNode {
+ border-width: 0;
+}
+.dj_a11y .dijitSpinnerButtonContainer .dijitButtonNode {
+ border-width: 0px !important;
+ border-style: solid !important;
+}
+.dj_a11y .dijitTextBox .dijitSpinnerButtonContainer,
+.dj_a11y .dijitSpinner .dijitArrowButtonInner,
+.dj_a11y .dijitSpinnerButtonContainer input {
+ width: 1em !important;
+}
+.dj_a11y .dijitSpinner .dijitArrowButtonInner {
+ margin: 0 auto !important; /* should auto-center */
+}
+.dj_ie .dj_a11y .dijitSpinner .dijitArrowButtonInner .dijitInputField {
+ padding-left: 0.3em !important;
+ padding-right: 0.3em !important;
+ margin-left: 0.3em !important;
+ margin-right: 0.3em !important;
+ width: 1.4em !important;
+}
+.dj_ie7 .dj_a11y .dijitSpinner .dijitArrowButtonInner .dijitInputField {
+ padding-left: 0 !important; /* manually center INPUT: character is .5em and total width = 1em */
+ padding-right: 0 !important;
+ width: 1em !important;
+}
+.dj_ie6 .dj_a11y .dijitSpinner .dijitArrowButtonInner .dijitInputField {
+ margin-left: 0.1em !important;
+ margin-right: 0.1em !important;
+ width: 1em !important;
+}
+.dj_iequirks .dj_a11y .dijitSpinner .dijitArrowButtonInner .dijitInputField {
+ margin-left: 0 !important;
+ margin-right: 0 !important;
+ width: 2em !important;
+}
+.dijitSpinner .dijitSpinnerButtonContainer .dijitArrowButton {
+ /* note: .dijitInputLayoutContainer makes this rule override .dijitArrowButton settings
+ * for dijit.form.Button
+ */
+ padding: 0;
+ position: absolute !important;
+ right: 0;
+ float: none;
+ height: 50%;
+ width: 100%;
+ bottom: auto;
+ left: 0;
+ right: auto;
+}
+.dj_iequirks .dijitSpinner .dijitSpinnerButtonContainer .dijitArrowButton {
+ width: auto;
+}
+.dj_a11y .dijitSpinnerButtonContainer .dijitArrowButton {
+ overflow: visible !important;
+}
+.dijitSpinner .dijitSpinnerButtonContainer .dijitDownArrowButton {
+ top: 50%;
+ border-top-width: 1px !important;
+}
+.dijitSpinner .dijitSpinnerButtonContainer .dijitUpArrowButton {
+ #bottom: 50%; /* otherwise (on some machines) top arrow icon too close to splitter border (IE6/7) */
+ top: 0;
+}
+.dijitSpinner .dijitArrowButtonInner {
+ margin: auto;
+ overflow-x: hidden;
+ height: 100% !important;
+}
+.dj_iequirks .dijitSpinner .dijitArrowButtonInner {
+ height: auto !important;
+}
+.dijitSpinner .dijitArrowButtonInner .dijitInputField {
+ -moz-transform: scale(0.5);
+ -moz-transform-origin: center top;
+ -webkit-transform: scale(0.5);
+ -webkit-transform-origin: center top;
+ -o-transform: scale(0.5);
+ -o-transform-origin: center top;
+ transform: scale(0.5);
+ transform-origin: left top;
+ padding-top: 0;
+ padding-bottom: 0;
+ padding-left: 0 !important;
+ padding-right: 0 !important;
+ width: 100%;
+ visibility: hidden;
+}
+.dj_ie .dijitSpinner .dijitArrowButtonInner .dijitInputField {
+ zoom: 50%; /* emulate transform: scale(0.5) */
+}
+.dijitSpinner .dijitSpinnerButtonContainer .dijitArrowButtonInner {
+ overflow: hidden;
+}
+
+.dj_a11y .dijitSpinner .dijitSpinnerButtonContainer .dijitArrowButton {
+ width: 100%;
+}
+.dj_iequirks .dj_a11y .dijitSpinner .dijitSpinnerButtonContainer .dijitArrowButton {
+ width: 1em; /* matches .dj_a11y .dijitTextBox .dijitSpinnerButtonContainer rule - 100% is the whole screen width in quirks */
+}
+.dj_a11y .dijitSpinner .dijitArrowButtonInner .dijitInputField {
+ vertical-align:top;
+ visibility: visible;
+}
+.dj_a11y .dijitSpinnerButtonContainer {
+ width: 1em;
+}
+
+/****
+ dijit.form.CheckBox
+ &
+ dijit.form.RadioButton
+ ****/
+
+.dijitCheckBox,
+.dijitRadio,
+.dijitCheckBoxInput {
+ padding: 0;
+ border: 0;
+ width: 16px;
+ height: 16px;
+ background-position:center center;
+ background-repeat:no-repeat;
+ overflow: hidden;
+}
+
+.dijitCheckBox input,
+.dijitRadio input {
+ margin: 0;
+ padding: 0;
+ display: block;
+}
+
+.dijitCheckBoxInput {
+ /* place the actual input on top, but invisible */
+ opacity: 0;
+}
+
+.dj_ie .dijitCheckBoxInput {
+ filter: alpha(opacity=0);
+}
+
+.dj_a11y .dijitCheckBox,
+.dj_a11y .dijitRadio {
+ /* in a11y mode we display the native checkbox (not the icon), so don't restrict the size */
+ width: auto !important;
+ height: auto !important;
+}
+.dj_a11y .dijitCheckBoxInput {
+ opacity: 1;
+ filter: none;
+ width: auto;
+ height: auto;
+}
+
+.dj_a11y .dijitFocusedLabel {
+ /* for checkboxes or radio buttons in high contrast mode, use border rather than outline to indicate focus (outline does not work in FF)*/
+ border: 1px dotted;
+ outline: 0px !important;
+}
+
+/****
+ dijit.ProgressBar
+ ****/
+
+.dijitProgressBar {
+ z-index: 0; /* so z-index settings below have no effect outside of the ProgressBar */
+}
+.dijitProgressBarEmpty {
+ /* outer container and background of the bar that's not finished yet*/
+ position:relative;overflow:hidden;
+ border:1px solid black; /* a11y: border necessary for high-contrast mode */
+ z-index:0; /* establish a stacking context for this progress bar */
+}
+
+.dijitProgressBarFull {
+ /* outer container for background of bar that is finished */
+ position:absolute;
+ overflow:hidden;
+ z-index:-1;
+ top:0;
+ width:100%;
+}
+.dj_ie6 .dijitProgressBarFull {
+ height:1.6em;
+}
+
+.dijitProgressBarTile {
+ /* inner container for finished portion */
+ position:absolute;
+ overflow:hidden;
+ top:0;
+ left:0;
+ bottom:0;
+ right:0;
+ margin:0;
+ padding:0;
+ width: 100%; /* needed for IE/quirks */
+ height:auto;
+ background-color:#aaa;
+ background-attachment: fixed;
+}
+
+.dj_a11y .dijitProgressBarTile {
+ /* a11y: The border provides visibility in high-contrast mode */
+ border-width:2px;
+ border-style:solid;
+ background-color:transparent !important;
+}
+
+.dj_ie6 .dijitProgressBarTile {
+ /* width:auto works in IE6 with position:static but not position:absolute */
+ position:static;
+ /* height:auto or 100% does not work in IE6 */
+ height:1.6em;
+}
+
+.dijitProgressBarIndeterminate .dijitProgressBarTile {
+ /* animated gif for 'indeterminate' mode */
+}
+
+.dijitProgressBarIndeterminateHighContrastImage {
+ display:none;
+}
+
+.dj_a11y .dijitProgressBarIndeterminate .dijitProgressBarIndeterminateHighContrastImage {
+ display:block;
+ position:absolute;
+ top:0;
+ bottom:0;
+ margin:0;
+ padding:0;
+ width:100%;
+ height:auto;
+}
+
+.dijitProgressBarLabel {
+ display:block;
+ position:static;
+ width:100%;
+ text-align:center;
+ background-color:transparent !important;
+}
+
+/****
+ dijit.Tooltip
+ ****/
+
+.dijitTooltip {
+ position: absolute;
+ z-index: 2000;
+ display: block;
+ /* make visible but off screen */
+ left: 0;
+ top: -10000px;
+ overflow: visible;
+}
+
+.dijitTooltipContainer {
+ border: solid black 2px;
+ background: #b8b5b5;
+ color: black;
+ font-size: small;
+}
+
+.dijitTooltipFocusNode {
+ padding: 2px 2px 2px 2px;
+}
+
+.dijitTooltipConnector {
+ position: absolute;
+}
+.dj_a11y .dijitTooltipConnector {
+ display: none; /* won't show b/c it's background-image; hide to avoid border gap */
+}
+
+.dijitTooltipData {
+ display:none;
+}
+
+/* Layout widgets. This is essential CSS to make layout work (it isn't "styling" CSS)
+ make sure that the position:absolute in dijitAlign* overrides other classes */
+
+.dijitLayoutContainer {
+ position: relative;
+ display: block;
+ overflow: hidden;
+}
+
+.dijitAlignTop,
+.dijitAlignBottom,
+.dijitAlignLeft,
+.dijitAlignRight {
+ position: absolute;
+ overflow: hidden;
+}
+
+body .dijitAlignClient { position: absolute; }
+
+/*
+ * BorderContainer
+ *
+ * .dijitBorderContainer is a stylized layout where panes have border and margin.
+ * .dijitBorderContainerNoGutter is a raw layout.
+ */
+.dijitBorderContainer, .dijitBorderContainerNoGutter {
+ position:relative;
+ overflow: hidden;
+ z-index: 0; /* so z-index settings below have no effect outside of the BorderContainer */
+}
+
+.dijitBorderContainerPane,
+.dijitBorderContainerNoGutterPane {
+ position: absolute !important; /* !important to override position:relative in dijitTabContainer etc. */
+ z-index: 2; /* above the splitters so that off-by-one browser errors don't cover up border of pane */
+}
+
+.dijitBorderContainer > .dijitTextArea {
+ /* On Safari, for SimpleTextArea inside a BorderContainer,
+ don't want to display the grip to resize */
+ resize: none;
+}
+
+.dijitGutter {
+ /* gutter is just a place holder for empty space between panes in BorderContainer */
+ position: absolute;
+ font-size: 1px; /* needed by IE6 even though div is empty, otherwise goes to 15px */
+}
+
+/* SplitContainer
+
+ 'V' == container that splits vertically (up/down)
+ 'H' = horizontal (left/right)
+*/
+
+.dijitSplitter {
+ position: absolute;
+ overflow: hidden;
+ z-index: 10; /* above the panes so that splitter focus is visible on FF, see #7583*/
+ background-color: #fff;
+ border-color: gray;
+ border-style: solid;
+ border-width: 0;
+}
+.dj_ie .dijitSplitter {
+ z-index: 1; /* behind the panes so that pane borders aren't obscured see test_Gui.html/[14392] */
+}
+
+.dijitSplitterActive {
+ z-index: 11 !important;
+}
+
+.dijitSplitterCover {
+ position:absolute;
+ z-index:-1;
+ top:0;
+ left:0;
+ width:100%;
+ height:100%;
+}
+
+.dijitSplitterCoverActive {
+ z-index:3 !important;
+}
+
+/* #6945: stop mouse events */
+.dj_ie .dijitSplitterCover {
+ background: white;
+ opacity: 0;
+}
+.dj_ie6 .dijitSplitterCover,
+.dj_ie7 .dijitSplitterCover,
+.dj_ie8 .dijitSplitterCover {
+ filter: alpha(opacity=0);
+}
+
+.dijitSplitterH {
+ height: 7px;
+ border-top:1px;
+ border-bottom:1px;
+ cursor: row-resize;
+ -webkit-tap-highlight-color: transparent;
+}
+.dijitSplitterV {
+ width: 7px;
+ border-left:1px;
+ border-right:1px;
+ cursor: col-resize;
+ -webkit-tap-highlight-color: transparent;
+}
+.dijitSplitContainer {
+ position: relative;
+ overflow: hidden;
+ display: block;
+}
+
+.dijitSplitPane {
+ position: absolute;
+}
+
+.dijitSplitContainerSizerH,
+.dijitSplitContainerSizerV {
+ position:absolute;
+ font-size: 1px;
+ background-color: ThreeDFace;
+ border: 1px solid;
+ border-color: ThreeDHighlight ThreeDShadow ThreeDShadow ThreeDHighlight;
+ margin: 0;
+}
+
+.dijitSplitContainerSizerH .thumb, .dijitSplitterV .dijitSplitterThumb {
+ overflow:hidden;
+ position:absolute;
+ top:49%;
+}
+
+.dijitSplitContainerSizerV .thumb, .dijitSplitterH .dijitSplitterThumb {
+ position:absolute;
+ left:49%;
+}
+
+.dijitSplitterShadow,
+.dijitSplitContainerVirtualSizerH,
+.dijitSplitContainerVirtualSizerV {
+ font-size: 1px;
+ background-color: ThreeDShadow;
+ -moz-opacity: 0.5;
+ opacity: 0.5;
+ filter: Alpha(Opacity=50);
+ margin: 0;
+}
+
+.dijitSplitContainerSizerH, .dijitSplitContainerVirtualSizerH {
+ cursor: col-resize;
+}
+
+.dijitSplitContainerSizerV, .dijitSplitContainerVirtualSizerV {
+ cursor: row-resize;
+}
+
+.dj_a11y .dijitSplitterH {
+ border-top:1px solid #d3d3d3 !important;
+ border-bottom:1px solid #d3d3d3 !important;
+}
+.dj_a11y .dijitSplitterV {
+ border-left:1px solid #d3d3d3 !important;
+ border-right:1px solid #d3d3d3 !important;
+}
+
+/* ContentPane */
+
+.dijitContentPane {
+ display: block;
+ overflow: auto; /* if we don't have this (or overflow:hidden), then Widget.resizeTo() doesn't make sense for ContentPane */
+ -webkit-overflow-scrolling: touch;
+}
+
+.dijitContentPaneSingleChild {
+ /*
+ * if the ContentPane holds a single layout widget child which is being sized to match the content pane,
+ * then the ContentPane should never get a scrollbar (but it does due to browser bugs, see #9449
+ */
+ overflow: hidden;
+}
+
+.dijitContentPaneLoading .dijitIconLoading,
+.dijitContentPaneError .dijitIconError {
+ margin-right: 9px;
+}
+
+/* TitlePane and Fieldset */
+
+.dijitTitlePane {
+ display: block;
+ overflow: hidden;
+}
+.dijitFieldset {
+ border: 1px solid gray;
+}
+.dijitTitlePaneTitle, .dijitFieldsetTitle {
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+.dijitTitlePaneTitleFixedOpen, .dijitTitlePaneTitleFixedClosed,
+.dijitFieldsetTitleFixedOpen, .dijitFieldsetTitleFixedClosed {
+ /* TitlePane or Fieldset that cannot be toggled */
+ cursor: default;
+}
+.dijitTitlePaneTitle * {
+ vertical-align: middle;
+}
+.dijitTitlePane .dijitArrowNodeInner, .dijitFieldset .dijitArrowNodeInner {
+ /* normally, hide arrow text in favor of icon */
+ display: none;
+}
+.dj_a11y .dijitTitlePane .dijitArrowNodeInner, .dj_a11y .dijitFieldset .dijitArrowNodeInner {
+ /* ... except in a11y mode, then show text arrow */
+ display: inline;
+ font-family: monospace; /* because - and + are different widths */
+}
+.dj_a11y .dijitTitlePane .dijitArrowNode, .dj_a11y .dijitFieldset .dijitArrowNode {
+ /* ... and hide icon (TODO: just point dijitIcon class on the icon, and it hides automatically) */
+ display: none;
+}
+.dijitTitlePaneTitleFixedOpen .dijitArrowNode, .dijitTitlePaneTitleFixedOpen .dijitArrowNodeInner,
+.dijitTitlePaneTitleFixedClosed .dijitArrowNode, .dijitTitlePaneTitleFixedClosed .dijitArrowNodeInner,
+.dijitFieldsetTitleFixedOpen .dijitArrowNode, .dijitFieldsetTitleFixedOpen .dijitArrowNodeInner,
+.dijitFieldsetTitleFixedClosed .dijitArrowNode, .dijitFieldsetTitleFixedClosed .dijitArrowNodeInner {
+ /* don't show the open close icon or text arrow; it makes the user think the pane is closable */
+ display: none !important; /* !important to override above a11y rules to show text arrow */
+}
+
+.dj_ie6 .dijitTitlePaneContentOuter,
+.dj_ie6 .dijitTitlePane .dijitTitlePaneTitle {
+ /* force hasLayout to ensure borders etc, show up */
+ zoom: 1;
+}
+
+/* Color Palette
+ * Sizes designed so that table cell positions match icons in underlying image,
+ * which appear at 20x20 intervals.
+ */
+
+.dijitColorPalette {
+ border: 1px solid #999;
+ background: #fff;
+ position: relative;
+}
+
+.dijitColorPalette .dijitPaletteTable {
+ /* Table that holds the palette cells, and overlays image file with color swatches.
+ * padding/margin to align table with image.
+ */
+ padding: 2px 3px 3px 3px;
+ position: relative;
+ overflow: hidden;
+ outline: 0;
+ border-collapse: separate;
+}
+.dj_ie6 .dijitColorPalette .dijitPaletteTable,
+.dj_ie7 .dijitColorPalette .dijitPaletteTable,
+.dj_iequirks .dijitColorPalette .dijitPaletteTable {
+ /* using padding above so that focus border isn't cutoff on moz/webkit,
+ * but using margin on IE because padding doesn't seem to work
+ */
+ padding: 0;
+ margin: 2px 3px 3px 3px;
+}
+
+.dijitColorPalette .dijitPaletteCell {
+ /* <td> in the <table> */
+ font-size: 1px;
+ vertical-align: middle;
+ text-align: center;
+ background: none;
+}
+.dijitColorPalette .dijitPaletteImg {
+ /* Called dijitPaletteImg for back-compat, this actually wraps the color swatch with a border and padding */
+ padding: 1px; /* white area between gray border and color swatch */
+ border: 1px solid #999;
+ margin: 2px 1px;
+ cursor: default;
+ font-size: 1px; /* prevent <span> from getting bigger just to hold a character */
+}
+.dj_gecko .dijitColorPalette .dijitPaletteImg {
+ padding-bottom: 0; /* workaround rendering glitch on FF, it adds an extra pixel at the bottom */
+}
+.dijitColorPalette .dijitColorPaletteSwatch {
+ /* the actual part where the color is */
+ width: 14px;
+ height: 12px;
+}
+.dijitPaletteTable td {
+ padding: 0;
+}
+.dijitColorPalette .dijitPaletteCell:hover .dijitPaletteImg {
+ /* hovered color swatch */
+ border: 1px solid #000;
+}
+
+.dijitColorPalette .dijitPaletteCell:active .dijitPaletteImg,
+.dijitColorPalette .dijitPaletteTable .dijitPaletteCellSelected .dijitPaletteImg {
+ border: 2px solid #000;
+ margin: 1px 0; /* reduce margin to compensate for increased border */
+}
+
+
+.dj_a11y .dijitColorPalette .dijitPaletteTable,
+.dj_a11y .dijitColorPalette .dijitPaletteTable * {
+ /* table cells are to catch events, but the swatches are in the PaletteImg behind the table */
+ background-color: transparent !important;
+}
+
+/* AccordionContainer */
+
+.dijitAccordionContainer {
+ border:1px solid #b7b7b7;
+ border-top:0 !important;
+}
+.dijitAccordionTitle {
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+.dijitAccordionTitleSelected {
+ cursor: default;
+}
+
+/* images off, high-contrast mode styles */
+.dijitAccordionTitle .arrowTextUp,
+.dijitAccordionTitle .arrowTextDown {
+ display: none;
+ font-size: 0.65em;
+ font-weight: normal !important;
+}
+
+.dj_a11y .dijitAccordionTitle .arrowTextUp,
+.dj_a11y .dijitAccordionTitleSelected .arrowTextDown {
+ display: inline;
+}
+
+.dj_a11y .dijitAccordionTitleSelected .arrowTextUp {
+ display: none;
+}
+
+.dijitAccordionChildWrapper {
+ /* this is the node whose height is adjusted */
+ overflow: hidden;
+}
+
+/* Calendar */
+
+.dijitCalendarContainer table {
+ width: auto; /* in case user has specified a width for the TABLE nodes, see #10553 */
+ clear: both; /* clear margin created for left/right month arrows; needed on IE10 for CalendarLite */
+}
+.dijitCalendarContainer th, .dijitCalendarContainer td {
+ padding: 0;
+ vertical-align: middle;
+}
+
+.dijitCalendarMonthContainer {
+ text-align: center;
+}
+.dijitCalendarDecrementArrow {
+ float: left;
+}
+.dijitCalendarIncrementArrow {
+ float: right;
+}
+
+.dijitCalendarYearLabel {
+ white-space: nowrap; /* make sure previous, current, and next year appear on same row */
+}
+
+.dijitCalendarNextYear {
+ margin:0 0 0 0.55em;
+}
+
+.dijitCalendarPreviousYear {
+ margin:0 0.55em 0 0;
+}
+
+.dijitCalendarIncrementControl {
+ vertical-align: middle;
+}
+
+.dijitCalendarIncrementControl,
+.dijitCalendarDateTemplate,
+.dijitCalendarMonthLabel,
+.dijitCalendarPreviousYear,
+.dijitCalendarNextYear {
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+
+.dijitCalendarDisabledDate {
+ color: gray;
+ text-decoration: line-through;
+ cursor: default;
+}
+
+.dijitSpacer {
+ /* don't display it, but make it affect the width */
+ position: relative;
+ height: 1px;
+ overflow: hidden;
+ visibility: hidden;
+}
+
+/* Styling for month drop down list */
+
+.dijitCalendarMonthMenu .dijitCalendarMonthLabel {
+ text-align:center;
+}
+
+/* Menu */
+
+.dijitMenu {
+ border:1px solid black;
+ background-color:white;
+}
+.dijitMenuTable {
+ border-collapse:collapse;
+ border-width:0;
+ background-color:white;
+}
+
+/* workaround for webkit bug #8427, remove this when it is fixed upstream */
+.dj_webkit .dijitMenuTable td[colspan="2"]{
+ border-right:hidden;
+}
+
+.dijitMenuItem {
+ text-align: left;
+ white-space: nowrap;
+ padding:.1em .2em;
+ cursor:pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+
+/*
+No need to show a focus border since it's obvious from the shading, and there's a .dj_a11y .dijitMenuItemSelected
+rule below that handles the high contrast case when there's no shading.
+Hiding the focus border also works around webkit bug https://code.google.com/p/chromium/issues/detail?id=125779.
+*/
+.dijitMenuItem:focus {
+ outline: none
+}
+
+.dijitMenuPassive .dijitMenuItemHover,
+.dijitMenuItemSelected {
+ /*
+ * dijitMenuItemHover refers to actual mouse over
+ * dijitMenuItemSelected is used after a menu has been "activated" by
+ * clicking it, tabbing into it, or being opened from a parent menu,
+ * and denotes that the menu item has focus or that focus is on a child
+ * menu
+ */
+ background-color:black;
+ color:white;
+}
+
+.dijitMenuItemIcon, .dijitMenuExpand {
+ background-repeat: no-repeat;
+}
+
+.dijitMenuItemDisabled * {
+ /* for a disabled menu item, just set it to mostly transparent */
+ opacity:0.5;
+ cursor:default;
+}
+.dj_ie .dj_a11y .dijitMenuItemDisabled,
+.dj_ie .dj_a11y .dijitMenuItemDisabled *,
+.dj_ie .dijitMenuItemDisabled * {
+ color: gray;
+ filter: alpha(opacity=35);
+}
+
+.dijitMenuItemLabel {
+ vertical-align: middle;
+}
+
+.dj_a11y .dijitMenuItemSelected {
+ border: 1px dotted black !important; /* for 2.0 use outline instead, to prevent jitter */
+}
+
+.dj_a11y .dijitMenuItemSelected .dijitMenuItemLabel {
+ border-width: 1px;
+ border-style: solid;
+}
+.dj_ie8 .dj_a11y .dijitMenuItemLabel {
+ position:static;
+}
+
+.dijitMenuExpandA11y {
+ display: none;
+}
+.dj_a11y .dijitMenuExpandA11y {
+ display: inline;
+}
+
+.dijitMenuSeparator td {
+ border: 0;
+ padding: 0;
+}
+
+/* separator can be two pixels -- set border of either one to 0 to have only one */
+.dijitMenuSeparatorTop {
+ height: 50%;
+ margin: 0;
+ margin-top:3px;
+ font-size: 1px;
+}
+
+.dijitMenuSeparatorBottom {
+ height: 50%;
+ margin: 0;
+ margin-bottom:3px;
+ font-size: 1px;
+}
+
+/* CheckedMenuItem and RadioMenuItem */
+.dijitMenuItemIconChar {
+ display: none; /* don't display except in high contrast mode */
+ visibility: hidden; /* for high contrast mode when menuitem is unchecked: leave space for when it is checked */
+}
+.dj_a11y .dijitMenuItemIconChar {
+ display: inline; /* display character in high contrast mode, since icon doesn't show */
+}
+.dijitCheckedMenuItemChecked .dijitMenuItemIconChar,
+.dijitRadioMenuItemChecked .dijitMenuItemIconChar {
+ visibility: visible; /* menuitem is checked */
+}
+.dj_ie .dj_a11y .dijitMenuBar .dijitMenuItem {
+ /* so bottom border of MenuBar appears on IE7 in high-contrast mode */
+ margin: 0;
+}
+
+/* StackContainer */
+
+.dijitStackController .dijitToggleButtonChecked * {
+ cursor: default; /* because pressing it has no effect */
+}
+
+/***
+TabContainer
+
+Main class hierarchy:
+
+.dijitTabContainer - the whole TabContainer
+ .dijitTabController / .dijitTabListContainer-top - wrapper for tab buttons, scroll buttons
+ .dijitTabListWrapper / .dijitTabContainerTopStrip - outer wrapper for tab buttons (normal width)
+ .nowrapTabStrip / .dijitTabContainerTop-tabs - inner wrapper for tab buttons (50K width)
+ .dijitTabPaneWrapper - wrapper for content panes, has all borders except the one between content and tabs
+***/
+
+.dijitTabContainer {
+ z-index: 0; /* so z-index settings below have no effect outside of the TabContainer */
+ overflow: visible; /* prevent off-by-one-pixel errors from hiding bottom border (opposite tab labels) */
+}
+.dj_ie6 .dijitTabContainer {
+ /* workaround IE6 problem when tall content overflows TabContainer, see editor/test_FullScreen.html */
+ overflow: hidden;
+
+}
+.dijitTabContainerNoLayout {
+ width: 100%; /* otherwise ScrollingTabController goes to 50K pixels wide */
+}
+
+.dijitTabContainerBottom-tabs,
+.dijitTabContainerTop-tabs,
+.dijitTabContainerLeft-tabs,
+.dijitTabContainerRight-tabs {
+ z-index: 1;
+ overflow: visible !important; /* so tabs can cover up border adjacent to container */
+}
+
+.dijitTabController {
+ z-index: 1;
+}
+.dijitTabContainerBottom-container,
+.dijitTabContainerTop-container,
+.dijitTabContainerLeft-container,
+.dijitTabContainerRight-container {
+ z-index:0;
+ overflow: hidden;
+ border: 1px solid black;
+}
+.nowrapTabStrip {
+ width: 50000px;
+ display: block;
+ position: relative;
+ text-align: left; /* just in case ancestor has non-standard setting */
+ z-index: 1;
+}
+.dijitTabListWrapper {
+ overflow: hidden;
+ z-index: 1;
+}
+
+.dj_a11y .tabStripButton img {
+ /* hide the icons (or rather the empty space where they normally appear) because text will appear instead */
+ display: none;
+}
+
+.dijitTabContainerTop-tabs {
+ border-bottom: 1px solid black;
+}
+.dijitTabContainerTop-container {
+ border-top: 0;
+}
+
+.dijitTabContainerLeft-tabs {
+ border-right: 1px solid black;
+ float: left; /* needed for IE7 RTL mode */
+}
+.dijitTabContainerLeft-container {
+ border-left: 0;
+}
+
+.dijitTabContainerBottom-tabs {
+ border-top: 1px solid black;
+}
+.dijitTabContainerBottom-container {
+ border-bottom: 0;
+}
+
+.dijitTabContainerRight-tabs {
+ border-left: 1px solid black;
+ float: left; /* needed for IE7 RTL mode */
+}
+.dijitTabContainerRight-container {
+ border-right: 0;
+}
+
+div.dijitTabDisabled, .dj_ie div.dijitTabDisabled {
+ cursor: auto;
+}
+
+.dijitTab {
+ position:relative;
+ cursor:pointer;
+ -webkit-tap-highlight-color: transparent;
+ white-space:nowrap;
+ z-index:3;
+}
+.dijitTab * {
+ /* make tab icons and close icon line up w/text */
+ vertical-align: middle;
+}
+.dijitTabChecked {
+ cursor: default; /* because clicking will have no effect */
+}
+
+.dijitTabContainerTop-tabs .dijitTab {
+ top: 1px; /* to overlap border on .dijitTabContainerTop-tabs */
+}
+.dijitTabContainerBottom-tabs .dijitTab {
+ top: -1px; /* to overlap border on .dijitTabContainerBottom-tabs */
+}
+.dijitTabContainerLeft-tabs .dijitTab {
+ left: 1px; /* to overlap border on .dijitTabContainerLeft-tabs */
+}
+.dijitTabContainerRight-tabs .dijitTab {
+ left: -1px; /* to overlap border on .dijitTabContainerRight-tabs */
+}
+
+
+.dijitTabContainerTop-tabs .dijitTab,
+.dijitTabContainerBottom-tabs .dijitTab {
+ /* Inline-block */
+ display:inline-block; /* webkit and FF3 */
+ #zoom: 1; /* set hasLayout:true to mimic inline-block */
+ #display:inline; /* don't use .dj_ie since that increases the priority */
+}
+
+.tabStripButton {
+ z-index: 12;
+}
+
+.dijitTabButtonDisabled .tabStripButton {
+ display: none;
+}
+
+
+.dijitTabCloseButton {
+ margin-left: 1em;
+}
+
+.dijitTabCloseText {
+ display:none;
+}
+
+.dijitTab .tabLabel {
+ /* make sure tabs w/close button and w/out close button are same height, even w/small (<15px) font.
+ * assumes <=15px height for close button icon.
+ */
+ min-height: 15px;
+ display: inline-block;
+}
+.dijitNoIcon {
+ /* applied to <img>/<span> node when there is no icon specified */
+ display: none;
+}
+.dj_ie6 .dijitTab .dijitNoIcon {
+ /* because min-height (on .tabLabel, above) doesn't work on IE6 */
+ display: inline;
+ height: 15px;
+ width: 1px;
+}
+
+/* images off, high-contrast mode styles */
+
+.dj_a11y .dijitTabCloseButton {
+ background-image: none !important;
+ width: auto !important;
+ height: auto !important;
+}
+
+.dj_a11y .dijitTabCloseText {
+ display: inline;
+}
+
+.dijitTabPane,
+.dijitStackContainer-child,
+.dijitAccordionContainer-child {
+ /* children of TabContainer, StackContainer, and AccordionContainer shouldn't have borders
+ * b/c a border is already there from the TabContainer/StackContainer/AccordionContainer itself.
+ */
+ border: none !important;
+}
+
+/* InlineEditBox */
+.dijitInlineEditBoxDisplayMode {
+ border: 1px solid transparent; /* so keyline (border) on hover can appear without screen jump */
+ cursor: text;
+}
+
+.dj_a11y .dijitInlineEditBoxDisplayMode,
+.dj_ie6 .dijitInlineEditBoxDisplayMode {
+ /* except that IE6 doesn't support transparent borders, nor does high contrast mode */
+ border: none;
+}
+
+.dijitInlineEditBoxDisplayModeHover,
+.dj_a11y .dijitInlineEditBoxDisplayModeHover,
+.dj_ie6 .dijitInlineEditBoxDisplayModeHover {
+ /* An InlineEditBox in view mode (click this to edit the text) */
+ background-color: #e2ebf2;
+ border: solid 1px black;
+}
+
+.dijitInlineEditBoxDisplayModeDisabled {
+ cursor: default;
+}
+
+/* Tree */
+.dijitTree {
+ overflow: auto; /* for scrollbars when Tree has a height setting, and to prevent wrapping around float elements, see #11491 */
+ -webkit-tap-highlight-color: transparent;
+}
+
+.dijitTreeContainer {
+ float: left; /* for correct highlighting during horizontal scroll, see #16132 */
+}
+
+.dijitTreeIndent {
+ /* amount to indent each tree node (relative to parent node) */
+ width: 19px;
+}
+
+.dijitTreeRow, .dijitTreeContent {
+ white-space: nowrap;
+}
+
+.dj_ie .dijitTreeLabel:focus {
+ /* workaround IE9 behavior where down arrowing through TreeNodes doesn't show focus outline */
+ outline: 1px dotted black;
+}
+
+.dijitTreeRow img {
+ /* make the expando and folder icons line up with the label */
+ vertical-align: middle;
+}
+
+.dijitTreeContent {
+ cursor: default;
+}
+
+.dijitExpandoText {
+ display: none;
+}
+
+.dj_a11y .dijitExpandoText {
+ display: inline;
+ padding-left: 10px;
+ padding-right: 10px;
+ font-family: monospace;
+ border-style: solid;
+ border-width: thin;
+ cursor: pointer;
+}
+
+.dijitTreeLabel {
+ margin: 0 4px;
+}
+
+/* Dialog */
+
+.dijitDialog {
+ position: absolute;
+ z-index: 999;
+ overflow: hidden; /* override overflow: auto; from ContentPane to make dragging smoother */
+}
+
+.dijitDialogTitleBar {
+ cursor: move;
+}
+.dijitDialogFixed .dijitDialogTitleBar {
+ cursor:default;
+}
+.dijitDialogCloseIcon {
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+.dijitDialogPaneContent {
+ -webkit-overflow-scrolling: touch;
+}
+.dijitDialogUnderlayWrapper {
+ position: absolute;
+ left: 0;
+ top: 0;
+ z-index: 998;
+ display: none;
+ background: transparent !important;
+}
+
+.dijitDialogUnderlay {
+ background: #eee;
+ opacity: 0.5;
+}
+
+.dj_ie .dijitDialogUnderlay {
+ filter: alpha(opacity=50);
+}
+
+/* images off, high-contrast mode styles */
+.dj_a11y .dijitSpinnerButtonContainer,
+.dj_a11y .dijitDialog {
+ opacity: 1 !important;
+ background-color: white !important;
+}
+
+.dijitDialog .closeText {
+ display:none;
+ /* for the onhover border in high contrast on IE: */
+ position:absolute;
+}
+
+.dj_a11y .dijitDialog .closeText {
+ display:inline;
+}
+
+/* Slider */
+
+.dijitSliderMoveable {
+ z-index:99;
+ position:absolute !important;
+ display:block;
+ vertical-align:middle;
+}
+
+.dijitSliderMoveableH {
+ right:0;
+}
+.dijitSliderMoveableV {
+ right:50%;
+}
+
+.dj_a11y div.dijitSliderImageHandle,
+.dijitSliderImageHandle {
+ margin:0;
+ padding:0;
+ position:relative !important;
+ border:8px solid gray;
+ width:0;
+ height:0;
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+.dj_iequirks .dj_a11y .dijitSliderImageHandle {
+ font-size: 0;
+}
+.dj_ie7 .dijitSliderImageHandle {
+ overflow: hidden; /* IE7 workaround to make slider handle VISIBLE in non-a11y mode */
+}
+.dj_ie7 .dj_a11y .dijitSliderImageHandle {
+ overflow: visible; /* IE7 workaround to make slider handle VISIBLE in a11y mode */
+}
+.dj_a11y .dijitSliderFocused .dijitSliderImageHandle {
+ border:4px solid #000;
+ height:8px;
+ width:8px;
+}
+
+.dijitSliderImageHandleV {
+ top:-8px;
+ right: -50%;
+}
+
+.dijitSliderImageHandleH {
+ left:50%;
+ top:-5px;
+ vertical-align:top;
+}
+
+.dijitSliderBar {
+ border-style:solid;
+ border-color:black;
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+
+.dijitSliderBarContainerV {
+ position:relative;
+ height:100%;
+ z-index:1;
+}
+
+.dijitSliderBarContainerH {
+ position:relative;
+ z-index:1;
+}
+
+.dijitSliderBarH {
+ height:4px;
+ border-width:1px 0;
+}
+
+.dijitSliderBarV {
+ width:4px;
+ border-width:0 1px;
+}
+
+.dijitSliderProgressBar {
+ background-color:red;
+ z-index:1;
+}
+
+.dijitSliderProgressBarV {
+ position:static !important;
+ height:0;
+ vertical-align:top;
+ text-align:left;
+}
+
+.dijitSliderProgressBarH {
+ position:absolute !important;
+ width:0;
+ vertical-align:middle;
+ overflow:visible;
+}
+
+.dijitSliderRemainingBar {
+ overflow:hidden;
+ background-color:transparent;
+ z-index:1;
+}
+
+.dijitSliderRemainingBarV {
+ height:100%;
+ text-align:left;
+}
+
+.dijitSliderRemainingBarH {
+ width:100% !important;
+}
+
+/* the slider bumper is the space consumed by the slider handle when it hangs over an edge */
+.dijitSliderBumper {
+ overflow:hidden;
+ z-index:1;
+}
+
+.dijitSliderBumperV {
+ width:4px;
+ height:8px;
+ border-width:0 1px;
+}
+
+.dijitSliderBumperH {
+ width:8px;
+ height:4px;
+ border-width:1px 0;
+}
+
+.dijitSliderBottomBumper,
+.dijitSliderLeftBumper {
+ background-color:red;
+}
+
+.dijitSliderTopBumper,
+.dijitSliderRightBumper {
+ background-color:transparent;
+}
+
+.dijitSliderDecoration {
+ text-align:center;
+}
+
+.dijitSliderDecorationC,
+.dijitSliderDecorationV {
+ position: relative; /* needed for IE+quirks+RTL+vertical (rendering bug) but add everywhere for custom styling consistency but this messes up IE horizontal sliders */
+}
+
+.dijitSliderDecorationH {
+ width: 100%;
+}
+
+.dijitSliderDecorationV {
+ height: 100%;
+ white-space: nowrap;
+}
+
+.dijitSliderButton {
+ font-family:monospace;
+ margin:0;
+ padding:0;
+ display:block;
+}
+
+.dj_a11y .dijitSliderButtonInner {
+ visibility:visible !important;
+}
+
+.dijitSliderButtonContainer {
+ text-align:center;
+ height:0; /* ??? */
+}
+.dijitSliderButtonContainer * {
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+
+.dijitSlider .dijitButtonNode {
+ padding:0;
+ display:block;
+}
+
+.dijitRuleContainer {
+ position:relative;
+ overflow:visible;
+}
+
+.dijitRuleContainerV {
+ height:100%;
+ line-height:0;
+ float:left;
+ text-align:left;
+}
+
+.dj_opera .dijitRuleContainerV {
+ line-height:2%;
+}
+
+.dj_ie .dijitRuleContainerV {
+ line-height:normal;
+}
+
+.dj_gecko .dijitRuleContainerV {
+ margin:0 0 1px 0; /* mozilla bug workaround for float:left,height:100% block elements */
+}
+
+.dijitRuleMark {
+ position:absolute;
+ border:1px solid black;
+ line-height:0;
+ height:100%;
+}
+
+.dijitRuleMarkH {
+ width:0;
+ border-top-width:0 !important;
+ border-bottom-width:0 !important;
+ border-left-width:0 !important;
+}
+
+.dijitRuleLabelContainer {
+ position:absolute;
+}
+
+.dijitRuleLabelContainerH {
+ text-align:center;
+ display:inline-block;
+}
+
+.dijitRuleLabelH {
+ position:relative;
+ left:-50%;
+}
+
+.dijitRuleLabelV {
+ /* so that long labels don't overflow to multiple rows, or overwrite slider itself */
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ overflow: hidden;
+}
+
+.dijitRuleMarkV {
+ height:0;
+ border-right-width:0 !important;
+ border-bottom-width:0 !important;
+ border-left-width:0 !important;
+ width:100%;
+ left:0;
+}
+
+.dj_ie .dijitRuleLabelContainerV {
+ margin-top:-.55em;
+}
+
+.dj_a11y .dijitSliderReadOnly,
+.dj_a11y .dijitSliderDisabled {
+ opacity:0.6;
+}
+.dj_ie .dj_a11y .dijitSliderReadOnly .dijitSliderBar,
+.dj_ie .dj_a11y .dijitSliderDisabled .dijitSliderBar {
+ filter: alpha(opacity=40);
+}
+
+/* + and - Slider buttons: override theme settings to display icons */
+.dj_a11y .dijitSlider .dijitSliderButtonContainer div {
+ font-family: monospace; /* otherwise hyphen is larger and more vertically centered */
+ font-size: 1em;
+ line-height: 1em;
+ height: auto;
+ width: auto;
+ margin: 0 4px;
+}
+
+/* Icon-only buttons (often in toolbars) still display the text in high-contrast mode */
+.dj_a11y .dijitButtonContents .dijitButtonText,
+.dj_a11y .dijitTab .tabLabel {
+ display: inline !important;
+}
+.dj_a11y .dijitSelect .dijitButtonText {
+ display: inline-block !important;
+}
+
+/* TextArea, SimpleTextArea */
+.dijitTextArea {
+ width:100%;
+ overflow-y: auto; /* w/out this IE's SimpleTextArea goes to overflow: scroll */
+}
+.dijitTextArea[cols] {
+ width:auto; /* SimpleTextArea cols */
+}
+.dj_ie .dijitTextAreaCols {
+ width:auto;
+}
+
+.dijitExpandingTextArea {
+ /* for auto exanding textarea (called Textarea currently, rename for 2.0) don't want to display the grip to resize */
+ resize: none;
+}
+
+
+/* Toolbar
+ * Note that other toolbar rules (for objects in toolbars) are scattered throughout this file.
+ */
+
+.dijitToolbarSeparator {
+ height: 18px;
+ width: 5px;
+ padding: 0 1px;
+ margin: 0;
+}
+
+/* Editor */
+.dijitIEFixedToolbar {
+ position:absolute;
+ /* top:0; */
+ top: expression(eval((document.documentElement||document.body).scrollTop));
+}
+
+.dijitEditor {
+ display: block; /* prevents glitch on FF with InlineEditBox, see #8404 */
+}
+
+.dijitEditorDisabled,
+.dijitEditorReadOnly {
+ color: gray;
+}
+
+/* TimePicker */
+
+.dijitTimePicker {
+ background-color: white;
+}
+.dijitTimePickerItem {
+ cursor:pointer;
+ -webkit-tap-highlight-color: transparent;
+}
+.dijitTimePickerItemHover {
+ background-color:gray;
+ color:white;
+}
+.dijitTimePickerItemSelected {
+ font-weight:bold;
+ color:#333;
+ background-color:#b7cdee;
+}
+.dijitTimePickerItemDisabled {
+ color:gray;
+ text-decoration:line-through;
+}
+
+.dijitTimePickerItemInner {
+ text-align:center;
+ border:0;
+ padding:2px 8px 2px 8px;
+}
+
+.dijitTimePickerTick,
+.dijitTimePickerMarker {
+ border-bottom:1px solid gray;
+}
+
+.dijitTimePicker .dijitDownArrowButton {
+ border-top: none !important;
+}
+
+.dijitTimePickerTick {
+ color:#CCC;
+}
+
+.dijitTimePickerMarker {
+ color:black;
+ background-color:#CCC;
+}
+
+.dj_a11y .dijitTimePickerItemSelected .dijitTimePickerItemInner {
+ border: solid 4px black;
+}
+.dj_a11y .dijitTimePickerItemHover .dijitTimePickerItemInner {
+ border: dashed 4px black;
+}
+
+
+.dijitToggleButtonIconChar {
+ /* character (instead of icon) to show that ToggleButton is checked */
+ display:none !important;
+}
+.dj_a11y .dijitToggleButton .dijitToggleButtonIconChar {
+ display:inline !important;
+ visibility:hidden;
+}
+.dj_ie6 .dijitToggleButtonIconChar, .dj_ie6 .tabStripButton .dijitButtonText {
+ font-family: "Arial Unicode MS"; /* otherwise the a11y character (checkmark, arrow, etc.) appears as a box */
+}
+.dj_a11y .dijitToggleButtonChecked .dijitToggleButtonIconChar {
+ display: inline !important; /* In high contrast mode, display the check symbol */
+ visibility:visible !important;
+}
+
+.dijitArrowButtonChar {
+ display:none !important;
+}
+.dj_a11y .dijitArrowButtonChar {
+ display:inline !important;
+}
+
+.dj_a11y .dijitDropDownButton .dijitArrowButtonInner,
+.dj_a11y .dijitComboButton .dijitArrowButtonInner {
+ display:none !important;
+}
+
+/* Select */
+.dj_a11y .dijitSelect {
+ border-collapse: separate !important;
+ border-width: 1px;
+ border-style: solid;
+}
+.dj_ie .dijitSelect {
+ vertical-align: middle; /* Set this back for what we hack in dijit inline */
+}
+.dj_ie6 .dijitSelect .dijitValidationContainer,
+.dj_ie8 .dijitSelect .dijitButtonText {
+ vertical-align: top;
+}
+.dj_ie6 .dijitTextBox .dijitInputContainer,
+.dj_iequirks .dijitTextBox .dijitInputContainer,
+.dj_ie6 .dijitTextBox .dijitArrowButtonInner,
+.dj_ie6 .dijitSpinner .dijitSpinnerButtonInner,
+.dijitSelect .dijitSelectLabel {
+ vertical-align: baseline;
+}
+
+.dijitNumberTextBox {
+ text-align: left;
+ direction: ltr;
+}
+
+.dijitNumberTextBox .dijitInputInner {
+ text-align: inherit; /* input */
+}
+
+.dijitNumberTextBox input.dijitInputInner,
+.dijitCurrencyTextBox input.dijitInputInner,
+.dijitSpinner input.dijitInputInner {
+ text-align: right;
+}
+
+.dj_ie8 .dijitNumberTextBox input.dijitInputInner, .dj_ie9 .dijitNumberTextBox input.dijitInputInner,
+.dj_ie8 .dijitCurrencyTextBox input.dijitInputInner, .dj_ie9 .dijitCurrencyTextBox input.dijitInputInner,
+.dj_ie8 .dijitSpinner input.dijitInputInner, .dj_ie9 .dijitSpinner input.dijitInputInner {
+ /* workaround bug where caret invisible in empty textboxes */
+ padding-right: 1px !important;
+}
+
+.dijitToolbar .dijitSelect {
+ margin: 0;
+}
+.dj_webkit .dijitToolbar .dijitSelect {
+ padding-left: 0.3em;
+}
+.dijitSelect .dijitButtonContents {
+ padding: 0;
+ white-space: nowrap;
+ text-align: left;
+ border-style: none solid none none;
+ border-width: 1px;
+}
+.dijitSelectFixedWidth .dijitButtonContents {
+ width: 100%;
+}
+
+.dijitSelectMenu .dijitMenuItemIcon {
+ /* avoid blank area in left side of menu (since we have no icons) */
+ display:none;
+}
+.dj_ie6 .dijitSelectMenu .dijitMenuItemLabel,
+.dj_ie7 .dijitSelectMenu .dijitMenuItemLabel {
+ /* Set back to static due to bug in ie6/ie7 - See Bug #9651 */
+ position: static;
+}
+
+/* Fix the baseline of our label (for multi-size font elements) */
+.dijitSelectLabel *
+{
+ vertical-align: baseline;
+}
+
+/* Styling for the currently-selected option (rich text can mess this up) */
+.dijitSelectSelectedOption * {
+ font-weight: bold;
+}
+
+/* Fix the styling of the dropdown menu to be more combobox-like */
+.dijitSelectMenu {
+ border-width: 1px;
+}
+
+/* Used in cases, such as FullScreen plugin, when we need to force stuff to static positioning. */
+.dijitForceStatic {
+ position: static !important;
+}
+
+/**** Disabled cursor *****/
+.dijitReadOnly *,
+.dijitDisabled *,
+.dijitReadOnly,
+.dijitDisabled {
+ /* a region the user would be able to click on, but it's disabled */
+ cursor: default;
+}
+
+/* Drag and Drop */
+.dojoDndItem {
+ padding: 2px; /* will be replaced by border during drag over (dojoDndItemBefore, dojoDndItemAfter) */
+
+ /* Prevent magnifying-glass text selection icon to appear on mobile webkit as it causes a touchout event */
+ -webkit-touch-callout: none;
+ -webkit-user-select: none; /* Disable selection/Copy of UIWebView */
+}
+.dojoDndHorizontal .dojoDndItem {
+ /* make contents of horizontal container be side by side, rather than vertical */
+ #display: inline;
+ display: inline-block;
+}
+
+.dojoDndItemBefore,
+.dojoDndItemAfter {
+ border: 0px solid #369;
+}
+.dojoDndItemBefore {
+ border-width: 2px 0 0 0;
+ padding: 0 2px 2px 2px;
+}
+.dojoDndItemAfter {
+ border-width: 0 0 2px 0;
+ padding: 2px 2px 0 2px;
+}
+.dojoDndHorizontal .dojoDndItemBefore {
+ border-width: 0 0 0 2px;
+ padding: 2px 2px 2px 0;
+}
+.dojoDndHorizontal .dojoDndItemAfter {
+ border-width: 0 2px 0 0;
+ padding: 2px 0 2px 2px;
+}
+
+.dojoDndItemOver {
+ cursor:pointer;
+}
+.dj_gecko .dijitArrowButtonInner INPUT,
+.dj_gecko INPUT.dijitArrowButtonInner {
+ -moz-user-focus:ignore;
+}
+.dijitFocused .dijitMenuItemShortcutKey {
+ text-decoration: underline;
+}
diff --cc dojox/CONTRIBUTING.md
index 7914225,0000000..13cdf4f
mode 100644,000000..100644
--- a/dojox/CONTRIBUTING.md
+++ b/dojox/CONTRIBUTING.md
@@@ -1,227 -1,0 +1,228 @@@
+_Do you have a contribution? We welcome contributions, but please ensure that you read the following information
+before issuing a pull request. Also refer back to this document as a checklist before issuing your pull request.
+This will save time for everyone._
+
+# Before You Start
+
+## Understanding the Basics
+
+If you don't understand what a *pull request* is, or how to submit one, please refer to the [help documentation][]
+provided by GitHub.
+
+## Is It Really a Support Issue
+
+If you aren't sure if your contribution is needed or necessary, please visit the [support forum][] before attempting to
+submit a pull request or a ticket.
+
+## Search Dojo Toolkit's Bug Database
+
+We require every commit to be tracked via our [bug database][]. It is useful, before you get too far, that you have
+checked that your issue isn't already known, otherwise addressed? If you think it is a valid defect or enhancement,
+please open a new ticket before submitting your pull request.
+
+## Discuss Non-Trivial Contributions with the Committers
+
+If your desired contribution is more than a non-trivial fix, you should discuss it on the
+[contributor's mailing list][dojo-contrib]. If you currently are not a member, you can request to be added.
+
+## Contributor License Agreement
+
+We require all contributions, to be covered under the Dojo Foundation's [Contributor License Agreement][cla]. This can
+be done electronically and essentially ensures that you are making it clear that your contributions are your
- contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
++contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
+Foundation.
+
+If you are an unfamiliar contributor to the committer assessing your pull request, it is best to make it clear how
+you are covered by a CLA in the notes of the pull request. The committer will [verify][claCheck] your status.
+
+If your GitHub user id you are submitting your pull request from differs from the Dojo Community ID or e-mail address
+which you have signed your CLA under, you should specifically note what you have your CLA filed under (and for CCLA
+that you are listed under your companies authorised contributors).
+
+# Submitting a Pull Request
+
+The following are the general steps you should follow in creating a pull request. Subsequent pull requests only need
+to follow step 3 and beyond:
+
+1. Fork the repository on GitHub
+2. Clone the forked repository to your machine
+3. Create a "feature" branch in your local repository
+4. Make your changes and commit them to your local repository
+5. Rebase and push your commits to your GitHub remote fork/repository
+6. Issue a Pull Request to the official repository
+7. Your Pull Request is reviewed by a committer and merged into the repository
+
+*Note* While there are other ways to accomplish the steps using other tools, the examples here will assume the most
+actions will be performed via the `git` command line.
+
+## 1. Fork the Repository
+
+When logged into your GitHub account, and you are viewing one of the main repositories, you will see the *Fork* button.
+Clicking this button will show you which repositories your can fork to. Choose your own account. Once the process
+finishes, you will have your own repository that is "forked" from the GitHub one.
+
+Forking is a GitHub term and not a git term. Git is a wholly distributed source control system and simply worries
+about local and remote repositories and allows you to manage your code against them. GitHub then adds this additional
+layer of structure of how repositories can relate to each other.
+
+## 2. Clone the Forked Repository
+
+Once you have successfully forked your repository, you will need to clone it locally to your machine:
+
+```bash
+$ git clone --recursive git at github.com:username/dojox.git
+```
+
+This will clone your fork to your current path in a directory named `dojox`.
+
+It is important that you clone recursively for ``dojox``, ``demos`` or ``util`` because some of the code is contained in
+submodules. You won't be able to submit your changes to the repositories that way though. If you are working on any of
+these sub-projects, you should contact those project leads to see if their workflow differs.
+
+You should also setup the `upstream` repository. This will allow you to take changes from the "master" repository
+and merge them into your local clone and then push them to your GitHub fork:
+
+```bash
+$ cd dojo
+$ git remote add upstream git at github.com:dojo/dojox.git
+$ git fetch upstream
+```
+
+Then you can retrieve upstream changes and rebase on them into your code like this:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+For more information on maintaining a fork, please see the GitHub Help article [Fork a Repo][] and information on
+[rebasing][] from git.
+
+## 3. Create a Branch
+
+The easiest workflow is to keep your master branch in sync with the upstream branch and do not locate any of your own
+commits in that branch. When you want to work on a new feature, you then ensure you are on the master branch and create
+a new branch from there. While the name of the branch can be anything, it can often be easy to use the ticket number
+you might be working on. For example:
+
+```bash
+$ git checkout -b t12345 master
+Switched to a new branch 't12345'
+```
+
+You will then be on the feature branch. You can verify what branch you are on like this:
+
+```bash
+$ git status
+# On branch t12345
+nothing to commit, working directory clean
+```
+
+## 4. Make Changes and Commit
+
+Now you just need to make your changes. Once you have finished your changes (and tested them) you need to commit them
+to your local repository (assuming you have staged your changes for committing):
+
+```bash
+$ git status
+# On branch t12345
+# Changes to be committed:
+# (use "git reset HEAD <file>..." to unstage)
+#
+# modified: somefile.js
+#
+$ git commit -m "Corrects some defect, fixes #12345, refs #12346"
+[t12345 0000000] Corrects some defect, fixes #12345, refs #12346
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+```
+
+## 5. Rebase and Push Changes
+
+If you have been working on your contribution for a while, the upstream repository may have changed. You may want to
+ensure your work is on top of the latest changes so your pull request can be applied cleanly:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+When you are ready to push your commit to your GitHub repository for the first time on this branch you would do the
+following:
+
+```bash
+$ git push -u origin t12345
+```
+
+After the first time, you simply need to do:
+
+```bash
+$ git push
+```
+
+## 6. Issue a Pull Request
+
+In order to have your commits merged into the main repository, you need to create a pull request. The instructions for
+this can be found in the GitHub Help Article [Creating a Pull Request][]. Essentially you do the following:
+
+1. Go to the site for your repository.
+2. Click the Pull Request button.
+3. Select the feature branch from your repository.
+4. Enter a title and description of your pull request mentioning the corresponding [bug database][] ticket in the description.
+5. Review the commit and files changed tabs.
+6. Click `Send Pull Request`
+
+You will get notified about the status of your pull request based on your GitHub settings.
+
+## 7. Request is Reviewed and Merged
+
+Your request will be reviewed. It may be merged directly, or you may receive feedback or questions on your pull
+request.
+
+# What Makes a Successful Pull Request?
+
+Having your contribution accepted is more than just the mechanics of getting your contribution into a pull request,
+there are several other things that are expected when contributing to the Dojo Toolkit which are covered below.
+
+## Coding Style and Linting
+
+Dojo has a very specific [coding style][styleguide]. All pull requests should adhere to this.
+
+## Inline Documentation
+
+Dojo has an inline API documentation called [DojoDoc][]. Any pull request should ensure it has updated the inline
+documentation appropriately or added the appropriate inline documentation.
+
+## Test Cases
+
+If the pull request changes the functional behaviour or is fixing a defect, the unit test cases should be modified to
+reflect this. The committer reviewing your pull request is likely to request the appropriate changes in the test
- cases. Dojo utilises its own test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository.
++cases. Dojo utilises [Intern][] for all new tests, and has legacy support for its previous generation test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository. All new tests should be authored using Intern.
+
+It is expected that you will have tested your changes against the existing test cases and appropriate platforms prior to
+submitting your pull request.
+
+## Licensing
+
+All of your submissions are licensed under a dual "New" BSD/AFL license.
+
+## Expect Discussion and Rework
+
+Unless you have been working with contributing to Dojo for a while, expect a a significant amount of feedback on your
+pull requests. We are a very passionate community and even the committers often will provide robust feedback to each
+other about their code. Don't be offended by such feedback or feel that your contributions aren't welcome, it is just
+that we are quite passionate and Dojo has a long history with many things that are the "Dojo-way" which may be
+unfamiliar to those who are just starting to contribute.
+
+[help documentation]: http://help.github.com/send-pull-requests
+[bug database]: http://bugs.dojotoolkit.org/
+[support forum]: http://dojotoolkit.org/community/
+[dojo-contrib]: http://mail.dojotoolkit.org/mailman/listinfo/dojo-contributors
+[cla]: http://dojofoundation.org/about/cla
+[claCheck]: http://dojofoundation.org/about/claCheck
+[Creating a Pull Request]: https://help.github.com/articles/creating-a-pull-request
+[Fork a Repo]: https://help.github.com/articles/fork-a-repo
++[Intern]: http://theintern.io/
+[styleguide]: http://dojotoolkit.org/reference-guide/developer/styleguide.html
+[DojoDoc]: http://dojotoolkit.org/reference-guide/developer/markup.html
+[D.O.H.]: http://dojotoolkit.org/reference-guide/util/doh.html
+[dojo/util]: https://github.com/dojo/util
+[interactive rebase]: http://git-scm.com/book/en/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages
+[rebasing]: http://git-scm.com/book/en/Git-Branching-Rebasing
diff --cc dojox/bower.json
index 7071858,0000000..d8023ce
mode 100644,000000..100644
--- a/dojox/bower.json
+++ b/dojox/bower.json
@@@ -1,23 -1,0 +1,23 @@@
+{
+ "name": "dojox",
+ "main": "main.js",
+ "moduleType": [ "amd" ],
+ "licenses": [ "BSD-3-Clause", "AFL-2.1" ],
+ "ignore": [
+ ".*",
+ "tests"
+ ],
+ "keywords": [ "JavaScript", "Dojo", "Toolkit", "DojoX" ],
+ "authors": [],
+ "homepage": "http://dojotoolkit.org/",
+ "repository":{
+ "type": "git",
+ "url": "https://github.com/dojo/dojox.git"
+ },
+ "dependencies": {
- "dojo": "1.11.0-rc3",
- "dijit": "1.11.0-rc3"
++ "dojo": "1.11.0",
++ "dijit": "1.11.0"
+ },
+ "devDependencies": {
- },
++ }
+}
diff --cc dojox/package.json
index ba455bb,0000000..3304151
mode 100644,000000..100644
--- a/dojox/package.json
+++ b/dojox/package.json
@@@ -1,22 -1,0 +1,22 @@@
+{
+ "name": "dojox",
- "version": "1.11.0-rc3",
++ "version": "1.11.0",
+ "directories": {
+ "lib": "."
+ },
+ "main": "main",
+ "dependencies": {
- "dojo": "1.11.0-rc3",
- "dijit": "1.11.0-rc3"
++ "dojo": "1.11.0",
++ "dijit": "1.11.0"
+ },
+ "description": "Dojo eXtensions, a rollup of many useful sub-projects and varying states of maturity – from very stable and robust, to alpha and experimental. See individual projects contain README files for details.",
+ "license" : "BSD-3-Clause OR AFL-2.1",
+ "bugs": "http://bugs.dojotoolkit.org/",
+ "keywords": [ "JavaScript", "Dojo", "Toolkit", "DojoX" ],
+ "homepage": "http://dojotoolkit.org/",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/dojo/dojox.git"
+ },
+ "dojoBuild": "dojox.profile.js"
+}
diff --cc themes/CONTRIBUTING.md
index 4bec4e8,0000000..b8c645d
mode 100644,000000..100644
--- a/themes/CONTRIBUTING.md
+++ b/themes/CONTRIBUTING.md
@@@ -1,227 -1,0 +1,215 @@@
+_Do you have a contribution? We welcome contributions, but please ensure that you read the following information
+before issuing a pull request. Also refer back to this document as a checklist before issuing your pull request.
+This will save time for everyone._
+
+# Before You Start
+
+## Understanding the Basics
+
+If you don't understand what a *pull request* is, or how to submit one, please refer to the [help documentation][]
+provided by GitHub.
+
+## Is It Really a Support Issue
+
+If you aren't sure if your contribution is needed or necessary, please visit the [support forum][] before attempting to
+submit a pull request or a ticket.
+
+## Search Dojo Toolkit's Bug Database
+
+We require every commit to be tracked via our [bug database][]. It is useful, before you get too far, that you have
+checked that your issue isn't already known, otherwise addressed? If you think it is a valid defect or enhancement,
+please open a new ticket before submitting your pull request.
+
+## Discuss Non-Trivial Contributions with the Committers
+
+If your desired contribution is more than a non-trivial fix, you should discuss it on the
+[contributor's mailing list][dojo-contrib]. If you currently are not a member, you can request to be added.
+
+## Contributor License Agreement
+
+We require all contributions, to be covered under the Dojo Foundation's [Contributor License Agreement][cla]. This can
+be done electronically and essentially ensures that you are making it clear that your contributions are your
- contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
++contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
+Foundation.
+
+If you are an unfamiliar contributor to the committer assessing your pull request, it is best to make it clear how
+you are covered by a CLA in the notes of the pull request. The committer will [verify][claCheck] your status.
+
+If your GitHub user id you are submitting your pull request from differs from the Dojo Community ID or e-mail address
+which you have signed your CLA under, you should specifically note what you have your CLA filed under (and for CCLA
+that you are listed under your company's authorised contributors).
+
+# Submitting a Pull Request
+
+The following are the general steps you should follow in creating a pull request. Subsequent pull requests only need
+to follow step 3 and beyond:
+
+1. Fork the repository on GitHub
+2. Clone the forked repository to your machine
+3. Create a "feature" branch in your local repository
+4. Make your changes and commit them to your local repository
+5. Rebase and push your commits to your GitHub remote fork/repository
+6. Issue a Pull Request to the official repository
+7. Your Pull Request is reviewed by a committer and merged into the repository
+
+*Note*: While there are other ways to accomplish the steps using other tools, the examples here will assume the most
+actions will be performed via the `git` command line.
+
+## 1. Fork the Repository
+
+When logged in to your GitHub account, and you are viewing one of the main repositories, you will see the *Fork* button.
+Clicking this button will show you which organizations your can fork to. Choose your own account. Once the process
+finishes, you will have your own repository that is "forked" from the official one.
+
+Forking is a GitHub term and not a git term. Git is a wholly distributed source control system and simply worries
+about local and remote repositories and allows you to manage your code against them. GitHub then adds this additional
+layer of structure of how repositories can relate to each other.
+
+## 2. Clone the Forked Repository
+
+Once you have successfully forked your repository, you will need to clone it locally to your machine:
+
+```bash
- $ git clone --recursive git at github.com:username/dojo.git
++$ git clone --recursive git at github.com:username/themes.git
+```
+
- This will clone your fork to your current path in a directory named `dojo`.
++This will clone your fork to your current path in a directory named `themes`.
+
- It is important that you clone recursively for ``dojox``, ``demos`` or ``util``because some of the code is contained in
- submodules. You won't be able to submit your changes to the repositories that way though. If you are working on any of
- these sub-projects, you should contact those project leads to see if their workflow differs.
++To test your work in this repo against Dojo, Dijit, DojoX, and dgrid, you will need to either include the relevant
++release locally, or clone those repositories as well.
+
+You should also set up the `upstream` repository. This will allow you to take changes from the "master" repository
+and merge them into your local clone and then push them to your GitHub fork:
+
+```bash
- $ cd dojo
- $ git remote add upstream git at github.com:dojo/dojo.git
++$ cd themes
++$ git remote add upstream git at github.com:dojo/themes.git
+$ git fetch upstream
+```
+
+Then you can retrieve upstream changes and rebase on them into your code like this:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+For more information on maintaining a fork, please see the GitHub Help article [Fork a Repo][] and information on
+[rebasing][] from git.
+
+## 3. Create a Branch
+
+The easiest workflow is to keep your master branch in sync with the upstream branch and do not locate any of your own
+commits in that branch. When you want to work on a new feature, you then ensure you are on the master branch and create
+a new branch from there. While the name of the branch can be anything, it can often be easy to use the ticket number
+you might be working on. For example:
+
+```bash
+$ git checkout -b t12345 master
+Switched to a new branch 't12345'
+```
+
+You will then be on the feature branch. You can verify what branch you are on like this:
+
+```bash
+$ git status
+# On branch t12345
+nothing to commit, working directory clean
+```
+
+## 4. Make Changes and Commit
+
+Now you just need to make your changes. Once you have finished your changes (and tested them) you need to commit them
+to your local repository (assuming you have staged your changes for committing):
+
+```bash
+$ git status
+# On branch t12345
+# Changes to be committed:
+# (use "git reset HEAD <file>..." to unstage)
+#
+# modified: somefile.js
+#
+$ git commit -m "Corrects some defect, fixes #12345, refs #12346"
+[t12345 0000000] Corrects some defect, fixes #12345, refs #12346
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+```
+
+## 5. Rebase and Push Changes
+
+If you have been working on your contribution for a while, the upstream repository may have changed. You may want to
+ensure your work is on top of the latest changes so your pull request can be applied cleanly:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+When you are ready to push your commit to your GitHub repository for the first time on this branch you would do the
+following:
+
+```bash
+$ git push -u origin t12345
+```
+
+After the first time, you simply need to do:
+
+```bash
+$ git push
+```
+
+## 6. Issue a Pull Request
+
+In order to have your commits merged into the main repository, you need to create a pull request. The instructions for
+this can be found in the GitHub Help Article [Creating a Pull Request][]. Essentially you do the following:
+
+1. Go to the site for your repository.
+2. Click the Pull Request button.
+3. Select the feature branch from your repository.
+4. Enter a title and description of your pull request mentioning the corresponding [bug database][] ticket in the description.
+5. Review the commit and files changed tabs.
+6. Click `Send Pull Request`
+
+You will get notified about the status of your pull request based on your GitHub settings.
+
+## 7. Request is Reviewed and Merged
+
+Your request will be reviewed. It may be merged directly, or you may receive feedback or questions on your pull
+request.
+
+# What Makes a Successful Pull Request?
+
+Having your contribution accepted is more than just the mechanics of getting your contribution into a pull request,
+there are several other things that are expected when contributing to the Dojo Toolkit which are covered below.
+
+## Coding Style and Linting
+
+Dojo has a very specific [coding style][styleguide]. All pull requests should adhere to this.
+
+## Inline Documentation
+
- Dojo has an inline API documentation called [DojoDoc][]. Any pull request should ensure it has updated the inline
- documentation appropriately or added the appropriate inline documentation.
-
- ## Test Cases
-
- If the pull request changes the functional behaviour or is fixing a defect, the unit test cases should be modified to
- reflect this. The committer reviewing your pull request is likely to request the appropriate changes in the test
- cases. Dojo utilises its own test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository.
-
- It is expected that you will have tested your changes against the existing test cases and appropriate platforms prior to
- submitting your pull request.
++Any non-obvious style rules should include a valid CSS comment.
+
+## Licensing
+
+All of your submissions are licensed under a dual "New" BSD/AFL license.
+
+## Expect Discussion and Rework
+
+Unless you have been working with contributing to Dojo for a while, expect a significant amount of feedback on your
+pull requests. We are a very passionate community and even the committers often will provide robust feedback to each
+other about their code. Don't be offended by such feedback or feel that your contributions aren't welcome, it is just
+that we are quite passionate and Dojo has a long history with many things that are the "Dojo-way" which may be
+unfamiliar to those who are just starting to contribute.
+
+[help documentation]: http://help.github.com/send-pull-requests
+[bug database]: http://bugs.dojotoolkit.org/
+[support forum]: http://dojotoolkit.org/community/
+[dojo-contrib]: http://mail.dojotoolkit.org/mailman/listinfo/dojo-contributors
+[cla]: http://dojofoundation.org/about/cla
+[claCheck]: http://dojofoundation.org/about/claCheck
+[Creating a Pull Request]: https://help.github.com/articles/creating-a-pull-request
+[Fork a Repo]: https://help.github.com/articles/fork-a-repo
+[styleguide]: http://dojotoolkit.org/reference-guide/developer/styleguide.html
+[DojoDoc]: http://dojotoolkit.org/reference-guide/developer/markup.html
- [D.O.H.]: http://dojotoolkit.org/reference-guide/util/doh.html
+[dojo/util]: https://github.com/dojo/util
+[interactive rebase]: http://git-scm.com/book/en/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages
+[rebasing]: http://git-scm.com/book/en/Git-Branching-Rebasing
diff --cc themes/bower.json
index ebecc0a,0000000..00c7534
mode 100644,000000..100644
--- a/themes/bower.json
+++ b/themes/bower.json
@@@ -1,20 -1,0 +1,20 @@@
+{
+ "name": "dojo-themes",
+ "licenses": [ "BSD-3-Clause", "AFL-2.1"],
+ "ignore": [
+ ".*"
+ ],
+ "keywords": ["JavaScript", "Dojo", "Toolkit", "Themes"],
+ "authors": [],
+ "homepage": "http://dojotoolkit.org/",
+ "repository":{
+ "type": "git",
+ "url": "https://github.com/dojo/themes.git"
+ },
+ "dependencies": {
+ },
+ "devDependencies": {
- "stylus": "0.53.0",
- "nib": "1.1.0"
++ "stylus": "0.53.0",
++ "nib": "1.1.0"
+ }
+}
diff --cc themes/package.json
index 8be2bf3,0000000..d4484a6
mode 100644,000000..100644
--- a/themes/package.json
+++ b/themes/package.json
@@@ -1,28 -1,0 +1,28 @@@
+{
+ "name": "dojo-themes",
- "version": "1.11.0-rc3",
++ "version": "1.11.0",
+ "description": "Dojo 1.x modern themes",
+ "license" : "BSD-3-Clause OR AFL-2.1",
+ "bugs": "http://bugs.dojotoolkit.org/",
+ "keywords": ["Dojo", "Dijit", "Themes"],
+ "homepage": "http://dojotoolkit.org/",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/dojo/themes.git"
+ },
+ "dojoBuild": "themes.profile.js",
+ "peerDependencies": {
- "dojo": "1.11.0-rc3",
- "dijit": "1.11.0-rc3"
++ "dojo": "1.11.0",
++ "dijit": "1.11.0"
+ },
+ "devDependencies": {
+ "grunt": "^0.4",
+ "grunt-contrib-watch": "^0",
+ "grunt-concurrent": "^2",
+ "grunt-contrib-connect": "^0",
+ "grunt-contrib-stylus": "^0.21.0",
+ "grunt-open": "^0",
+ "grunt-newer": "^1.1.0"
+ },
+ "engine": "node >= 0.10"
+}
diff --cc util/CONTRIBUTING.md
index 566a014,0000000..ac63376
mode 100644,000000..100644
--- a/util/CONTRIBUTING.md
+++ b/util/CONTRIBUTING.md
@@@ -1,227 -1,0 +1,228 @@@
+_Do you have a contribution? We welcome contributions, but please ensure that you read the following information
+before issuing a pull request. Also refer back to this document as a checklist before issuing your pull request.
+This will save time for everyone._
+
+# Before You Start
+
+## Understanding the Basics
+
+If you don't understand what a *pull request* is, or how to submit one, please refer to the [help documentation][]
+provided by GitHub.
+
+## Is It Really a Support Issue
+
+If you aren't sure if your contribution is needed or necessary, please visit the [support forum][] before attempting to
+submit a pull request or a ticket.
+
+## Search Dojo Toolkit's Bug Database
+
+We require every commit to be tracked via our [bug database][]. It is useful, before you get too far, that you have
+checked that your issue isn't already known, otherwise addressed? If you think it is a valid defect or enhancement,
+please open a new ticket before submitting your pull request.
+
+## Discuss Non-Trivial Contributions with the Committers
+
+If your desired contribution is more than a non-trivial fix, you should discuss it on the
+[contributor's mailing list][dojo-contrib]. If you currently are not a member, you can request to be added.
+
+## Contributor License Agreement
+
+We require all contributions, to be covered under the Dojo Foundation's [Contributor License Agreement][cla]. This can
+be done electronically and essentially ensures that you are making it clear that your contributions are your
- contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
++contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo
+Foundation.
+
+If you are an unfamiliar contributor to the committer assessing your pull request, it is best to make it clear how
+you are covered by a CLA in the notes of the pull request. The committer will [verify][claCheck] your status.
+
+If your GitHub user id you are submitting your pull request from differs from the Dojo Community ID or e-mail address
+which you have signed your CLA under, you should specifically note what you have your CLA filed under (and for CCLA
+that you are listed under your companies authorised contributors).
+
+# Submitting a Pull Request
+
+The following are the general steps you should follow in creating a pull request. Subsequent pull requests only need
+to follow step 3 and beyond:
+
+1. Fork the repository on GitHub
+2. Clone the forked repository to your machine
+3. Create a "feature" branch in your local repository
+4. Make your changes and commit them to your local repository
+5. Rebase and push your commits to your GitHub remote fork/repository
+6. Issue a Pull Request to the official repository
+7. Your Pull Request is reviewed by a committer and merged into the repository
+
+*Note* While there are other ways to accomplish the steps using other tools, the examples here will assume the most
+actions will be performed via the `git` command line.
+
+## 1. Fork the Repository
+
+When logged into your GitHub account, and you are viewing one of the main repositories, you will see the *Fork* button.
+Clicking this button will show you which repositories your can fork to. Choose your own account. Once the process
+finishes, you will have your own repository that is "forked" from the GitHub one.
+
+Forking is a GitHub term and not a git term. Git is a wholly distributed source control system and simply worries
+about local and remote repositories and allows you to manage your code against them. GitHub then adds this additional
+layer of structure of how repositories can relate to each other.
+
+## 2. Clone the Forked Repository
+
+Once you have successfully forked your repository, you will need to clone it locally to your machine:
+
+```bash
+$ git clone --recursive git at github.com:username/util.git
+```
+
+This will clone your fork to your current path in a directory named `util`.
+
- It is important that you clone recursively for ``dojox``, ``demos`` or ``util``because some of the code is contained in
++It is important that you clone recursively for ``dojox``, ``demos`` or ``util`` because some of the code is contained in
+submodules. You won't be able to submit your changes to the repositories that way though. If you are working on any of
+these sub-projects, you should contact those project leads to see if their workflow differs.
+
+You should also setup the `upstream` repository. This will allow you to take changes from the "master" repository
+and merge them into your local clone and then push them to your GitHub fork:
+
+```bash
+$ cd util
+$ git remote add upstream git at github.com:dojo/util.git
+$ git fetch upstream
+```
+
+Then you can retrieve upstream changes and rebase on them into your code like this:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+For more information on maintaining a fork, please see the GitHub Help article [Fork a Repo][] and information on
+[rebasing][] from git.
+
+## 3. Create a Branch
+
+The easiest workflow is to keep your master branch in sync with the upstream branch and do not locate any of your own
+commits in that branch. When you want to work on a new feature, you then ensure you are on the master branch and create
+a new branch from there. While the name of the branch can be anything, it can often be easy to use the ticket number
+you might be working on. For example:
+
+```bash
+$ git checkout -b t12345 master
+Switched to a new branch 't12345'
+```
+
+You will then be on the feature branch. You can verify what branch you are on like this:
+
+```bash
+$ git status
+# On branch t12345
+nothing to commit, working directory clean
+```
+
+## 4. Make Changes and Commit
+
+Now you just need to make your changes. Once you have finished your changes (and tested them) you need to commit them
+to your local repository (assuming you have staged your changes for committing):
+
+```bash
+$ git status
+# On branch t12345
+# Changes to be committed:
+# (use "git reset HEAD <file>..." to unstage)
+#
+# modified: somefile.js
+#
+$ git commit -m "Corrects some defect, fixes #12345, refs #12346"
+[t12345 0000000] Corrects some defect, fixes #12345, refs #12346
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+```
+
+## 5. Rebase and Push Changes
+
+If you have been working on your contribution for a while, the upstream repository may have changed. You may want to
+ensure your work is on top of the latest changes so your pull request can be applied cleanly:
+
+```bash
+$ git pull --rebase upstream master
+```
+
+When you are ready to push your commit to your GitHub repository for the first time on this branch you would do the
+following:
+
+```bash
+$ git push -u origin t12345
+```
+
+After the first time, you simply need to do:
+
+```bash
+$ git push
+```
+
+## 6. Issue a Pull Request
+
+In order to have your commits merged into the main repository, you need to create a pull request. The instructions for
+this can be found in the GitHub Help Article [Creating a Pull Request][]. Essentially you do the following:
+
+1. Go to the site for your repository.
+2. Click the Pull Request button.
+3. Select the feature branch from your repository.
+4. Enter a title and description of your pull request.
+5. Review the commit and files changed tabs.
+6. Click `Send Pull Request`
+
+You will get notified about the status of your pull request based on your GitHub settings.
+
+## 7. Request is Reviewed and Merged
+
+Your request will be reviewed. It may be merged directly, or you may receive feedback or questions on your pull
+request.
+
+# What Makes a Successful Pull Request?
+
+Having your contribution accepted is more than just the mechanics of getting your contribution into a pull request,
+there are several other things that are expected when contributing to the Dojo Toolkit which are covered below.
+
+## Coding Style and Linting
+
+Dojo has a very specific [coding style][styleguide]. All pull requests should adhere to this.
+
+## Inline Documentation
+
+Dojo has an inline API documentation called [DojoDoc][]. Any pull request should ensure it has updated the inline
+documentation appropriately or added the appropriate inline documentation.
+
+## Test Cases
+
+If the pull request changes the functional behaviour or is fixing a defect, the unit test cases should be modified to
+reflect this. The committer reviewing your pull request is likely to request the appropriate changes in the test
- cases. Dojo utilises its own test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository.
++cases. Dojo utilises [Intern][] for all new tests, and has legacy support for its previous generation test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository. All new tests should be authored using Intern.
+
+It is expected that you will have tested your changes against the existing test cases and appropriate platforms prior to
+submitting your pull request.
+
+## Licensing
+
+All of your submissions are licensed under a dual "New" BSD/AFL license.
+
+## Expect Discussion and Rework
+
+Unless you have been working with contributing to Dojo for a while, expect a significant amount of feedback on your
+pull requests. We are a very passionate community and even the committers often will provide robust feedback to each
+other about their code. Don't be offended by such feedback or feel that your contributions aren't welcome, it is just
+that we are quite passionate and Dojo has a long history with many things that are the "Dojo-way" which may be
+unfamiliar to those who are just starting to contribute.
+
+[help documentation]: http://help.github.com/send-pull-requests
+[bug database]: http://bugs.dojotoolkit.org/
+[support forum]: http://dojotoolkit.org/community/
+[dojo-contrib]: http://mail.dojotoolkit.org/mailman/listinfo/dojo-contributors
+[cla]: http://dojofoundation.org/about/cla
+[claCheck]: http://dojofoundation.org/about/claCheck
+[Creating a Pull Request]: https://help.github.com/articles/creating-a-pull-request
+[Fork a Repo]: https://help.github.com/articles/fork-a-repo
++[Intern]: http://theintern.io/
+[styleguide]: http://dojotoolkit.org/reference-guide/developer/styleguide.html
+[DojoDoc]: http://dojotoolkit.org/reference-guide/developer/markup.html
+[D.O.H.]: http://dojotoolkit.org/reference-guide/util/doh.html
+[dojo/util]: https://github.com/dojo/util
+[interactive rebase]: http://git-scm.com/book/en/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages
- [rebasing]: http://git-scm.com/book/en/Git-Branching-Rebasing
++[rebasing]: http://git-scm.com/book/en/Git-Branching-Rebasing
diff --cc util/bower.json
index 7dc852c,0000000..78e85ca
mode 100644,000000..100644
--- a/util/bower.json
+++ b/util/bower.json
@@@ -1,24 -1,0 +1,24 @@@
+{
+ "name": "dojo-util",
+ "main": "",
+ "moduleType": [ "amd" ],
+ "licenses": [ "BSD-3-Clause", "AFL-2.1"],
+ "ignore": [
+ ".*"
+ ],
+ "keywords": ["JavaScript", "Dojo", "Toolkit", "Util", "Build System"],
+ "authors": [],
+ "homepage": "http://dojotoolkit.org/",
+ "repository":{
+ "type": "git",
+ "url": "https://github.com/dojo/util.git"
+ },
+ "dependencies": {
- "dojo": "1.11.0-rc3",
- "dijit": "1.11.0-rc3",
- "dojox": "1.11.0-rc3",
- "dojo-themes":"1.11.0-pre",
++ "dojo": "1.11.0",
++ "dijit": "1.11.0",
++ "dojox": "1.11.0",
++ "dojo-themes":"1.11.0-pre"
+ },
+ "devDependencies": {
- },
++ }
+}
diff --cc util/build/version.js
index b721987,0000000..3783581
mode 100644,000000..100644
--- a/util/build/version.js
+++ b/util/build/version.js
@@@ -1,13 -1,0 +1,13 @@@
+define([], function(){
+ var
- rev = "$Rev: 3fda435 $".match(/[0-9a-f]{7,}/),
++ rev = "$Rev: 32aadc8 $".match(/[0-9a-f]{7,}/),
+ version= {
- major: 1, minor: 11, patch: 0, flag: "-rc3",
++ major: 1, minor: 11, patch: 0, flag: "",
+ revision: rev ? rev[0] : NaN,
+ toString: function(){
+ var v= version;
+ return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";
+ }
+ };
+ return version;
+});
diff --cc util/doh/_nodeRunner.js
index 9361cc0,0000000..fc51b8b
mode 100644,000000..100644
--- a/util/doh/_nodeRunner.js
+++ b/util/doh/_nodeRunner.js
@@@ -1,40 -1,0 +1,40 @@@
+define(["doh/runner", "require", "dojo/_base/config"], function(doh, require, config){
+ /*=====
+ return {
+ // summary:
+ // Module for running DOH tests in node (as opposed to a browser).
+ // Augments return value from doh/runner.
+ };
+ =====*/
+
+ doh.debug= console.log;
+ doh.error= console.log;
+
+ // Override the doh._report method to make it quit with an
+ // appropriate exit code in case of test failures.
+ var oldReport = doh._report;
+ doh._report = function(){
+ oldReport.apply(doh, arguments);
+ if(this._failureCount > 0 || this._errorCount > 0){
+ process.exit(1);
+ }
+ };
+
+ console.log("\n"+doh._line);
- console.log("The Dojo Unit Test Harness, $Rev: 3fda435 $");
++ console.log("The Dojo Unit Test Harness, $Rev: 32aadc8 $");
+ console.log("Copyright (c) 2011, The Dojo Foundation, All Rights Reserved");
+ console.log("Running with node.js");
+ for (var tests= [], args= config["commandLineArgs"], i= 0, arg; i<args.length; i++) {
+ arg= args[i];
+ if (arg.length==2 && arg[0]=="test") {
+ var test= arg[1];
+ console.log("loading test " + test);
+ tests.push(test);
+ }
+ }
+ console.log(doh._line, "\n");
+
+ require(tests, function() {
+ doh.run();
+ });
+});
diff --cc util/doh/_rhinoRunner.js
index 6d0b557,0000000..d1adc91
mode 100644,000000..100644
--- a/util/doh/_rhinoRunner.js
+++ b/util/doh/_rhinoRunner.js
@@@ -1,39 -1,0 +1,39 @@@
+define(["doh/runner", "require", "dojo/_base/config"], function(doh, require, config){
+ /*=====
+ return {
+ // summary:
+ // Module for running DOH tests in rhino (as opposed to a browser).
+ // Augments return value from doh/runner.
+ };
+ =====*/
+
+ doh.debug= print;
+ doh.error= print;
+
+ // Override the doh._report method to make it quit with an
+ // appropriate exit code in case of test failures.
+ var oldReport = doh._report;
+ doh._report = function(){
+ oldReport.apply(doh, arguments);
+ if(this._failureCount > 0 || this._errorCount > 0){
+ quit(1);
+ }
+ };
+
+ print("\n"+doh._line);
- print("The Dojo Unit Test Harness, $Rev: 3fda435 $");
++ print("The Dojo Unit Test Harness, $Rev: 32aadc8 $");
+ print("Copyright (c) 2011, The Dojo Foundation, All Rights Reserved");
+ for (var tests= [], args= config["commandLineArgs"], i= 0, arg; i<args.length; i++) {
+ arg= (args[i]+"").split("=");
+ if (arg.length==2 && arg[0]=="test") {
+ var test= arg[1];
+ print("loading test " + test);
+ tests.push(test);
+ }
+ }
+ print(doh._line, "\n");
+
+ require(tests, function() {
+ doh.run();
+ });
+});
diff --cc util/doh/mobileRunner.html
index 42b4222,0000000..99e0b1b
mode 100644,000000..100644
--- a/util/doh/mobileRunner.html
+++ b/util/doh/mobileRunner.html
@@@ -1,88 -1,0 +1,88 @@@
+<!DOCTYPE html>
+<html style="height:100%;">
+ <head>
- <title>The Dojo Unit Test Harness, $Rev: 3fda435 $</title>
++ <title>The Dojo Unit Test Harness, $Rev: 32aadc8 $</title>
+ <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1"/>
+ <meta name="apple-mobile-web-app-capable" content="yes">
+ <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
+ <script type="text/javascript">
+ // workaround for bug in Safari 3. See #7189
+ if (/3[\.0-9]+ Safari/.test(navigator.appVersion))
+ {
+ window.console = {
+ origConsole: window.console,
+ log: function(s){
+ this.origConsole.log(s);
+ },
+ info: function(s){
+ this.origConsole.info(s);
+ },
+ error: function(s){
+ this.origConsole.error(s);
+ },
+ warn: function(s){
+ this.origConsole.warn(s);
+ }
+ };
+ }
+ </script>
+
+ <script type="text/javascript" src="_parseURLargs.js"></script>
+
+ <style type="text/css">
+ @import "../../dojo/resources/dojo.css";
+
+ #testLayout {
+ position: relative;
+ left: 0px;
+ top: 0px;
+ width: 100%;
+ height: 100%;
+ border: 1px solid black;
+ border: 0px;
+ }
+
+ .tabBody {
+ margin: 0px;
+ padding: 0px;
+ /*
+ border: 1px solid black;
+ */
+ background-color: #DEDEDE;
+ border: 0px;
+ width: 100%;
+ height: 100%;
+ position: absolute;
+ left: 0px;
+ top: 0px;
+ overflow: auto;
+ }
+
+ #logBody {
+ padding-left: 5px;
+ padding-top: 5px;
+ font-family: Monaco, monospace;
+ font-size: 11px;
+ white-space: pre;
+ }
+
+
+ </style>
+ </head>
+ <body style="height: 100%;">
+ <div style="position: relative; width: 100%; height: 100%; top: 0px; left: 0px;">
+ <div class="tabBody"
+ style="z-index: 1;">
+ <pre id="logBody"></pre>
+ <div id="perfTestsBody" style="background-color: white;"></div>
+ </div>
+ <iframe id="testBody" class="tabBody"
+ style="z-index: -1;"></iframe>
+ <!--
+ src="http://redesign.dojotoolkit.org"></iframe>
+ -->
+ </div>
+ <span id="hiddenAudio"></span>
+ </body>
+</html>
+
diff --cc util/doh/package.json
index 0b84e65,0000000..3405830
mode 100644,000000..100644
--- a/util/doh/package.json
+++ b/util/doh/package.json
@@@ -1,23 -1,0 +1,23 @@@
+{
+ "name": "doh",
- "version": "1.11.0-rc3",
++ "version": "1.11.0",
+ "directories": {
+ "lib": "."
+ },
+ "main": "main",
+ "description": "DOH is a unit test framework developed by the Dojo Toolkit Community.",
+ "licenses": [
+ {
+ "type": "AFLv2.1",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
+ },
+ {
+ "type": "BSD",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
+ }
+ ],
+ "bugs": "http://bugs.dojotoolkit.org/",
+ "keywords": ["JavaScript", "Dojo", "Toolkit", "DOH"],
+ "homepage": "http://dojotoolkit.org/",
+ "dojoBuild": "doh.profile.js"
+}
diff --cc util/doh/runner.html
index 5a7d635,0000000..fa9b0fe
mode 100644,000000..100644
--- a/util/doh/runner.html
+++ b/util/doh/runner.html
@@@ -1,251 -1,0 +1,251 @@@
+<!DOCTYPE html>
+<html style="height:100%;">
+ <head>
- <title>The Dojo Unit Test Harness, $Rev: 3fda435 $</title>
++ <title>The Dojo Unit Test Harness, $Rev: 32aadc8 $</title>
+
+ <script type="text/javascript" src="_parseURLargs.js"></script>
+
+ <style type="text/css">
+ @import "../../dojo/resources/dojo.css";
+ /*
+ body {
+ margin: 0px;
+ padding: 0px;
+ font-size: 13px;
+ color: #292929;
+ font-family: Myriad, Lucida Grande, Bitstream Vera Sans, Arial, Helvetica, sans-serif;
+ *font-size: small;
+ *font: x-small;
+ }
+
+ th, td {
+ font-size: 13px;
+ color: #292929;
+ font-family: Myriad, Lucida Grande, Bitstream Vera Sans, Arial, Helvetica, sans-serif;
+ font-weight: normal;
+ }
+
+ * body {
+ line-height: 1.25em;
+ }
+
+ table {
+ border-collapse: collapse;
+ }
+ */
+
+ #testLayout {
+ position: relative;
+ left: 0px;
+ top: 0px;
+ width: 100%;
+ height: 100%;
+ border: 1px solid black;
+ border: 0px;
+ }
+
+ .tabBody {
+ margin: 0px;
+ padding: 0px;
+ /*
+ border: 1px solid black;
+ */
+ background-color: #DEDEDE;
+ border: 0px;
+ width: 100%;
+ height: 100%;
+ position: absolute;
+ left: 0px;
+ top: 0px;
+ overflow: auto;
+ }
+
+ #logBody {
+ padding-left: 5px;
+ padding-top: 5px;
+ font-family: Monaco, monospace;
+ font-size: 11px;
+ white-space: pre;
+ }
+
+ #progressOuter {
+ background-color: #e9e9e9;
+ background-image: -webkit-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+ background-image: -moz-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+ background-image: -ms-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+ background-image: -o-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+
+ height: 1em;
+ /*the following trick is necessary to prevent IE from wrapping the last piece of progress bar into a new line*/
+ _margin:1px;
+ _padding: -1px;
+ }
+
+ #progressOuter .success, #progressOuter .failure{
+ float: left;
+ height: 1em;
+ }
+
+ #play, #pause {
+ font-family: Arial;
+ font-size: 1.4em;
+ border: 1px solid #DEDEDE;
+ cursor: pointer;
+ padding-right: 0.5em;
+ }
+
+ .header {
+ border: 1px solid #DEDEDE;
+ }
+
+ button.tab {
+ border-width: 1px 1px 0px 1px;
+ border-style: solid;
+ border-color: #DEDEDE;
+ margin-right: 5px;
+ }
+
+ #testListContainer {
+ /*
+ border: 1px solid black;
+ */
+ position: relative;
+ height: 99%;
+ width: 100%;
+ overflow: auto;
+ }
+
+ #testList {
+ border-collapse: collapse;
+ position: absolute;
+ left: 0px;
+ width: 100%;
+ }
+
+ #testList td {
+ border-bottom: 1px solid #DEDEDE;
+ border-right : 1px solid #DEDEDE;
+ padding: 3px;
+ }
+
+ #testListHeader th {
+ border-bottom: 1px solid #DEDEDE;
+ border-right : 1px solid #DEDEDE;
+ padding: 3px;
+ font-weight: bolder;
+ font-style: italic;
+ }
+
+ #testList tfoot {
+ font-weight: bold;
+ }
+
+ #toggleButtons {
+ float: left;
+ background-color: #DEDEDE;
+ }
+
+ div.testGroupName {
+ position: absolute;
+ }
+
+ .inProgress {
+ background-color: #85afde;
+ }
+
+ .success {
+ background-color: #7cdea7;
+ }
+
+ .failure {
+ background-color: #de827b;
+ }
+ </style>
+ </head>
+ <body style="height: 100%;">
+ <table id="testLayout" cellpadding="0" cellspacing="0" style="margin: 0;">
+ <tr valign="top" height="40">
+ <td colspan="2" id="logoBar">
+ <h3 style="margin: 5px 5px 0px 5px; float: left;">D.O.H.: The Dojo Objective Harness</h3>
+ <img src="small_logo.png" height="40" style="margin: 0px 5px 0px 5px; float: right;">
+ <span style="margin: 10px 5px 0px 5px; float: right;">
+ <input type="checkbox" id="audio" name="audio">
+ <label for="audio">sounds?</label>
+ </span>
+ </td>
+ </tr>
+ <tr valign="top" height="10">
+ <td colspan="2"><div id="progressOuter" onclick="doh._jumpToSuite(arguments[0]);"></div></td>
+ </tr>
+ <tr valign="top" height="30">
+ <td width="30%" class="header">
+ <span id="toggleButtons" onclick="doh.togglePaused();">
+ <button id="play">►</button>
+ <button id="pause" style="display: none;">║</button>
+ </span>
+ <span id="runningStatus">
+ <span id="pausedMsg">Stopped</span>
+ <span id="playingMsg" style="display: none;">Tests Running</span>
+ </span>
+ </td>
+ <td width="*" class="header" valign="bottom">
+ <button class="tab" onclick="doh.showTestPage();">Test Page</button>
+ <button class="tab" onclick="doh.showLogPage();">Log</button>
+ <button class="tab" onclick="doh.showPerfTestsPage();">Performance Tests Results</button>
+ </td>
+ </tr>
+ <tr valign="top" style="border: 0; padding: 0; margin: 0;">
+ <td style="border: 0; padding: 0; margin: 0; height:100%;">
+ <div id="testListContainer">
+ <table cellpadding="0" cellspacing="0" border="0"
+ width="100%" id="testList" style="margin: 0;" onclick="doh._jumpToLog(arguments[0]);">
+ <thead>
+ <tr id="testListHeader" style="border: 0; padding: 0; margin: 0;" >
+ <th> </th>
+ <th width="20">
+ <input type="checkbox" checked
+ onclick="doh.toggleRunAll();">
+ </th>
+ <th width="*" style="text-align: left;">test</th>
+ <th width="50">time</th>
+ </tr>
+ </thead>
+ <tbody valign="top">
+ <tr id="groupTemplate" style="display: none;">
+ <td style="font-family: Arial; width: 15px;">►</td>
+ <td>
+ <input type="checkbox" checked>
+ </td>
+ <td>group name</td>
+ <td>10ms</td>
+ </tr>
+ <tr id="testTemplate" style="display: none;">
+ <td> </td>
+ <td> </td>
+ <td style="padding-left: 20px;">test name</td>
+ <td>10ms</td>
+ </tr>
+ </tbody>
+ </table>
+ </div>
+ </td>
+ <td style="height: 100%;">
+ <div style="position: relative; width: 100%; height: 100%; top: 0px; left: 0px;">
+ <div class="tabBody"
+ style="z-index: 1;">
+ <pre id="logBody"></pre>
+ <div id="perfTestsBody" style="background-color: white;"></div>
+ </div>
+ <iframe id="testBody" class="tabBody"
+ style="z-index: -1;"></iframe>
+ <!--
+ src="http://redesign.dojotoolkit.org"></iframe>
+ -->
+ </div>
+ </td>
+ </tr>
+ </table>
+ <span id="hiddenAudio"></span>
+ </body>
+</html>
+
diff --cc util/package.json
index 6f65015,0000000..4c74237
mode 100644,000000..100644
--- a/util/package.json
+++ b/util/package.json
@@@ -1,24 -1,0 +1,24 @@@
+{
+ "name": "dojo-util",
- "version": "1.11.0-rc3",
++ "version": "1.11.0",
+ "licenses": [
+ {
+ "type": "AFLv2.1",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
+ },
+ {
+ "type": "BSD",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
+ }
+ ],
+ "description": "Dojo utilities including build system for optimizing JavaScript application performance, and DOH testing tool",
+ "bugs": {
+ "url": "http://bugs.dojotoolkit.org/"
+ },
+ "keywords": ["JavaScript", "Dojo", "Toolkit", "util"],
+ "repository":{
+ "type": "git",
+ "url": "https://github.com/dojo/util.git"
+ },
+ "homepage": "http://dojotoolkit.org/"
+}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/dojo.git
More information about the Pkg-javascript-commits
mailing list