+ Starten Sie mit einem Link auf ein Wikimedia-Commons-Bild oder einen Wikipedia-Artikel die Anwendung.
+
+
+
+
+ Beantworten Sie die Fragen zur beabsichtigten Nutzung, um den Lizenzhinweis zu erstellen.
+
+
+
+
+ Lesen Sie nach, wie der Lizenzhinweis zu benutzen ist.
+
+
+
+
+ Kopieren Sie Ihren Lizenzhinweis und binden Sie ihn in Ihre Veröffentlichung ein, um das Bild entsprechend der Richtlinien zu nutzen.
+
+
+
+
+
+
+
+
+
+
+
Lizenzhinweisgenerator
+
Lizenzhinweise für Bilder aus Wikipedia und Wikimedia Commons
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Über das Tool
+
+
+
Diese Webseite soll Ihnen dabei helfen, Bilder aus Wikipedia und dem freien Medienarchiv Wikimedia Commons einfach und rechtssicher nachzunutzen.
+
Alle Bilder, die auf Wikipedia im freien Medienarchiv Wikimedia Commons veröffentlicht werden, sind zwar urheberrechtlich geschützt, stehen aber unter so genannten freien Lizenzen. Diese erlauben eine unkomplizierte Nachnutzung, wenn bestimmte Lizenzbedingungen eingehalten werden. Dafür ist kein gesondertes Einverständnis der Urheber erforderlich. Diese Anwendung soll dabei helfen, die erforderlichen Anforderungen an eine Nachnutzung einzuhalten und Hilfe bei der Verwendung frei lizenzierter Inhalte zu bieten. Dies funktioniert, indem ein Computerprogramm alle Informationen anzeigt, die zusammen in unmittelbarer Nähe zum nachgenutzten Bild abgedruckt bzw. angezeigt werden müssen. Dazu werden Sie durch einen kurzen Dialog geleitet, der Sie zur Art Ihrer individuellen Nachnutzung befragt. Nach Beantwortung dieser wenigen Fragen, können Sie schnell und einfach den entsprechenden Lizenzhinweis auf verschiedene Arten kopieren und in Ihre Veröffentlichung einbinden. Bisher deckt dieses Werkzeug mögliche Nachnutzungen in digitalen und gedruckten Medien ab, da dies die häufigsten Nutzungsformen sind. Andere Nutzungen (z.B. Ausstellungen, Sendungen, Live-Darbietungen) bleiben vorerst unberücksichtigt.
+
Wir bedanken uns herzlich für die Unterstützung des Fachanwalts für Urheber- und Medienrecht Dr. Till Jaeger, JBB Rechtsanwälte in Berlin.
+
Welche Lizenzen werden unterstützt?
+
+ Diese Anwendung unterstützt Bilder von Wikipedia und Wikimedia Commons, die unter Creative-Commons-Lizenzen freigegeben wurden. Folgende Lizenzen, sowie ihre portierte Versionen, werden unterstützt:
+
+
+
CC 0
+
CC BY 2.0 DE
+
CC BY 3.0 DE
+
CC BY 3.0 Unported
+
CC BY 4.0 International
+
CC BY-SA 1.0 (generic)
+
CC BY-SA 2.0 DE
+
CC BY-SA 3.0 DE
+
CC BY-SA 3.0 Unported
+
CC BY-SA 4.0 International
+
CC BY 1.0 (generic)
+
CC BY 2.0 (generic)
+
CC BY 2.5 (generic)
+
CC BY-SA 2.0 (generic)
+
CC BY-SA 2.5 (generic)
+
+
+ Der Lizenzhinweisgenerator soll die legale Nachnutzung von bestimmten urheberrechtlich geschützten Bildern vereinfachen. Sie kann niemals alle möglichen Anwendungsfälle und Besonderheiten abdecken und ersetzt in keinem Fall die qualifizierte juristische Beratung durch einen Anwalt.
+
+
+
+
+
+
+
+
+
+
+
+
Impressum und Datenschutz
+
+
+
+ Wikimedia Deutschland – Gesellschaft zur Förderung Freien Wissens e. V.
+ Tempelhofer Ufer 23/24
+ 10963 Berlin
+ E-Mail: info@wikimedia.de
+ Telefon: +49 (0)30-219 15 826-0
+ Fax: +49 (0)30-219 158 26-9
+
+
+ Geschäftsführender Vorstand: Christian Rickerts
+ Eingetragen im Vereinsregister des Amtsgerichts Charlottenburg, VR 23855. Inhaltlich Verantwortlicher gemäß § 55 Abs. 2 RStV: Christian Rickerts (Anschrift wie oben).
+
+
+ Der gesamte Quellcode des Lizenzhinweisgenerators wird unter der GNU General Public Licence (GPL v3) veröffentlicht. Der Code kann auf GitHub eingesehen, heruntergeladen und anschließend verändert und neu veröffentlicht werden. Alle Texte der Anwendung stehen unter der Lizenz Creative Commons Namensnennung - Weitergabe unter gleichen Bedingungen 4.0 International und können somit auch weitergenutzt, verändert und veröffentlicht werden.
+
+
+ Datenschutzhinweis
+
+
+ Personenbezogene Daten werden auf dieser Website nur im technisch notwendigen Umfang erhoben. In keinem Fall werden die erhobenen Daten verkauft oder aus anderen Gründen an Dritte weitergegeben. Im Folgenden erhalten Sie einen Überblick über die von uns im Rahmen dieser Website erhobenen Daten.
+ Log-Files: Bei der Nutzung dieses Angebots werden die von Ihrem Browser an den Server übermittelten Daten erfasst und gespeichert. Dies umfasst üblichweise Informationen über den Typ und die Version des von Ihnen verwendeten Browsers, das verwendete Betriebssystem, die Referrer-URL (die Website, von der aus Sie zu dieser Website gelangt sind), den Hostnamen des zugreifenden Rechners (die IP-Adresse) sowie die Uhrzeit der Serveranfrage. In der Regel lassen sich diese Daten nicht bestimmten Personen – und damit auch nicht Ihnen – zuordnen. Weder wird zu diesem Zweck ein Abgleich der Daten mit anderen Daten vorgenommen, noch werden sie hierfür mit anderen Daten zusammengeführt. Die Daten werden regelmäßig nach einer statistischen Auswertung gelöscht.
+
+
+ Diese Website verwendet Piwik, eine Open-Source-Software zur statistischen Auswertung und Analyse der Besucherzugriffe. Auch Piwik nutzt Cookies. Die durch Piwik erzeugten und in einem Cookie gespeicherten Informationen über Ihre Benutzung dieser Website werden auf unseren Servern in Deutschland gespeichert. Die IP-Adresse wird sofort nach der Verarbeitung und vor deren Speicherung anonymisiert. Sie können die Installation der Cookies durch eine entsprechende Einstellung Ihrer Browser-Software verhindern; wir weisen Sie jedoch darauf hin, dass Sie in diesem Fall eventuell nicht sämtliche Funktionen dieser Website vollumfänglich nutzen können. Zudem haben Sie die Möglichkeit, der Datenverarbeitung durch Piwik für die Zukunft zu widersprechen. Entfernen Sie hierfür das Häkchen in dem unten abgebildeten Kasten. In der Folge wird ein Piwik-Deaktivierungs-Cookie in Ihrem Browser abgelegt. Bitte beachten Sie, dass der Piwik-Deaktivierungs-Cookie dieser Website gelöscht wird, wenn Sie die in Ihrem Browser abgelegten Cookies entfernen.
+
+
+ Sie können sich hier entscheiden, ob in Ihrem Browser ein eindeutiger Webanalyse-Cookie abgelegt werden darf, um dem Betreiber der Website die Erfassung und Analyse verschiedener statistischer Daten zu ermöglichen.
+ Wenn Sie sich dagegen entscheiden möchten, klicken Sie den folgenden Link, um den Piwik-Deaktivierungs-Cookie in Ihrem Browser abzulegen.
+
Dieses Tool hilft Ihnen dabei, den korrekten Lizenhinweis für frei lizenzierte Inhalte zu generieren. Sie benötigen diesen Lizenzhinweis, wenn Sie ein frei lizenziertes Werk nachnutzen und veröffentlichen möchten. Unter einer Veröffentlichung versteht man z.B. das Posten eines Bildes auf Ihrem Blog, in sozialen Netzwerken oder die Abbildung in einem Druckerzeugnis. Möchten Sie den gewählten Inhalt in einem rein privaten Kontext nutzen und nicht öffentlich zugänglich machen, brauchen Sie sich nicht an die Lizenzbedingungen zu halten und somit auch keinen Lizenzhinweis anbringen. Wir möchten Ihnen dies trotzdem empfehlen. Unter einer privaten Nutzung versteht man z.B. das Versenden an Freunde per E-Mail oder den Druck eines Bildes für die eigenen Wohnräume.
+
Weitere gesetzliche Ausnahmen gelten für die Nachnutzung in wissenschaftlichen Publikationen oder als Zitat. In diesen Fällen können Sie wählen, ob Sie nur die gesetzlichen Vorgaben oder stattdessen die Lizenzbedingungen der Creative-Commons-Lizenz einhalten möchten.
+
+
+
+
+
+
+
+
diff --git a/redesign/js/app/Api.js b/js/app/Api.js
similarity index 100%
rename from redesign/js/app/Api.js
rename to js/app/Api.js
diff --git a/redesign/js/app/ApplicationError.js b/js/app/ApplicationError.js
similarity index 100%
rename from redesign/js/app/ApplicationError.js
rename to js/app/ApplicationError.js
diff --git a/redesign/js/app/Asset.js b/js/app/Asset.js
similarity index 100%
rename from redesign/js/app/Asset.js
rename to js/app/Asset.js
diff --git a/redesign/js/app/AttributionDialogue.js b/js/app/AttributionDialogue.js
similarity index 100%
rename from redesign/js/app/AttributionDialogue.js
rename to js/app/AttributionDialogue.js
diff --git a/redesign/js/app/Author.js b/js/app/Author.js
similarity index 100%
rename from redesign/js/app/Author.js
rename to js/app/Author.js
diff --git a/redesign/js/app/Dialogue.js b/js/app/Dialogue.js
similarity index 100%
rename from redesign/js/app/Dialogue.js
rename to js/app/Dialogue.js
diff --git a/redesign/js/app/DialogueEvaluation.js b/js/app/DialogueEvaluation.js
similarity index 100%
rename from redesign/js/app/DialogueEvaluation.js
rename to js/app/DialogueEvaluation.js
diff --git a/redesign/js/app/DialogueStep.js b/js/app/DialogueStep.js
similarity index 100%
rename from redesign/js/app/DialogueStep.js
rename to js/app/DialogueStep.js
diff --git a/redesign/js/app/FileForm.js b/js/app/FileForm.js
similarity index 100%
rename from redesign/js/app/FileForm.js
rename to js/app/FileForm.js
diff --git a/redesign/js/app/ImageInfo.js b/js/app/ImageInfo.js
similarity index 100%
rename from redesign/js/app/ImageInfo.js
rename to js/app/ImageInfo.js
diff --git a/redesign/js/app/InputHandler.js b/js/app/InputHandler.js
similarity index 100%
rename from redesign/js/app/InputHandler.js
rename to js/app/InputHandler.js
diff --git a/redesign/js/app/LICENCES.js b/js/app/LICENCES.js
similarity index 100%
rename from redesign/js/app/LICENCES.js
rename to js/app/LICENCES.js
diff --git a/redesign/js/app/Licence.js b/js/app/Licence.js
similarity index 100%
rename from redesign/js/app/Licence.js
rename to js/app/Licence.js
diff --git a/redesign/js/app/LicenceStep.js b/js/app/LicenceStep.js
similarity index 100%
rename from redesign/js/app/LicenceStep.js
rename to js/app/LicenceStep.js
diff --git a/redesign/js/app/LicenceStore.js b/js/app/LicenceStore.js
similarity index 100%
rename from redesign/js/app/LicenceStore.js
rename to js/app/LicenceStore.js
diff --git a/redesign/js/app/Messages.js b/js/app/Messages.js
similarity index 100%
rename from redesign/js/app/Messages.js
rename to js/app/Messages.js
diff --git a/redesign/js/app/WikiAsset.js b/js/app/WikiAsset.js
similarity index 100%
rename from redesign/js/app/WikiAsset.js
rename to js/app/WikiAsset.js
diff --git a/redesign/js/app/WikiAssetPage.js b/js/app/WikiAssetPage.js
similarity index 100%
rename from redesign/js/app/WikiAssetPage.js
rename to js/app/WikiAssetPage.js
diff --git a/redesign/js/app/templates/Attribution.handlebars b/js/app/templates/Attribution.handlebars
similarity index 100%
rename from redesign/js/app/templates/Attribution.handlebars
rename to js/app/templates/Attribution.handlebars
diff --git a/redesign/js/app/templates/AuthorStep.handlebars b/js/app/templates/AuthorStep.handlebars
similarity index 100%
rename from redesign/js/app/templates/AuthorStep.handlebars
rename to js/app/templates/AuthorStep.handlebars
diff --git a/redesign/js/app/templates/ChangeStep.handlebars b/js/app/templates/ChangeStep.handlebars
similarity index 100%
rename from redesign/js/app/templates/ChangeStep.handlebars
rename to js/app/templates/ChangeStep.handlebars
diff --git a/redesign/js/app/templates/CompilationStep.handlebars b/js/app/templates/CompilationStep.handlebars
similarity index 100%
rename from redesign/js/app/templates/CompilationStep.handlebars
rename to js/app/templates/CompilationStep.handlebars
diff --git a/redesign/js/app/templates/CreatorStep.handlebars b/js/app/templates/CreatorStep.handlebars
similarity index 100%
rename from redesign/js/app/templates/CreatorStep.handlebars
rename to js/app/templates/CreatorStep.handlebars
diff --git a/redesign/js/app/templates/Dialogue.handlebars b/js/app/templates/Dialogue.handlebars
similarity index 100%
rename from redesign/js/app/templates/Dialogue.handlebars
rename to js/app/templates/Dialogue.handlebars
diff --git a/redesign/js/app/templates/DialogueScreen.handlebars b/js/app/templates/DialogueScreen.handlebars
similarity index 100%
rename from redesign/js/app/templates/DialogueScreen.handlebars
rename to js/app/templates/DialogueScreen.handlebars
diff --git a/redesign/js/app/templates/Done.handlebars b/js/app/templates/Done.handlebars
similarity index 100%
rename from redesign/js/app/templates/Done.handlebars
rename to js/app/templates/Done.handlebars
diff --git a/redesign/js/app/templates/DosAndDonts.handlebars b/js/app/templates/DosAndDonts.handlebars
similarity index 100%
rename from redesign/js/app/templates/DosAndDonts.handlebars
rename to js/app/templates/DosAndDonts.handlebars
diff --git a/redesign/js/app/templates/EditingStep.handlebars b/js/app/templates/EditingStep.handlebars
similarity index 100%
rename from redesign/js/app/templates/EditingStep.handlebars
rename to js/app/templates/EditingStep.handlebars
diff --git a/redesign/js/app/templates/ImagePreview.handlebars b/js/app/templates/ImagePreview.handlebars
similarity index 100%
rename from redesign/js/app/templates/ImagePreview.handlebars
rename to js/app/templates/ImagePreview.handlebars
diff --git a/redesign/js/app/templates/ImageSuggestion.handlebars b/js/app/templates/ImageSuggestion.handlebars
similarity index 100%
rename from redesign/js/app/templates/ImageSuggestion.handlebars
rename to js/app/templates/ImageSuggestion.handlebars
diff --git a/redesign/js/app/templates/InfoBox.handlebars b/js/app/templates/InfoBox.handlebars
similarity index 100%
rename from redesign/js/app/templates/InfoBox.handlebars
rename to js/app/templates/InfoBox.handlebars
diff --git a/redesign/js/app/templates/LicenceStep.handlebars b/js/app/templates/LicenceStep.handlebars
similarity index 100%
rename from redesign/js/app/templates/LicenceStep.handlebars
rename to js/app/templates/LicenceStep.handlebars
diff --git a/redesign/js/app/templates/ProgressBar.handlebars b/js/app/templates/ProgressBar.handlebars
similarity index 100%
rename from redesign/js/app/templates/ProgressBar.handlebars
rename to js/app/templates/ProgressBar.handlebars
diff --git a/redesign/js/app/templates/PublicDomain.handlebars b/js/app/templates/PublicDomain.handlebars
similarity index 100%
rename from redesign/js/app/templates/PublicDomain.handlebars
rename to js/app/templates/PublicDomain.handlebars
diff --git a/redesign/js/app/templates/QuestionMark.handlebars b/js/app/templates/QuestionMark.handlebars
similarity index 100%
rename from redesign/js/app/templates/QuestionMark.handlebars
rename to js/app/templates/QuestionMark.handlebars
diff --git a/redesign/js/app/templates/SmallButton.handlebars b/js/app/templates/SmallButton.handlebars
similarity index 100%
rename from redesign/js/app/templates/SmallButton.handlebars
rename to js/app/templates/SmallButton.handlebars
diff --git a/redesign/js/app/templates/TypeOfUseStep.handlebars b/js/app/templates/TypeOfUseStep.handlebars
similarity index 100%
rename from redesign/js/app/templates/TypeOfUseStep.handlebars
rename to js/app/templates/TypeOfUseStep.handlebars
diff --git a/redesign/js/app/views/AttributionDialogueView.js b/js/app/views/AttributionDialogueView.js
similarity index 100%
rename from redesign/js/app/views/AttributionDialogueView.js
rename to js/app/views/AttributionDialogueView.js
diff --git a/redesign/js/app/views/DialogueEvaluationView.js b/js/app/views/DialogueEvaluationView.js
similarity index 100%
rename from redesign/js/app/views/DialogueEvaluationView.js
rename to js/app/views/DialogueEvaluationView.js
diff --git a/redesign/js/app/views/DialogueScreen.js b/js/app/views/DialogueScreen.js
similarity index 100%
rename from redesign/js/app/views/DialogueScreen.js
rename to js/app/views/DialogueScreen.js
diff --git a/redesign/js/app/views/DialogueStepView.js b/js/app/views/DialogueStepView.js
similarity index 100%
rename from redesign/js/app/views/DialogueStepView.js
rename to js/app/views/DialogueStepView.js
diff --git a/redesign/js/app/views/ImageSuggestionView.js b/js/app/views/ImageSuggestionView.js
similarity index 100%
rename from redesign/js/app/views/ImageSuggestionView.js
rename to js/app/views/ImageSuggestionView.js
diff --git a/redesign/js/app/views/InfoBoxView.js b/js/app/views/InfoBoxView.js
similarity index 100%
rename from redesign/js/app/views/InfoBoxView.js
rename to js/app/views/InfoBoxView.js
diff --git a/redesign/js/app/views/LicenceStepView.js b/js/app/views/LicenceStepView.js
similarity index 100%
rename from redesign/js/app/views/LicenceStepView.js
rename to js/app/views/LicenceStepView.js
diff --git a/redesign/js/app/views/ProgressBarView.js b/js/app/views/ProgressBarView.js
similarity index 100%
rename from redesign/js/app/views/ProgressBarView.js
rename to js/app/views/ProgressBarView.js
diff --git a/redesign/js/app/views/PublicDomainDialogueView.js b/js/app/views/PublicDomainDialogueView.js
similarity index 100%
rename from redesign/js/app/views/PublicDomainDialogueView.js
rename to js/app/views/PublicDomainDialogueView.js
diff --git a/redesign/js/background.js b/js/background.js
similarity index 100%
rename from redesign/js/background.js
rename to js/background.js
diff --git a/redesign/js/config.json b/js/config.json
similarity index 100%
rename from redesign/js/config.json
rename to js/config.json
diff --git a/redesign/js/i18n.json b/js/i18n.json
similarity index 100%
rename from redesign/js/i18n.json
rename to js/i18n.json
diff --git a/redesign/js/main.js b/js/main.js
similarity index 100%
rename from redesign/js/main.js
rename to js/main.js
diff --git a/redesign/js/scrolling_effects.js b/js/scrolling_effects.js
similarity index 100%
rename from redesign/js/scrolling_effects.js
rename to js/scrolling_effects.js
diff --git a/redesign/js/tracking.js b/js/tracking.js
similarity index 100%
rename from redesign/js/tracking.js
rename to js/tracking.js
diff --git a/redesign/js/view_helpers.js b/js/view_helpers.js
similarity index 100%
rename from redesign/js/view_helpers.js
rename to js/view_helpers.js
diff --git a/lib/dojo/AdapterRegistry.js b/lib/dojo/AdapterRegistry.js
deleted file mode 100644
index 4ed7b8a..0000000
--- a/lib/dojo/AdapterRegistry.js
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/AdapterRegistry",["./_base/kernel","./_base/lang"],function(_1,_2){
-var _3=_1.AdapterRegistry=function(_4){
-this.pairs=[];
-this.returnWrappers=_4||false;
-};
-_2.extend(_3,{register:function(_5,_6,_7,_8,_9){
-this.pairs[((_9)?"unshift":"push")]([_5,_6,_7,_8]);
-},match:function(){
-for(var i=0;i..." 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.
-
-## 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 --git a/lib/dojo/Deferred.js b/lib/dojo/Deferred.js
deleted file mode 100644
index afa9405..0000000
--- a/lib/dojo/Deferred.js
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/Deferred",["./has","./_base/lang","./errors/CancelError","./promise/Promise","./promise/instrumentation"],function(_1,_2,_3,_4,_5){
-"use strict";
-var _6=0,_7=1,_8=2;
-var _9="This deferred has already been fulfilled.";
-var _a=Object.freeze||function(){
-};
-var _b=function(_c,_d,_e,_f,_10){
-if(1){
-if(_d===_8&&_11.instrumentRejected&&_c.length===0){
-_11.instrumentRejected(_e,false,_f,_10);
-}
-}
-for(var i=0;i<_c.length;i++){
-_12(_c[i],_d,_e,_f);
-}
-};
-var _12=function(_13,_14,_15,_16){
-var _17=_13[_14];
-var _18=_13.deferred;
-if(_17){
-try{
-var _19=_17(_15);
-if(_14===_6){
-if(typeof _19!=="undefined"){
-_1a(_18,_14,_19);
-}
-}else{
-if(_19&&typeof _19.then==="function"){
-_13.cancel=_19.cancel;
-_19.then(_1b(_18,_7),_1b(_18,_8),_1b(_18,_6));
-return;
-}
-_1a(_18,_7,_19);
-}
-}
-catch(error){
-_1a(_18,_8,error);
-}
-}else{
-_1a(_18,_14,_15);
-}
-if(1){
-if(_14===_8&&_11.instrumentRejected){
-_11.instrumentRejected(_15,!!_17,_16,_18.promise);
-}
-}
-};
-var _1b=function(_1c,_1d){
-return function(_1e){
-_1a(_1c,_1d,_1e);
-};
-};
-var _1a=function(_1f,_20,_21){
-if(!_1f.isCanceled()){
-switch(_20){
-case _6:
-_1f.progress(_21);
-break;
-case _7:
-_1f.resolve(_21);
-break;
-case _8:
-_1f.reject(_21);
-break;
-}
-}
-};
-var _11=function(_22){
-var _23=this.promise=new _4();
-var _24=this;
-var _25,_26,_27;
-var _28=false;
-var _29=[];
-if(1&&Error.captureStackTrace){
-Error.captureStackTrace(_24,_11);
-Error.captureStackTrace(_23,_11);
-}
-this.isResolved=_23.isResolved=function(){
-return _25===_7;
-};
-this.isRejected=_23.isRejected=function(){
-return _25===_8;
-};
-this.isFulfilled=_23.isFulfilled=function(){
-return !!_25;
-};
-this.isCanceled=_23.isCanceled=function(){
-return _28;
-};
-this.progress=function(_2a,_2b){
-if(!_25){
-_b(_29,_6,_2a,null,_24);
-return _23;
-}else{
-if(_2b===true){
-throw new Error(_9);
-}else{
-return _23;
-}
-}
-};
-this.resolve=function(_2c,_2d){
-if(!_25){
-_b(_29,_25=_7,_26=_2c,null,_24);
-_29=null;
-return _23;
-}else{
-if(_2d===true){
-throw new Error(_9);
-}else{
-return _23;
-}
-}
-};
-var _2e=this.reject=function(_2f,_30){
-if(!_25){
-if(1&&Error.captureStackTrace){
-Error.captureStackTrace(_27={},_2e);
-}
-_b(_29,_25=_8,_26=_2f,_27,_24);
-_29=null;
-return _23;
-}else{
-if(_30===true){
-throw new Error(_9);
-}else{
-return _23;
-}
-}
-};
-this.then=_23.then=function(_31,_32,_33){
-var _34=[_33,_31,_32];
-_34.cancel=_23.cancel;
-_34.deferred=new _11(function(_35){
-return _34.cancel&&_34.cancel(_35);
-});
-if(_25&&!_29){
-_12(_34,_25,_26,_27);
-}else{
-_29.push(_34);
-}
-return _34.deferred.promise;
-};
-this.cancel=_23.cancel=function(_36,_37){
-if(!_25){
-if(_22){
-var _38=_22(_36);
-_36=typeof _38==="undefined"?_36:_38;
-}
-_28=true;
-if(!_25){
-if(typeof _36==="undefined"){
-_36=new _3();
-}
-_2e(_36);
-return _36;
-}else{
-if(_25===_8&&_26===_36){
-return _36;
-}
-}
-}else{
-if(_37===true){
-throw new Error(_9);
-}
-}
-};
-_a(_23);
-};
-_11.prototype.toString=function(){
-return "[object Deferred]";
-};
-if(_5){
-_5(_11);
-}
-return _11;
-});
diff --git a/lib/dojo/Deferred.js.uncompressed.js b/lib/dojo/Deferred.js.uncompressed.js
deleted file mode 100644
index f78dbd1..0000000
--- a/lib/dojo/Deferred.js.uncompressed.js
+++ /dev/null
@@ -1,320 +0,0 @@
-define("dojo/Deferred", [
- "./has",
- "./_base/lang",
- "./errors/CancelError",
- "./promise/Promise",
- "./promise/instrumentation"
-], function(has, lang, CancelError, Promise, instrumentation){
- "use strict";
-
- // module:
- // dojo/Deferred
-
- var PROGRESS = 0,
- RESOLVED = 1,
- REJECTED = 2;
- var FULFILLED_ERROR_MESSAGE = "This deferred has already been fulfilled.";
-
- var freezeObject = Object.freeze || function(){};
-
- var signalWaiting = function(waiting, type, result, rejection, deferred){
- if( 1 ){
- if(type === REJECTED && Deferred.instrumentRejected && waiting.length === 0){
- Deferred.instrumentRejected(result, false, rejection, deferred);
- }
- }
-
- for(var i = 0; i < waiting.length; i++){
- signalListener(waiting[i], type, result, rejection);
- }
- };
-
- var signalListener = function(listener, type, result, rejection){
- var func = listener[type];
- var deferred = listener.deferred;
- if(func){
- try{
- var newResult = func(result);
- if(type === PROGRESS){
- if(typeof newResult !== "undefined"){
- signalDeferred(deferred, type, newResult);
- }
- }else{
- if(newResult && typeof newResult.then === "function"){
- listener.cancel = newResult.cancel;
- newResult.then(
- // Only make resolvers if they're actually going to be used
- makeDeferredSignaler(deferred, RESOLVED),
- makeDeferredSignaler(deferred, REJECTED),
- makeDeferredSignaler(deferred, PROGRESS));
- return;
- }
- signalDeferred(deferred, RESOLVED, newResult);
- }
- }catch(error){
- signalDeferred(deferred, REJECTED, error);
- }
- }else{
- signalDeferred(deferred, type, result);
- }
-
- if( 1 ){
- if(type === REJECTED && Deferred.instrumentRejected){
- Deferred.instrumentRejected(result, !!func, rejection, deferred.promise);
- }
- }
- };
-
- var makeDeferredSignaler = function(deferred, type){
- return function(value){
- signalDeferred(deferred, type, value);
- };
- };
-
- var signalDeferred = function(deferred, type, result){
- if(!deferred.isCanceled()){
- switch(type){
- case PROGRESS:
- deferred.progress(result);
- break;
- case RESOLVED:
- deferred.resolve(result);
- break;
- case REJECTED:
- deferred.reject(result);
- break;
- }
- }
- };
-
- var Deferred = function(canceler){
- // summary:
- // Creates a new deferred. This API is preferred over
- // `dojo/_base/Deferred`.
- // description:
- // Creates a new deferred, as an abstraction over (primarily)
- // asynchronous operations. The deferred is the private interface
- // that should not be returned to calling code. That's what the
- // `promise` is for. See `dojo/promise/Promise`.
- // canceler: Function?
- // Will be invoked if the deferred is canceled. The canceler
- // receives the reason the deferred was canceled as its argument.
- // The deferred is rejected with its return value, or a new
- // `dojo/errors/CancelError` instance.
-
- // promise: dojo/promise/Promise
- // The public promise object that clients can add callbacks to.
- var promise = this.promise = new Promise();
-
- var deferred = this;
- var fulfilled, result, rejection;
- var canceled = false;
- var waiting = [];
-
- if( 1 && Error.captureStackTrace){
- Error.captureStackTrace(deferred, Deferred);
- Error.captureStackTrace(promise, Deferred);
- }
-
- this.isResolved = promise.isResolved = function(){
- // summary:
- // Checks whether the deferred has been resolved.
- // returns: Boolean
-
- return fulfilled === RESOLVED;
- };
-
- this.isRejected = promise.isRejected = function(){
- // summary:
- // Checks whether the deferred has been rejected.
- // returns: Boolean
-
- return fulfilled === REJECTED;
- };
-
- this.isFulfilled = promise.isFulfilled = function(){
- // summary:
- // Checks whether the deferred has been resolved or rejected.
- // returns: Boolean
-
- return !!fulfilled;
- };
-
- this.isCanceled = promise.isCanceled = function(){
- // summary:
- // Checks whether the deferred has been canceled.
- // returns: Boolean
-
- return canceled;
- };
-
- this.progress = function(update, strict){
- // summary:
- // Emit a progress update on the deferred.
- // description:
- // Emit a progress update on the deferred. Progress updates
- // can be used to communicate updates about the asynchronous
- // operation before it has finished.
- // update: any
- // The progress update. Passed to progbacks.
- // strict: Boolean?
- // If strict, will throw an error if the deferred has already
- // been fulfilled and consequently no progress can be emitted.
- // returns: dojo/promise/Promise
- // Returns the original promise for the deferred.
-
- if(!fulfilled){
- signalWaiting(waiting, PROGRESS, update, null, deferred);
- return promise;
- }else if(strict === true){
- throw new Error(FULFILLED_ERROR_MESSAGE);
- }else{
- return promise;
- }
- };
-
- this.resolve = function(value, strict){
- // summary:
- // Resolve the deferred.
- // description:
- // Resolve the deferred, putting it in a success state.
- // value: any
- // The result of the deferred. Passed to callbacks.
- // strict: Boolean?
- // If strict, will throw an error if the deferred has already
- // been fulfilled and consequently cannot be resolved.
- // returns: dojo/promise/Promise
- // Returns the original promise for the deferred.
-
- if(!fulfilled){
- // Set fulfilled, store value. After signaling waiting listeners unset
- // waiting.
- signalWaiting(waiting, fulfilled = RESOLVED, result = value, null, deferred);
- waiting = null;
- return promise;
- }else if(strict === true){
- throw new Error(FULFILLED_ERROR_MESSAGE);
- }else{
- return promise;
- }
- };
-
- var reject = this.reject = function(error, strict){
- // summary:
- // Reject the deferred.
- // description:
- // Reject the deferred, putting it in an error state.
- // error: any
- // The error result of the deferred. Passed to errbacks.
- // strict: Boolean?
- // If strict, will throw an error if the deferred has already
- // been fulfilled and consequently cannot be rejected.
- // returns: dojo/promise/Promise
- // Returns the original promise for the deferred.
-
- if(!fulfilled){
- if( 1 && Error.captureStackTrace){
- Error.captureStackTrace(rejection = {}, reject);
- }
- signalWaiting(waiting, fulfilled = REJECTED, result = error, rejection, deferred);
- waiting = null;
- return promise;
- }else if(strict === true){
- throw new Error(FULFILLED_ERROR_MESSAGE);
- }else{
- return promise;
- }
- };
-
- this.then = promise.then = function(callback, errback, progback){
- // summary:
- // Add new callbacks to the deferred.
- // description:
- // Add new callbacks to the deferred. Callbacks can be added
- // before or after the deferred is fulfilled.
- // callback: Function?
- // Callback to be invoked when the promise is resolved.
- // Receives the resolution value.
- // errback: Function?
- // Callback to be invoked when the promise is rejected.
- // Receives the rejection error.
- // progback: Function?
- // Callback to be invoked when the promise emits a progress
- // update. Receives the progress update.
- // returns: dojo/promise/Promise
- // Returns a new promise for the result of the callback(s).
- // This can be used for chaining many asynchronous operations.
-
- var listener = [progback, callback, errback];
- // Ensure we cancel the promise we're waiting for, or if callback/errback
- // have returned a promise, cancel that one.
- listener.cancel = promise.cancel;
- listener.deferred = new Deferred(function(reason){
- // Check whether cancel is really available, returned promises are not
- // required to expose `cancel`
- return listener.cancel && listener.cancel(reason);
- });
- if(fulfilled && !waiting){
- signalListener(listener, fulfilled, result, rejection);
- }else{
- waiting.push(listener);
- }
- return listener.deferred.promise;
- };
-
- this.cancel = promise.cancel = function(reason, strict){
- // summary:
- // Inform the deferred it may cancel its asynchronous operation.
- // description:
- // Inform the deferred it may cancel its asynchronous operation.
- // The deferred's (optional) canceler is invoked and the
- // deferred will be left in a rejected state. Can affect other
- // promises that originate with the same deferred.
- // reason: any
- // A message that may be sent to the deferred's canceler,
- // explaining why it's being canceled.
- // strict: Boolean?
- // If strict, will throw an error if the deferred has already
- // been fulfilled and consequently cannot be canceled.
- // returns: any
- // Returns the rejection reason if the deferred was canceled
- // normally.
-
- if(!fulfilled){
- // Cancel can be called even after the deferred is fulfilled
- if(canceler){
- var returnedReason = canceler(reason);
- reason = typeof returnedReason === "undefined" ? reason : returnedReason;
- }
- canceled = true;
- if(!fulfilled){
- // Allow canceler to provide its own reason, but fall back to a CancelError
- if(typeof reason === "undefined"){
- reason = new CancelError();
- }
- reject(reason);
- return reason;
- }else if(fulfilled === REJECTED && result === reason){
- return reason;
- }
- }else if(strict === true){
- throw new Error(FULFILLED_ERROR_MESSAGE);
- }
- };
-
- freezeObject(promise);
- };
-
- Deferred.prototype.toString = function(){
- // returns: String
- // Returns `[object Deferred]`.
-
- return "[object Deferred]";
- };
-
- if(instrumentation){
- instrumentation(Deferred);
- }
-
- return Deferred;
-});
diff --git a/lib/dojo/DeferredList.js b/lib/dojo/DeferredList.js
deleted file mode 100644
index bd06d5f..0000000
--- a/lib/dojo/DeferredList.js
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/DeferredList",["./_base/kernel","./_base/Deferred","./_base/array"],function(_1,_2,_3){
-_1.DeferredList=function(_4,_5,_6,_7,_8){
-var _9=[];
-_2.call(this);
-var _a=this;
-if(_4.length===0&&!_5){
-this.resolve([0,[]]);
-}
-var _b=0;
-_3.forEach(_4,function(_c,i){
-_c.then(function(_d){
-if(_5){
-_a.resolve([i,_d]);
-}else{
-_e(true,_d);
-}
-},function(_f){
-if(_6){
-_a.reject(_f);
-}else{
-_e(false,_f);
-}
-if(_7){
-return null;
-}
-throw _f;
-});
-function _e(_10,_11){
-_9[i]=[_10,_11];
-_b++;
-if(_b===_4.length){
-_a.resolve(_9);
-}
-};
-});
-};
-_1.DeferredList.prototype=new _2();
-_1.DeferredList.prototype.gatherResults=function(_12){
-var d=new _1.DeferredList(_12,false,true,false);
-d.addCallback(function(_13){
-var ret=[];
-_3.forEach(_13,function(_14){
-ret.push(_14[1]);
-});
-return ret;
-});
-return d;
-};
-return _1.DeferredList;
-});
diff --git a/lib/dojo/DeferredList.js.uncompressed.js b/lib/dojo/DeferredList.js.uncompressed.js
deleted file mode 100644
index 26c36a9..0000000
--- a/lib/dojo/DeferredList.js.uncompressed.js
+++ /dev/null
@@ -1,84 +0,0 @@
-define("dojo/DeferredList", ["./_base/kernel", "./_base/Deferred", "./_base/array"], function(dojo, Deferred, darray){
- // module:
- // dojo/DeferredList
-
-
-dojo.DeferredList = function(/*Array*/ list, /*Boolean?*/ fireOnOneCallback, /*Boolean?*/ fireOnOneErrback, /*Boolean?*/ consumeErrors, /*Function?*/ canceller){
- // summary:
- // Deprecated, use dojo/promise/all instead.
- // Provides event handling for a group of Deferred objects.
- // description:
- // DeferredList takes an array of existing deferreds and returns a new deferred of its own
- // this new deferred will typically have its callback fired when all of the deferreds in
- // the given list have fired their own deferreds. The parameters `fireOnOneCallback` and
- // fireOnOneErrback, will fire before all the deferreds as appropriate
- // list:
- // The list of deferreds to be synchronizied with this DeferredList
- // fireOnOneCallback:
- // Will cause the DeferredLists callback to be fired as soon as any
- // of the deferreds in its list have been fired instead of waiting until
- // the entire list has finished
- // fireonOneErrback:
- // Will cause the errback to fire upon any of the deferreds errback
- // canceller:
- // A deferred canceller function, see dojo.Deferred
- var resultList = [];
- Deferred.call(this);
- var self = this;
- if(list.length === 0 && !fireOnOneCallback){
- this.resolve([0, []]);
- }
- var finished = 0;
- darray.forEach(list, function(item, i){
- item.then(function(result){
- if(fireOnOneCallback){
- self.resolve([i, result]);
- }else{
- addResult(true, result);
- }
- },function(error){
- if(fireOnOneErrback){
- self.reject(error);
- }else{
- addResult(false, error);
- }
- if(consumeErrors){
- return null;
- }
- throw error;
- });
- function addResult(succeeded, result){
- resultList[i] = [succeeded, result];
- finished++;
- if(finished === list.length){
- self.resolve(resultList);
- }
-
- }
- });
-};
-dojo.DeferredList.prototype = new Deferred();
-
-dojo.DeferredList.prototype.gatherResults = function(deferredList){
- // summary:
- // Gathers the results of the deferreds for packaging
- // as the parameters to the Deferred Lists' callback
- // deferredList: dojo/DeferredList
- // The deferred list from which this function gathers results.
- // returns: dojo/DeferredList
- // The newly created deferred list which packs results as
- // parameters to its callback.
-
- var d = new dojo.DeferredList(deferredList, false, true, false);
- d.addCallback(function(results){
- var ret = [];
- darray.forEach(results, function(result){
- ret.push(result[1]);
- });
- return ret;
- });
- return d;
-};
-
-return dojo.DeferredList;
-});
diff --git a/lib/dojo/Evented.js b/lib/dojo/Evented.js
deleted file mode 100644
index 96704ef..0000000
--- a/lib/dojo/Evented.js
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/Evented",["./aspect","./on"],function(_1,on){
-"use strict";
-var _2=_1.after;
-function _3(){
-};
-_3.prototype={on:function(_4,_5){
-return on.parse(this,_4,_5,function(_6,_7){
-return _2(_6,"on"+_7,_5,true);
-});
-},emit:function(_8,_9){
-var _a=[this];
-_a.push.apply(_a,arguments);
-return on.emit.apply(on,_a);
-}};
-return _3;
-});
diff --git a/lib/dojo/Evented.js.uncompressed.js b/lib/dojo/Evented.js.uncompressed.js
deleted file mode 100644
index 515c2a1..0000000
--- a/lib/dojo/Evented.js.uncompressed.js
+++ /dev/null
@@ -1,36 +0,0 @@
-define("dojo/Evented", ["./aspect", "./on"], function(aspect, on){
- // module:
- // dojo/Evented
-
- "use strict";
- var after = aspect.after;
- function Evented(){
- // summary:
- // A class that can be used as a mixin or base class,
- // to add on() and emit() methods to a class
- // for listening for events and emitting events:
- // example:
- // | define(["dojo/Evented", "dojo/_base/declare", "dojo/Stateful"
- // | ], function(Evented, declare, Stateful){
- // | var EventedStateful = declare([Evented, Stateful], {...});
- // | var instance = new EventedStateful();
- // | instance.on("open", function(event){
- // | ... do something with event
- // | });
- // |
- // | instance.emit("open", {name:"some event", ...});
- }
- Evented.prototype = {
- on: function(type, listener){
- return on.parse(this, type, listener, function(target, type){
- return after(target, 'on' + type, listener, true);
- });
- },
- emit: function(type, event){
- var args = [this];
- args.push.apply(args, arguments);
- return on.emit.apply(on, args);
- }
- };
- return Evented;
-});
diff --git a/lib/dojo/LICENSE b/lib/dojo/LICENSE
deleted file mode 100644
index 2640cee..0000000
--- a/lib/dojo/LICENSE
+++ /dev/null
@@ -1,195 +0,0 @@
-Dojo is available under *either* the terms of the modified BSD license *or* the
-Academic Free License version 2.1. As a recipient of Dojo, you may choose which
-license to receive this code under (except as noted in per-module LICENSE
-files). Some modules may not be the copyright of the Dojo Foundation. These
-modules contain explicit declarations of copyright in both the LICENSE files in
-the directories in which they reside and in the code itself. No external
-contributions are allowed under licenses which are fundamentally incompatible
-with the AFL or BSD licenses that Dojo is distributed under.
-
-The text of the AFL and BSD licenses is reproduced below.
-
--------------------------------------------------------------------------------
-The "New" BSD License:
-**********************
-
-Copyright (c) 2005-2014, The Dojo Foundation
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
- * Neither the name of the Dojo Foundation nor the names of its contributors
- may be used to endorse or promote products derived from this software
- without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
--------------------------------------------------------------------------------
-The Academic Free License, v. 2.1:
-**********************************
-
-This Academic Free License (the "License") applies to any original work of
-authorship (the "Original Work") whose owner (the "Licensor") has placed the
-following notice immediately following the copyright notice for the Original
-Work:
-
-Licensed under the Academic Free License version 2.1
-
-1) Grant of Copyright License. Licensor hereby grants You a world-wide,
-royalty-free, non-exclusive, perpetual, sublicenseable license to do the
-following:
-
-a) to reproduce the Original Work in copies;
-
-b) to prepare derivative works ("Derivative Works") based upon the Original
-Work;
-
-c) to distribute copies of the Original Work and Derivative Works to the
-public;
-
-d) to perform the Original Work publicly; and
-
-e) to display the Original Work publicly.
-
-2) Grant of Patent License. Licensor hereby grants You a world-wide,
-royalty-free, non-exclusive, perpetual, sublicenseable license, under patent
-claims owned or controlled by the Licensor that are embodied in the Original
-Work as furnished by the Licensor, to make, use, sell and offer for sale the
-Original Work and Derivative Works.
-
-3) Grant of Source Code License. The term "Source Code" means the preferred
-form of the Original Work for making modifications to it and all available
-documentation describing how to modify the Original Work. Licensor hereby
-agrees to provide a machine-readable copy of the Source Code of the Original
-Work along with each copy of the Original Work that Licensor distributes.
-Licensor reserves the right to satisfy this obligation by placing a
-machine-readable copy of the Source Code in an information repository
-reasonably calculated to permit inexpensive and convenient access by You for as
-long as Licensor continues to distribute the Original Work, and by publishing
-the address of that information repository in a notice immediately following
-the copyright notice that applies to the Original Work.
-
-4) Exclusions From License Grant. Neither the names of Licensor, nor the names
-of any contributors to the Original Work, nor any of their trademarks or
-service marks, may be used to endorse or promote products derived from this
-Original Work without express prior written permission of the Licensor. Nothing
-in this License shall be deemed to grant any rights to trademarks, copyrights,
-patents, trade secrets or any other intellectual property of Licensor except as
-expressly stated herein. No patent license is granted to make, use, sell or
-offer to sell embodiments of any patent claims other than the licensed claims
-defined in Section 2. No right is granted to the trademarks of Licensor even if
-such marks are included in the Original Work. Nothing in this License shall be
-interpreted to prohibit Licensor from licensing under different terms from this
-License any Original Work that Licensor otherwise would have a right to
-license.
-
-5) This section intentionally omitted.
-
-6) Attribution Rights. You must retain, in the Source Code of any Derivative
-Works that You create, all copyright, patent or trademark notices from the
-Source Code of the Original Work, as well as any notices of licensing and any
-descriptive text identified therein as an "Attribution Notice." You must cause
-the Source Code for any Derivative Works that You create to carry a prominent
-Attribution Notice reasonably calculated to inform recipients that You have
-modified the Original Work.
-
-7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that
-the copyright in and to the Original Work and the patent rights granted herein
-by Licensor are owned by the Licensor or are sublicensed to You under the terms
-of this License with the permission of the contributor(s) of those copyrights
-and patent rights. Except as expressly stated in the immediately proceeding
-sentence, the Original Work is provided under this License on an "AS IS" BASIS
-and WITHOUT WARRANTY, either express or implied, including, without limitation,
-the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU.
-This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No
-license to Original Work is granted hereunder except under this disclaimer.
-
-8) Limitation of Liability. Under no circumstances and under no legal theory,
-whether in tort (including negligence), contract, or otherwise, shall the
-Licensor be liable to any person for any direct, indirect, special, incidental,
-or consequential damages of any character arising as a result of this License
-or the use of the Original Work including, without limitation, damages for loss
-of goodwill, work stoppage, computer failure or malfunction, or any and all
-other commercial damages or losses. This limitation of liability shall not
-apply to liability for death or personal injury resulting from Licensor's
-negligence to the extent applicable law prohibits such limitation. Some
-jurisdictions do not allow the exclusion or limitation of incidental or
-consequential damages, so this exclusion and limitation may not apply to You.
-
-9) Acceptance and Termination. If You distribute copies of the Original Work or
-a Derivative Work, You must make a reasonable effort under the circumstances to
-obtain the express assent of recipients to the terms of this License. Nothing
-else but this License (or another written agreement between Licensor and You)
-grants You permission to create Derivative Works based upon the Original Work
-or to exercise any of the rights granted in Section 1 herein, and any attempt
-to do so except under the terms of this License (or another written agreement
-between Licensor and You) is expressly prohibited by U.S. copyright law, the
-equivalent laws of other countries, and by international treaty. Therefore, by
-exercising any of the rights granted to You in Section 1 herein, You indicate
-Your acceptance of this License and all of its terms and conditions.
-
-10) Termination for Patent Action. This License shall terminate automatically
-and You may no longer exercise any of the rights granted to You by this License
-as of the date You commence an action, including a cross-claim or counterclaim,
-against Licensor or any licensee alleging that the Original Work infringes a
-patent. This termination provision shall not apply for an action alleging
-patent infringement by combinations of the Original Work with other software or
-hardware.
-
-11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this
-License may be brought only in the courts of a jurisdiction wherein the
-Licensor resides or in which Licensor conducts its primary business, and under
-the laws of that jurisdiction excluding its conflict-of-law provisions. The
-application of the United Nations Convention on Contracts for the International
-Sale of Goods is expressly excluded. Any use of the Original Work outside the
-scope of this License or after its termination shall be subject to the
-requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et
-seq., the equivalent laws of other countries, and international treaty. This
-section shall survive the termination of this License.
-
-12) Attorneys Fees. In any action to enforce the terms of this License or
-seeking damages relating thereto, the prevailing party shall be entitled to
-recover its costs and expenses, including, without limitation, reasonable
-attorneys' fees and costs incurred in connection with such action, including
-any appeal of such action. This section shall survive the termination of this
-License.
-
-13) Miscellaneous. This License represents the complete agreement concerning
-the subject matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent necessary to
-make it enforceable.
-
-14) Definition of "You" in This License. "You" throughout this License, whether
-in upper or lower case, means an individual or a legal entity exercising rights
-under, and complying with all of the terms of, this License. For legal
-entities, "You" includes any entity that controls, is controlled by, or is
-under common control with you. For purposes of this definition, "control" means
-(i) the power, direct or indirect, to cause the direction or management of such
-entity, whether by contract or otherwise, or (ii) ownership of fifty percent
-(50%) or more of the outstanding shares, or (iii) beneficial ownership of such
-entity.
-
-15) Right to Use. You may use the Original Work in all ways not otherwise
-restricted or conditioned by this License or by law, and Licensor promises not
-to interfere with or be responsible for such uses by You.
-
-This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved.
-Permission is hereby granted to copy and distribute this license without
-modification. This license may not be modified without the express written
-permission of its copyright owner.
diff --git a/lib/dojo/NodeList-data.js b/lib/dojo/NodeList-data.js
deleted file mode 100644
index 000bb9a..0000000
--- a/lib/dojo/NodeList-data.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/NodeList-data",["./_base/kernel","./query","./_base/lang","./_base/array","./dom-attr"],function(_1,_2,_3,_4,_5){
-var _6=_2.NodeList;
-var _7={},x=0,_8="data-dojo-dataid",_9=function(_a){
-var _b=_5.get(_a,_8);
-if(!_b){
-_b="pid"+(x++);
-_5.set(_a,_8,_b);
-}
-return _b;
-};
-var _c=_1._nodeData=function(_d,_e,_f){
-var pid=_9(_d),r;
-if(!_7[pid]){
-_7[pid]={};
-}
-if(arguments.length==1){
-return _7[pid];
-}
-if(typeof _e=="string"){
-if(arguments.length>2){
-_7[pid][_e]=_f;
-}else{
-r=_7[pid][_e];
-}
-}else{
-r=_3.mixin(_7[pid],_e);
-}
-return r;
-};
-var _10=_1._removeNodeData=function(_11,key){
-var pid=_9(_11);
-if(_7[pid]){
-if(key){
-delete _7[pid][key];
-}else{
-delete _7[pid];
-}
-}
-};
-_6._gcNodeData=_1._gcNodeData=function(){
-var _12=_2("["+_8+"]").map(_9);
-for(var i in _7){
-if(_4.indexOf(_12,i)<0){
-delete _7[i];
-}
-}
-};
-_3.extend(_6,{data:_6._adaptWithCondition(_c,function(a){
-return a.length===0||a.length==1&&(typeof a[0]=="string");
-}),removeData:_6._adaptAsForEach(_10)});
-return _6;
-});
diff --git a/lib/dojo/NodeList-data.js.uncompressed.js b/lib/dojo/NodeList-data.js.uncompressed.js
deleted file mode 100644
index ab5981e..0000000
--- a/lib/dojo/NodeList-data.js.uncompressed.js
+++ /dev/null
@@ -1,198 +0,0 @@
-define("dojo/NodeList-data", [
- "./_base/kernel", "./query", "./_base/lang", "./_base/array", "./dom-attr"
-], function(dojo, query, lang, array, attr){
-
- // module:
- // dojo/NodeList-data
-
- /*=====
- return function(){
- // summary:
- // Adds data() and removeData() methods to NodeList, and returns NodeList constructor.
- };
- =====*/
-
- var NodeList = query.NodeList;
-
- var dataCache = {}, x = 0, dataattr = "data-dojo-dataid",
- dopid = function(node){
- // summary:
- // Return a uniqueish ID for the passed node reference
- var pid = attr.get(node, dataattr);
- if(!pid){
- pid = "pid" + (x++);
- attr.set(node, dataattr, pid);
- }
- return pid;
- }
- ;
-
-
- var dodata = dojo._nodeData = function(node, key, value){
- // summary:
- // Private helper for dojo/NodeList.data for single node data access. Refer to NodeList.data
- // documentation for more information.
- //
- // node: String|DomNode
- // The node to associate data with
- //
- // key: Object|String?
- // If an object, act as a setter and iterate over said object setting data items as defined.
- // If a string, and `value` present, set the data for defined `key` to `value`
- // If a string, and `value` absent, act as a getter, returning the data associated with said `key`
- //
- // value: Anything?
- // The value to set for said `key`, provided `key` is a string (and not an object)
- //
- var pid = dopid(node), r;
- if(!dataCache[pid]){ dataCache[pid] = {}; }
-
- // API discrepency: calling with only a node returns the whole object. $.data throws
- if(arguments.length == 1){ return dataCache[pid]; }
- if(typeof key == "string"){
- // either getter or setter, based on `value` presence
- if(arguments.length > 2){
- dataCache[pid][key] = value;
- }else{
- r = dataCache[pid][key];
- }
- }else{
- // must be a setter, mix `value` into data hash
- // API discrepency: using object as setter works here
- r = lang.mixin(dataCache[pid], key);
- }
-
- return r; // Object|Anything|Nothing
- };
-
- var removeData = dojo._removeNodeData = function(node, key){
- // summary:
- // Remove some data from this node
- // node: String|DomNode
- // The node reference to remove data from
- // key: String?
- // If omitted, remove all data in this dataset.
- // If passed, remove only the passed `key` in the associated dataset
- var pid = dopid(node);
- if(dataCache[pid]){
- if(key){
- delete dataCache[pid][key];
- }else{
- delete dataCache[pid];
- }
- }
- };
-
- NodeList._gcNodeData = dojo._gcNodeData = function(){
- // summary:
- // super expensive: GC all data in the data for nodes that no longer exist in the dom.
- // description:
- // super expensive: GC all data in the data for nodes that no longer exist in the dom.
- // MUCH safer to do this yourself, manually, on a per-node basis (via `NodeList.removeData()`)
- // provided as a stop-gap for exceptionally large/complex applications with constantly changing
- // content regions (eg: a dijit/layout/ContentPane with replacing data)
- // There is NO automatic GC going on. If you dojo.destroy() a node, you should _removeNodeData
- // prior to destruction.
- var livePids = query("[" + dataattr + "]").map(dopid);
- for(var i in dataCache){
- if(array.indexOf(livePids, i) < 0){ delete dataCache[i]; }
- }
- };
-
- // make nodeData and removeNodeData public on dojo/NodeList:
- lang.extend(NodeList, {
- data: NodeList._adaptWithCondition(dodata, function(a){
- return a.length === 0 || a.length == 1 && (typeof a[0] == "string");
- }),
- removeData: NodeList._adaptAsForEach(removeData)
- });
-
- /*=====
- lang.extend(NodeList, {
- data: function(key, value){
- // summary:
- // stash or get some arbitrary data on/from these nodes.
- //
- // description:
- // Stash or get some arbitrary data on/from these nodes. This private _data function is
- // exposed publicly on `dojo/NodeList`, eg: as the result of a `dojo/query` call.
- // DIFFERS from jQuery.data in that when used as a getter, the entire list is ALWAYS
- // returned. EVEN WHEN THE LIST IS length == 1.
- //
- // A single-node version of this function is provided as `dojo._nodeData`, which follows
- // the same signature, though expects a String ID or DomNode reference in the first
- // position, before key/value arguments.
- //
- // node: String|DomNode
- // The node to associate data with
- //
- // key: Object|String?
- // If an object, act as a setter and iterate over said object setting data items as defined.
- // If a string, and `value` present, set the data for defined `key` to `value`
- // If a string, and `value` absent, act as a getter, returning the data associated with said `key`
- //
- // value: Anything?
- // The value to set for said `key`, provided `key` is a string (and not an object)
- //
- // example:
- // Set a key `bar` to some data, then retrieve it.
- // | require(["dojo/query", "dojo/NodeList-data"], function(query){
- // | query(".foo").data("bar", "touched");
- // | var touched = query(".foo").data("bar");
- // | if(touched[0] == "touched"){ alert('win'); }
- // | });
- //
- // example:
- // Get all the data items for a given node.
- // | require(["dojo/query", "dojo/NodeList-data"], function(query){
- // | var list = query(".foo").data();
- // | var first = list[0];
- // | });
- //
- // example:
- // Set the data to a complex hash. Overwrites existing keys with new value
- // | require(["dojo/query", "dojo/NodeList-data"], function(query){
- // | query(".foo").data({ bar:"baz", foo:"bar" });
- // Then get some random key:
- // | query(".foo").data("foo"); // returns [`bar`]
- // | });
- //
- // returns: Object|Anything|Nothing
- // When used as a setter via `dojo/NodeList`, a NodeList instance is returned
- // for further chaining. When used as a getter via `dojo/NodeList` an ARRAY
- // of items is returned. The items in the array correspond to the elements
- // in the original list. This is true even when the list length is 1, eg:
- // when looking up a node by ID (#foo)
- },
-
- removeData: function(key){
- // summary:
- // Remove the data associated with these nodes.
- // key: String?
- // If omitted, clean all data for this node.
- // If passed, remove the data item found at `key`
- }
- });
- =====*/
-
-// TODO: this is the basic implementation of adaptWithConditionAndWhenMappedConsiderLength, for lack of a better API name
-// it conflicts with the the `dojo/NodeList` way: always always return an arrayLike thinger. Consider for 2.0:
-//
-// NodeList.prototype.data = function(key, value){
-// var a = arguments, r;
-// if(a.length === 0 || a.length == 1 && (typeof a[0] == "string")){
-// r = this.map(function(node){
-// return d._data(node, key);
-// });
-// if(r.length == 1){ r = r[0]; } // the offending line, and the diff on adaptWithCondition
-// }else{
-// r = this.forEach(function(node){
-// d._data(node, key, value);
-// });
-// }
-// return r; // NodeList|Array|SingleItem
-// };
-
- return NodeList;
-
-});
diff --git a/lib/dojo/NodeList-dom.js b/lib/dojo/NodeList-dom.js
deleted file mode 100644
index dc1afd0..0000000
--- a/lib/dojo/NodeList-dom.js
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/NodeList-dom",["./_base/kernel","./query","./_base/array","./_base/lang","./dom-class","./dom-construct","./dom-geometry","./dom-attr","./dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9){
-var _a=function(a){
-return a.length==1&&(typeof a[0]=="string");
-};
-var _b=function(_c){
-var p=_c.parentNode;
-if(p){
-p.removeChild(_c);
-}
-};
-var _d=_2.NodeList,_e=_d._adaptWithCondition,_f=_d._adaptAsForEach,aam=_d._adaptAsMap;
-function _10(_11){
-return function(_12,_13,_14){
-if(arguments.length==2){
-return _11[typeof _13=="string"?"get":"set"](_12,_13);
-}
-return _11.set(_12,_13,_14);
-};
-};
-_4.extend(_d,{_normalize:function(_15,_16){
-var _17=_15.parse===true;
-if(typeof _15.template=="string"){
-var _18=_15.templateFunc||(_1.string&&_1.string.substitute);
-_15=_18?_18(_15.template,_15):_15;
-}
-var _19=(typeof _15);
-if(_19=="string"||_19=="number"){
-_15=_6.toDom(_15,(_16&&_16.ownerDocument));
-if(_15.nodeType==11){
-_15=_4._toArray(_15.childNodes);
-}else{
-_15=[_15];
-}
-}else{
-if(!_4.isArrayLike(_15)){
-_15=[_15];
-}else{
-if(!_4.isArray(_15)){
-_15=_4._toArray(_15);
-}
-}
-}
-if(_17){
-_15._runParse=true;
-}
-return _15;
-},_cloneNode:function(_1a){
-return _1a.cloneNode(true);
-},_place:function(ary,_1b,_1c,_1d){
-if(_1b.nodeType!=1&&_1c=="only"){
-return;
-}
-var _1e=_1b,_1f;
-var _20=ary.length;
-for(var i=_20-1;i>=0;i--){
-var _21=(_1d?this._cloneNode(ary[i]):ary[i]);
-if(ary._runParse&&_1.parser&&_1.parser.parse){
-if(!_1f){
-_1f=_1e.ownerDocument.createElement("div");
-}
-_1f.appendChild(_21);
-_1.parser.parse(_1f);
-_21=_1f.firstChild;
-while(_1f.firstChild){
-_1f.removeChild(_1f.firstChild);
-}
-}
-if(i==_20-1){
-_6.place(_21,_1e,_1c);
-}else{
-_1e.parentNode.insertBefore(_21,_1e);
-}
-_1e=_21;
-}
-},position:aam(_7.position),attr:_e(_10(_8),_a),style:_e(_10(_9),_a),addClass:_f(_5.add),removeClass:_f(_5.remove),toggleClass:_f(_5.toggle),replaceClass:_f(_5.replace),empty:_f(_6.empty),removeAttr:_f(_8.remove),marginBox:aam(_7.getMarginBox),place:function(_22,_23){
-var _24=_2(_22)[0];
-return this.forEach(function(_25){
-_6.place(_25,_24,_23);
-});
-},orphan:function(_26){
-return (_26?_2._filterResult(this,_26):this).forEach(_b);
-},adopt:function(_27,_28){
-return _2(_27).place(this[0],_28)._stash(this);
-},query:function(_29){
-if(!_29){
-return this;
-}
-var ret=new _d;
-this.map(function(_2a){
-_2(_29,_2a).forEach(function(_2b){
-if(_2b!==undefined){
-ret.push(_2b);
-}
-});
-});
-return ret._stash(this);
-},filter:function(_2c){
-var a=arguments,_2d=this,_2e=0;
-if(typeof _2c=="string"){
-_2d=_2._filterResult(this,a[0]);
-if(a.length==1){
-return _2d._stash(this);
-}
-_2e=1;
-}
-return this._wrap(_3.filter(_2d,a[_2e],a[_2e+1]),this);
-},addContent:function(_2f,_30){
-_2f=this._normalize(_2f,this[0]);
-for(var i=0,_31;(_31=this[i]);i++){
-if(_2f.length){
-this._place(_2f,_31,_30,i>0);
-}else{
-_6.empty(_31);
-}
-}
-return this;
-}});
-return _d;
-});
diff --git a/lib/dojo/NodeList-dom.js.uncompressed.js b/lib/dojo/NodeList-dom.js.uncompressed.js
deleted file mode 100644
index 20d24ef..0000000
--- a/lib/dojo/NodeList-dom.js.uncompressed.js
+++ /dev/null
@@ -1,543 +0,0 @@
-define("dojo/NodeList-dom", ["./_base/kernel", "./query", "./_base/array", "./_base/lang", "./dom-class", "./dom-construct", "./dom-geometry", "./dom-attr", "./dom-style"], function(dojo, query, array, lang, domCls, domCtr, domGeom, domAttr, domStyle){
-
- // module:
- // dojo/NodeList-dom.js
-
- /*=====
- return function(){
- // summary:
- // Adds DOM related methods to NodeList, and returns NodeList constructor.
- };
- =====*/
-
- var magicGuard = function(a){
- // summary:
- // the guard function for dojo/dom-attr() and dojo/dom-style()
- return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
- };
-
- var orphan = function(node){
- // summary:
- // function to orphan nodes
- var p = node.parentNode;
- if(p){
- p.removeChild(node);
- }
- };
- // FIXME: should we move orphan() to dojo/_base/html?
-
- var NodeList = query.NodeList,
- awc = NodeList._adaptWithCondition,
- aafe = NodeList._adaptAsForEach,
- aam = NodeList._adaptAsMap;
-
- function getSet(module){
- return function(node, name, value){
- if(arguments.length == 2){
- return module[typeof name == "string" ? "get" : "set"](node, name);
- }
- // setter
- return module.set(node, name, value);
- };
- }
-
- lang.extend(NodeList, {
- _normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
- // summary:
- // normalizes data to an array of items to insert.
- // description:
- // If content is an object, it can have special properties "template" and
- // "parse". If "template" is defined, then the template value is run through
- // dojo/string.substitute (if dojo/string.substitute() has been required elsewhere),
- // or if templateFunc is a function on the content, that function will be used to
- // transform the template into a final string to be used for for passing to dojo/dom-construct.toDom().
- // If content.parse is true, then it is remembered for later, for when the content
- // nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
- // (if dojo/parser has been required elsewhere).
-
- //Wanted to just use a DocumentFragment, but for the array/NodeList
- //case that meant using cloneNode, but we may not want that.
- //Cloning should only happen if the node operations span
- //multiple refNodes. Also, need a real array, not a NodeList from the
- //DOM since the node movements could change those NodeLists.
-
- var parse = content.parse === true;
-
- //Do we have an object that needs to be run through a template?
- if(typeof content.template == "string"){
- var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
- content = templateFunc ? templateFunc(content.template, content) : content;
- }
-
- var type = (typeof content);
- if(type == "string" || type == "number"){
- content = domCtr.toDom(content, (refNode && refNode.ownerDocument));
- if(content.nodeType == 11){
- //DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
- content = lang._toArray(content.childNodes);
- }else{
- content = [content];
- }
- }else if(!lang.isArrayLike(content)){
- content = [content];
- }else if(!lang.isArray(content)){
- //To get to this point, content is array-like, but
- //not an array, which likely means a DOM NodeList. Convert it now.
- content = lang._toArray(content);
- }
-
- //Pass around the parse info
- if(parse){
- content._runParse = true;
- }
- return content; //Array
- },
-
- _cloneNode: function(/*DOMNode*/ node){
- // summary:
- // private utility to clone a node. Not very interesting in the vanilla
- // dojo/NodeList case, but delegates could do interesting things like
- // clone event handlers if that is derivable from the node.
- return node.cloneNode(true);
- },
-
- _place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
- // summary:
- // private utility to handle placing an array of nodes relative to another node.
- // description:
- // Allows for cloning the nodes in the array, and for
- // optionally parsing widgets, if ary._runParse is true.
-
- //Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
- if(refNode.nodeType != 1 && position == "only"){
- return;
- }
- var rNode = refNode, tempNode;
-
- //Always cycle backwards in case the array is really a
- //DOM NodeList and the DOM operations take it out of the live collection.
- var length = ary.length;
- for(var i = length - 1; i >= 0; i--){
- var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
-
- //If need widget parsing, use a temp node, instead of waiting after inserting into
- //real DOM because we need to start widget parsing at one node up from current node,
- //which could cause some already parsed widgets to be parsed again.
- if(ary._runParse && dojo.parser && dojo.parser.parse){
- if(!tempNode){
- tempNode = rNode.ownerDocument.createElement("div");
- }
- tempNode.appendChild(node);
- dojo.parser.parse(tempNode);
- node = tempNode.firstChild;
- while(tempNode.firstChild){
- tempNode.removeChild(tempNode.firstChild);
- }
- }
-
- if(i == length - 1){
- domCtr.place(node, rNode, position);
- }else{
- rNode.parentNode.insertBefore(node, rNode);
- }
- rNode = node;
- }
- },
-
-
- position: aam(domGeom.position),
- /*=====
- position: function(){
- // summary:
- // Returns border-box objects (x/y/w/h) of all elements in a node list
- // as an Array (*not* a NodeList). Acts like `dojo/dom-geometry-position`, though
- // assumes the node passed is each node in this list.
-
- return dojo.map(this, dojo.position); // Array
- },
- =====*/
-
- attr: awc(getSet(domAttr), magicGuard),
- /*=====
- attr: function(property, value){
- // summary:
- // gets or sets the DOM attribute for every element in the
- // NodeList. See also `dojo/dom-attr`
- // property: String
- // the attribute to get/set
- // value: String?
- // optional. The value to set the property to
- // returns:
- // if no value is passed, the result is an array of attribute values
- // If a value is passed, the return is this NodeList
- // example:
- // Make all nodes with a particular class focusable:
- // | require(["dojo/query", "dojo/NodeList-dom"], function(query){
- // | query(".focusable").attr("tabIndex", -1);
- // | });
- // example:
- // Disable a group of buttons:
- // | require(["dojo/query", "dojo/NodeList-dom"], function(query){
- // | query("button.group").attr("disabled", true);
- // | });
- // example:
- // innerHTML can be assigned or retrieved as well:
- // | // get the innerHTML (as an array) for each list item
- // | require(["dojo/query", "dojo/NodeList-dom"], function(query){
- // | var ih = query("li.replaceable").attr("innerHTML");
- // | });
- return; // dojo/NodeList|Array
- },
- =====*/
-
- style: awc(getSet(domStyle), magicGuard),
- /*=====
- style: function(property, value){
- // summary:
- // gets or sets the CSS property for every element in the NodeList
- // property: String
- // the CSS property to get/set, in JavaScript notation
- // ("lineHieght" instead of "line-height")
- // value: String?
- // optional. The value to set the property to
- // returns:
- // if no value is passed, the result is an array of strings.
- // If a value is passed, the return is this NodeList
- return; // dojo/NodeList
- return; // Array
- },
- =====*/
-
- addClass: aafe(domCls.add),
- /*=====
- addClass: function(className){
- // summary:
- // adds the specified class to every node in the list
- // className: String|Array
- // A String class name to add, or several space-separated class names,
- // or an array of class names.
- return; // dojo/NodeList
- },
- =====*/
-
- removeClass: aafe(domCls.remove),
- /*=====
- removeClass: function(className){
- // summary:
- // removes the specified class from every node in the list
- // className: String|Array?
- // An optional String class name to remove, or several space-separated
- // class names, or an array of class names. If omitted, all class names
- // will be deleted.
- // returns:
- // this list
- return; // dojo/NodeList
- },
- =====*/
-
- toggleClass: aafe(domCls.toggle),
- /*=====
- toggleClass: function(className, condition){
- // summary:
- // Adds a class to node if not present, or removes if present.
- // Pass a boolean condition if you want to explicitly add or remove.
- // condition: Boolean?
- // If passed, true means to add the class, false means to remove.
- // className: String
- // the CSS class to add
- return; // dojo/NodeList
- },
- =====*/
-
- replaceClass: aafe(domCls.replace),
- /*=====
- replaceClass: function(addClassStr, removeClassStr){
- // summary:
- // Replaces one or more classes on a node if not present.
- // Operates more quickly than calling `removeClass()` and `addClass()`
- // addClassStr: String|Array
- // A String class name to add, or several space-separated class names,
- // or an array of class names.
- // removeClassStr: String|Array?
- // A String class name to remove, or several space-separated class names,
- // or an array of class names.
- return; // dojo/NodeList
- },
- =====*/
-
- empty: aafe(domCtr.empty),
- /*=====
- empty: function(){
- // summary:
- // clears all content from each node in the list. Effectively
- // equivalent to removing all child nodes from every item in
- // the list.
- return this.forEach("item.innerHTML='';"); // dojo/NodeList
- // FIXME: should we be checking for and/or disposing of widgets below these nodes?
- },
- =====*/
-
- removeAttr: aafe(domAttr.remove),
- /*=====
- removeAttr: function(name){
- // summary:
- // Removes an attribute from each node in the list.
- // name: String
- // the name of the attribute to remove
- return; // dojo/NodeList
- },
- =====*/
-
- marginBox: aam(domGeom.getMarginBox),
- /*=====
- marginBox: function(){
- // summary:
- // Returns margin-box size of nodes
- return; // dojo/NodeList
- },
- =====*/
-
- // FIXME: connectPublisher()? connectRunOnce()?
-
- /*
- destroy: function(){
- // summary:
- // destroys every item in the list.
- this.forEach(d.destroy);
- // FIXME: should we be checking for and/or disposing of widgets below these nodes?
- },
- */
-
- place: function(/*String||Node*/ queryOrNode, /*String*/ position){
- // summary:
- // places elements of this node list relative to the first element matched
- // by queryOrNode. Returns the original NodeList. See: `dojo/dom-construct.place`
- // queryOrNode:
- // may be a string representing any valid CSS3 selector or a DOM node.
- // In the selector case, only the first matching element will be used
- // for relative positioning.
- // position:
- // can be one of:
- //
- // - "last" (default)
- // - "first"
- // - "before"
- // - "after"
- // - "only"
- // - "replace"
- //
- // or an offset in the childNodes property
- var item = query(queryOrNode)[0];
- return this.forEach(function(node){ domCtr.place(node, item, position); }); // dojo/NodeList
- },
-
- orphan: function(/*String?*/ filter){
- // summary:
- // removes elements in this list that match the filter
- // from their parents and returns them as a new NodeList.
- // filter:
- // CSS selector like ".foo" or "div > span"
- // returns:
- // NodeList containing the orphaned elements
- return (filter ? query._filterResult(this, filter) : this).forEach(orphan); // dojo/NodeList
- },
-
- adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
- // summary:
- // places any/all elements in queryOrListOrNode at a
- // position relative to the first element in this list.
- // Returns a dojo/NodeList of the adopted elements.
- // queryOrListOrNode:
- // a DOM node or a query string or a query result.
- // Represents the nodes to be adopted relative to the
- // first element of this NodeList.
- // position:
- // can be one of:
- //
- // - "last" (default)
- // - "first"
- // - "before"
- // - "after"
- // - "only"
- // - "replace"
- //
- // or an offset in the childNodes property
- return query(queryOrListOrNode).place(this[0], position)._stash(this); // dojo/NodeList
- },
-
- // FIXME: do we need this?
- query: function(/*String*/ queryStr){
- // summary:
- // Returns a new list whose members match the passed query,
- // assuming elements of the current NodeList as the root for
- // each search.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
- // | bacon is tasty, dontcha think?
- // |
- // |
- // |
- // |
great comedians may not be funny in person
- // |
- // If we are presented with the following definition for a NodeList:
- // | require(["dojo/dom", "dojo/query", "dojo/NodeList-dom"
- // | ], function(dom, query){
- // | var l = new NodeList(dom.byId("foo"), dom.byId("bar"));
- // it's possible to find all span elements under paragraphs
- // contained by these elements with this sub-query:
- // | var spans = l.query("p span");
- // | });
-
- // FIXME: probably slow
- if(!queryStr){ return this; }
- var ret = new NodeList;
- this.map(function(node){
- // FIXME: why would we ever get undefined here?
- query(queryStr, node).forEach(function(subNode){
- if(subNode !== undefined){
- ret.push(subNode);
- }
- });
- });
- return ret._stash(this); // dojo/NodeList
- },
-
- filter: function(/*String|Function*/ filter){
- // summary:
- // "masks" the built-in javascript filter() method (supported
- // in Dojo via `dojo.filter`) to support passing a simple
- // string filter in addition to supporting filtering function
- // objects.
- // filter:
- // If a string, a CSS rule like ".thinger" or "div > span".
- // example:
- // "regular" JS filter syntax as exposed in dojo.filter:
- // | require(["dojo/query", "dojo/NodeList-dom"
- // | ], function(query){
- // | query("*").filter(function(item){
- // | // highlight every paragraph
- // | return (item.nodeName == "p");
- // | }).style("backgroundColor", "yellow");
- // | });
- // example:
- // the same filtering using a CSS selector
- // | require(["dojo/query", "dojo/NodeList-dom"
- // | ], function(query){
- // | query("*").filter("p").styles("backgroundColor", "yellow");
- // | });
- var a = arguments, items = this, start = 0;
- if(typeof filter == "string"){ // inline'd type check
- items = query._filterResult(this, a[0]);
- if(a.length == 1){
- // if we only got a string query, pass back the filtered results
- return items._stash(this); // dojo/NodeList
- }
- // if we got a callback, run it over the filtered items
- start = 1;
- }
- return this._wrap(array.filter(items, a[start], a[start + 1]), this); // dojo/NodeList
- },
-
- /*
- // FIXME: should this be "copyTo" and include parenting info?
- clone: function(){
- // summary:
- // creates node clones of each element of this list
- // and returns a new list containing the clones
- },
- */
-
- addContent: function(/*String||DomNode||Object||dojo/NodeList*/ content, /*String||Integer?*/ position){
- // summary:
- // add a node, NodeList or some HTML as a string to every item in the
- // list. Returns the original list.
- // description:
- // a copy of the HTML content is added to each item in the
- // list, with an optional position argument. If no position
- // argument is provided, the content is appended to the end of
- // each item.
- // content:
- // DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
- // NodeList, the content will be cloned if the current NodeList has more than one
- // element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
- // it should be an object with at "template" String property that has the HTML string
- // to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
- // will be used on the "template" to generate the final HTML string. Other allowed
- // properties on the object are: "parse" if the HTML
- // string should be parsed for widgets (dojo.require("dojo.parser") to get that
- // option to work), and "templateFunc" if a template function besides dojo.string.substitute
- // should be used to transform the "template".
- // position:
- // can be one of:
- //
- // - "last"||"end" (default)
- // - "first||"start"
- // - "before"
- // - "after"
- // - "replace" (replaces nodes in this NodeList with new content)
- // - "only" (removes other children of the nodes so new content is the only child)
- //
- // or an offset in the childNodes property
- // example:
- // appends content to the end if the position is omitted
- // | require(["dojo/query", "dojo/NodeList-dom"
- // | ], function(query){
- // | query("h3 > p").addContent("hey there!");
- // | });
- // example:
- // add something to the front of each element that has a
- // "thinger" property:
- // | require(["dojo/query", "dojo/NodeList-dom"
- // | ], function(query){
- // | query("[thinger]").addContent("...", "first");
- // | });
- // example:
- // adds a header before each element of the list
- // | require(["dojo/query", "dojo/NodeList-dom"
- // | ], function(query){
- // | query(".note").addContent("
NOTE:
", "before");
- // | });
- // example:
- // add a clone of a DOM node to the end of every element in
- // the list, removing it from its existing parent.
- // | require(["dojo/dom", "dojo/query", "dojo/NodeList-dom"
- // | ], function(dom, query){
- // | query(".note").addContent(dom.byId("foo"));
- // | });
- // example:
- // Append nodes from a templatized string.
- // | require(["dojo/string", "dojo/query", "dojo/NodeList-dom"
- // | ], function(string, query){
- // | query(".note").addContent({
- // | template: '${id}: ${name}',
- // | id: "user332",
- // | name: "Mr. Anderson"
- // | });
- // | });
- // example:
- // Append nodes from a templatized string that also has widgets parsed.
- // | require(["dojo/string", "dojo/parser", "dojo/query", "dojo/NodeList-dom"
- // | ], function(string, parser, query){
- // | var notes = query(".note").addContent({
- // | template: '',
- // | parse: true,
- // | text: "Send"
- // | });
- // | });
- content = this._normalize(content, this[0]);
- for(var i = 0, node; (node = this[i]); i++){
- if(content.length){
- this._place(content, node, position, i > 0);
- }else{
- // if it is an empty array, we empty the target node
- domCtr.empty(node);
- }
- }
- return this; // dojo/NodeList
- }
- });
-
- return NodeList;
-});
diff --git a/lib/dojo/NodeList-fx.js b/lib/dojo/NodeList-fx.js
deleted file mode 100644
index e062c72..0000000
--- a/lib/dojo/NodeList-fx.js
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/NodeList-fx",["./query","./_base/lang","./aspect","./_base/fx","./fx"],function(_1,_2,_3,_4,_5){
-var _6=_1.NodeList;
-_2.extend(_6,{_anim:function(_7,_8,_9){
-_9=_9||{};
-var a=_5.combine(this.map(function(_a){
-var _b={node:_a};
-_2.mixin(_b,_9);
-return _7[_8](_b);
-}));
-return _9.auto?a.play()&&this:a;
-},wipeIn:function(_c){
-return this._anim(_5,"wipeIn",_c);
-},wipeOut:function(_d){
-return this._anim(_5,"wipeOut",_d);
-},slideTo:function(_e){
-return this._anim(_5,"slideTo",_e);
-},fadeIn:function(_f){
-return this._anim(_4,"fadeIn",_f);
-},fadeOut:function(_10){
-return this._anim(_4,"fadeOut",_10);
-},animateProperty:function(_11){
-return this._anim(_4,"animateProperty",_11);
-},anim:function(_12,_13,_14,_15,_16){
-var _17=_5.combine(this.map(function(_18){
-return _4.animateProperty({node:_18,properties:_12,duration:_13||350,easing:_14});
-}));
-if(_15){
-_3.after(_17,"onEnd",_15,true);
-}
-return _17.play(_16||0);
-}});
-return _6;
-});
diff --git a/lib/dojo/NodeList-fx.js.uncompressed.js b/lib/dojo/NodeList-fx.js.uncompressed.js
deleted file mode 100644
index 83dfebd..0000000
--- a/lib/dojo/NodeList-fx.js.uncompressed.js
+++ /dev/null
@@ -1,257 +0,0 @@
-define("dojo/NodeList-fx", ["./query", "./_base/lang", "./aspect", "./_base/fx", "./fx"],
-function(query, lang, aspect, baseFx, coreFx){
-
-// module:
-// dojo/NodeList-fx
-
-/*=====
-return function(){
- // summary:
- // Adds dojo.fx animation support to dojo.query() by extending the NodeList class
- // with additional FX functions. NodeList is the array-like object used to hold query results.
-};
-=====*/
-
-var NodeList = query.NodeList;
-
-lang.extend(NodeList, {
- _anim: function(obj, method, args){
- args = args||{};
- var a = coreFx.combine(
- this.map(function(item){
- var tmpArgs = { node: item };
- lang.mixin(tmpArgs, args);
- return obj[method](tmpArgs);
- })
- );
- return args.auto ? a.play() && this : a; // dojo/_base/fx.Animation|dojo/NodeList
- },
-
- wipeIn: function(args){
- // summary:
- // wipe in all elements of this NodeList via `dojo/fx.wipeIn()`
- //
- // args: Object?
- // Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
- // an `auto` parameter.
- //
- // returns: dojo/_base/fx.Animation|dojo/NodeList
- // A special args member `auto` can be passed to automatically play the animation.
- // If args.auto is present, the original dojo/NodeList will be returned for further
- // chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
- //
- // example:
- // Fade in all tables with class "blah":
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query("table.blah").wipeIn().play();
- // | });
- //
- // example:
- // Utilizing `auto` to get the NodeList back:
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query(".titles").wipeIn({ auto:true }).onclick(someFunction);
- // | });
- //
- return this._anim(coreFx, "wipeIn", args); // dojo/_base/fx.Animation|dojo/NodeList
- },
-
- wipeOut: function(args){
- // summary:
- // wipe out all elements of this NodeList via `dojo/fx.wipeOut()`
- //
- // args: Object?
- // Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
- // an `auto` parameter.
- //
- // returns: dojo/_base/fx.Animation|dojo/NodeList
- // A special args member `auto` can be passed to automatically play the animation.
- // If args.auto is present, the original dojo/NodeList will be returned for further
- // chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
- //
- // example:
- // Wipe out all tables with class "blah":
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query("table.blah").wipeOut().play();
- // | });
- return this._anim(coreFx, "wipeOut", args); // dojo/_base/fx.Animation|dojo/NodeList
- },
-
- slideTo: function(args){
- // summary:
- // slide all elements of the node list to the specified place via `dojo/fx.slideTo()`
- //
- // args: Object?
- // Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
- // an `auto` parameter.
- //
- // returns: dojo/_base/fx.Animation|dojo/NodeList
- // A special args member `auto` can be passed to automatically play the animation.
- // If args.auto is present, the original dojo/NodeList will be returned for further
- // chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
- //
- // example:
- // | Move all tables with class "blah" to 300/300:
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query("table.blah").slideTo({
- // | left: 40,
- // | top: 50
- // | }).play();
- // | });
- return this._anim(coreFx, "slideTo", args); // dojo/_base/fx.Animation|dojo/NodeList
- },
-
-
- fadeIn: function(args){
- // summary:
- // fade in all elements of this NodeList via `dojo.fadeIn`
- //
- // args: Object?
- // Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
- // an `auto` parameter.
- //
- // returns: dojo/_base/fx.Animation|dojo/NodeList
- // A special args member `auto` can be passed to automatically play the animation.
- // If args.auto is present, the original dojo/NodeList will be returned for further
- // chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
- //
- // example:
- // Fade in all tables with class "blah":
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query("table.blah").fadeIn().play();
- // | });
- return this._anim(baseFx, "fadeIn", args); // dojo/_base/fx.Animation|dojo/NodeList
- },
-
- fadeOut: function(args){
- // summary:
- // fade out all elements of this NodeList via `dojo.fadeOut`
- //
- // args: Object?
- // Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
- // an `auto` parameter.
- //
- // returns: dojo/_base/fx.Animation|dojo/NodeList
- // A special args member `auto` can be passed to automatically play the animation.
- // If args.auto is present, the original dojo/NodeList will be returned for further
- // chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
- //
- // example:
- // Fade out all elements with class "zork":
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query(".zork").fadeOut().play();
- // | });
- // example:
- // Fade them on a delay and do something at the end:
- // | require(["dojo/query", "dojo/aspect", "dojo/NodeList-fx"
- // | ], function(query, aspect){
- // | var fo = query(".zork").fadeOut();
- // | aspect.after(fo, "onEnd", function(){ /*...*/ }, true);
- // | fo.play();
- // | });
- // example:
- // Using `auto`:
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query("li").fadeOut({ auto:true }).filter(filterFn).forEach(doit);
- // | });
- //
- return this._anim(baseFx, "fadeOut", args); // dojo/_base/fx.Animation|dojo/NodeList
- },
-
- animateProperty: function(args){
- // summary:
- // Animate all elements of this NodeList across the properties specified.
- // syntax identical to `dojo.animateProperty`
- //
- // args: Object?
- // Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
- // an `auto` parameter.
- //
- // returns: dojo/_base/fx.Animation|dojo/NodeList
- // A special args member `auto` can be passed to automatically play the animation.
- // If args.auto is present, the original dojo/NodeList will be returned for further
- // chaining. Otherwise the dojo/_base/fx.Animation instance is returned and must be .play()'ed
- //
- // example:
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query(".zork").animateProperty({
- // | duration: 500,
- // | properties: {
- // | color: { start: "black", end: "white" },
- // | left: { end: 300 }
- // | }
- // | }).play();
- // | });
- //
- // example:
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query(".grue").animateProperty({
- // | auto:true,
- // | properties: {
- // | height:240
- // | }
- // | }).onclick(handler);
- // | });
- return this._anim(baseFx, "animateProperty", args); // dojo/_base/fx.Animation|dojo/NodeList
- },
-
- anim: function( /*Object*/ properties,
- /*Integer?*/ duration,
- /*Function?*/ easing,
- /*Function?*/ onEnd,
- /*Integer?*/ delay){
- // summary:
- // Animate one or more CSS properties for all nodes in this list.
- // The returned animation object will already be playing when it
- // is returned. See the docs for `dojo.anim` for full details.
- // properties: Object
- // the properties to animate. does NOT support the `auto` parameter like other
- // NodeList-fx methods.
- // duration: Integer?
- // Optional. The time to run the animations for
- // easing: Function?
- // Optional. The easing function to use.
- // onEnd: Function?
- // A function to be called when the animation ends
- // delay:
- // how long to delay playing the returned animation
- // example:
- // Another way to fade out:
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query(".thinger").anim({ opacity: 0 });
- // | });
- // example:
- // animate all elements with the "thigner" class to a width of 500
- // pixels over half a second
- // | require(["dojo/query", "dojo/NodeList-fx"
- // | ], function(query){
- // | query(".thinger").anim({ width: 500 }, 700);
- // | });
- var canim = coreFx.combine(
- this.map(function(item){
- return baseFx.animateProperty({
- node: item,
- properties: properties,
- duration: duration||350,
- easing: easing
- });
- })
- );
- if(onEnd){
- aspect.after(canim, "onEnd", onEnd, true);
- }
- return canim.play(delay||0); // dojo/_base/fx.Animation
- }
-});
-
-return NodeList;
-});
diff --git a/lib/dojo/NodeList-html.js b/lib/dojo/NodeList-html.js
deleted file mode 100644
index f685da4..0000000
--- a/lib/dojo/NodeList-html.js
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/NodeList-html",["./query","./_base/lang","./html"],function(_1,_2,_3){
-var _4=_1.NodeList;
-_2.extend(_4,{html:function(_5,_6){
-var _7=new _3._ContentSetter(_6||{});
-this.forEach(function(_8){
-_7.node=_8;
-_7.set(_5);
-_7.tearDown();
-});
-return this;
-}});
-return _4;
-});
diff --git a/lib/dojo/NodeList-html.js.uncompressed.js b/lib/dojo/NodeList-html.js.uncompressed.js
deleted file mode 100644
index 54c1710..0000000
--- a/lib/dojo/NodeList-html.js.uncompressed.js
+++ /dev/null
@@ -1,56 +0,0 @@
-define("dojo/NodeList-html", ["./query", "./_base/lang", "./html"], function(query, lang, html){
-
-// module:
-// dojo/NodeList-html
-
-/*=====
-return function(){
- // summary:
- // Adds a chainable html method to dojo/query() / NodeList instances for setting/replacing node content
-};
-=====*/
-
-var NodeList = query.NodeList;
-
-
-lang.extend(NodeList, {
- html: function(/* String|DomNode|NodeList? */ content, /* Object? */params){
- // summary:
- // see `dojo/html.set()`. Set the content of all elements of this NodeList
- //
- // content:
- // An html string, node or enumerable list of nodes for insertion into the dom
- //
- // params:
- // Optional flags/properties to configure the content-setting. See dojo/html._ContentSetter
- //
- // description:
- // Based around `dojo/html.set()`, set the content of the Elements in a
- // NodeList to the given content (string/node/nodelist), with optional arguments
- // to further tune the set content behavior.
- //
- // example:
- // | require(["dojo/query", "dojo/NodeList-html"
- // | ], function(query){
- // | query(".thingList").html("
1
2
3
",
- // | {
- // | parseContent: true,
- // | onBegin: function(){
- // | this.content = this.content.replace(/([0-9])/g, this.id + ": $1");
- // | this.inherited("onBegin", arguments);
- // | }
- // | }).removeClass("notdone").addClass("done");
- // | });
-
- var dhs = new html._ContentSetter(params || {});
- this.forEach(function(elm){
- dhs.node = elm;
- dhs.set(content);
- dhs.tearDown();
- });
- return this; // dojo/NodeList
- }
-});
-
-return NodeList;
-});
diff --git a/lib/dojo/NodeList-manipulate.js b/lib/dojo/NodeList-manipulate.js
deleted file mode 100644
index 665f469..0000000
--- a/lib/dojo/NodeList-manipulate.js
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/NodeList-manipulate",["./query","./_base/lang","./_base/array","./dom-construct","./dom-attr","./NodeList-dom"],function(_1,_2,_3,_4,_5){
-var _6=_1.NodeList;
-function _7(_8){
-while(_8.childNodes[0]&&_8.childNodes[0].nodeType==1){
-_8=_8.childNodes[0];
-}
-return _8;
-};
-function _9(_a,_b){
-if(typeof _a=="string"){
-_a=_4.toDom(_a,(_b&&_b.ownerDocument));
-if(_a.nodeType==11){
-_a=_a.childNodes[0];
-}
-}else{
-if(_a.nodeType==1&&_a.parentNode){
-_a=_a.cloneNode(false);
-}
-}
-return _a;
-};
-_2.extend(_6,{_placeMultiple:function(_c,_d){
-var _e=typeof _c=="string"||_c.nodeType?_1(_c):_c;
-var _f=[];
-for(var i=0;i<_e.length;i++){
-var _10=_e[i];
-var _11=this.length;
-for(var j=_11-1,_12;_12=this[j];j--){
-if(i>0){
-_12=this._cloneNode(_12);
-_f.unshift(_12);
-}
-if(j==_11-1){
-_4.place(_12,_10,_d);
-}else{
-_10.parentNode.insertBefore(_12,_10);
-}
-_10=_12;
-}
-}
-if(_f.length){
-_f.unshift(0);
-_f.unshift(this.length-1);
-Array.prototype.splice.apply(this,_f);
-}
-return this;
-},innerHTML:function(_13){
-if(arguments.length){
-return this.addContent(_13,"only");
-}else{
-return this[0].innerHTML;
-}
-},text:function(_14){
-if(arguments.length){
-for(var i=0,_15;_15=this[i];i++){
-if(_15.nodeType==1){
-_5.set(_15,"textContent",_14);
-}
-}
-return this;
-}else{
-var _16="";
-for(i=0;_15=this[i];i++){
-_16+=_5.get(_15,"textContent");
-}
-return _16;
-}
-},val:function(_17){
-if(arguments.length){
-var _18=_2.isArray(_17);
-for(var _19=0,_1a;_1a=this[_19];_19++){
-var _1b=_1a.nodeName.toUpperCase();
-var _1c=_1a.type;
-var _1d=_18?_17[_19]:_17;
-if(_1b=="SELECT"){
-var _1e=_1a.options;
-for(var i=0;i<_1e.length;i++){
-var opt=_1e[i];
-if(_1a.multiple){
-opt.selected=(_3.indexOf(_17,opt.value)!=-1);
-}else{
-opt.selected=(opt.value==_1d);
-}
-}
-}else{
-if(_1c=="checkbox"||_1c=="radio"){
-_1a.checked=(_1a.value==_1d);
-}else{
-_1a.value=_1d;
-}
-}
-}
-return this;
-}else{
-_1a=this[0];
-if(!_1a||_1a.nodeType!=1){
-return undefined;
-}
-_17=_1a.value||"";
-if(_1a.nodeName.toUpperCase()=="SELECT"&&_1a.multiple){
-_17=[];
-_1e=_1a.options;
-for(i=0;i<_1e.length;i++){
-opt=_1e[i];
-if(opt.selected){
-_17.push(opt.value);
-}
-}
-if(!_17.length){
-_17=null;
-}
-}
-return _17;
-}
-},append:function(_1f){
-return this.addContent(_1f,"last");
-},appendTo:function(_20){
-return this._placeMultiple(_20,"last");
-},prepend:function(_21){
-return this.addContent(_21,"first");
-},prependTo:function(_22){
-return this._placeMultiple(_22,"first");
-},after:function(_23){
-return this.addContent(_23,"after");
-},insertAfter:function(_24){
-return this._placeMultiple(_24,"after");
-},before:function(_25){
-return this.addContent(_25,"before");
-},insertBefore:function(_26){
-return this._placeMultiple(_26,"before");
-},remove:_6.prototype.orphan,wrap:function(_27){
-if(this[0]){
-_27=_9(_27,this[0]);
-for(var i=0,_28;_28=this[i];i++){
-var _29=this._cloneNode(_27);
-if(_28.parentNode){
-_28.parentNode.replaceChild(_29,_28);
-}
-var _2a=_7(_29);
-_2a.appendChild(_28);
-}
-}
-return this;
-},wrapAll:function(_2b){
-if(this[0]){
-_2b=_9(_2b,this[0]);
-this[0].parentNode.replaceChild(_2b,this[0]);
-var _2c=_7(_2b);
-for(var i=0,_2d;_2d=this[i];i++){
-_2c.appendChild(_2d);
-}
-}
-return this;
-},wrapInner:function(_2e){
-if(this[0]){
-_2e=_9(_2e,this[0]);
-for(var i=0;i0);
-_31.parentNode.removeChild(_31);
-}
-return this;
-},replaceAll:function(_32){
-var nl=_1(_32);
-var _33=this._normalize(this,this[0]);
-for(var i=0,_34;_34=nl[i];i++){
-this._place(_33,_34,"before",i>0);
-_34.parentNode.removeChild(_34);
-}
-return this;
-},clone:function(){
-var ary=[];
-for(var i=0;i 0){
- //Need to clone the item. This also means
- //it needs to be added to the current NodeList
- //so it can also be the target of other chaining operations.
- item = this._cloneNode(item);
- toAdd.unshift(item);
- }
- if(j == length - 1){
- construct.place(item, refNode, position);
- }else{
- refNode.parentNode.insertBefore(item, refNode);
- }
- refNode = item;
- }
- }
-
- if(toAdd.length){
- //Add the toAdd items to the current NodeList. Build up list of args
- //to pass to splice.
- toAdd.unshift(0);
- toAdd.unshift(this.length - 1);
- Array.prototype.splice.apply(this, toAdd);
- }
-
- return this; // dojo/NodeList
- },
-
- innerHTML: function(/*String|DOMNode|NodeList?*/ value){
- // summary:
- // allows setting the innerHTML of each node in the NodeList,
- // if there is a value passed in, otherwise, reads the innerHTML value of the first node.
- // description:
- // This method is simpler than the dojo/NodeList.html() method provided by
- // `dojo/NodeList-html`. This method just does proper innerHTML insertion of HTML fragments,
- // and it allows for the innerHTML to be read for the first node in the node list.
- // Since dojo/NodeList-html already took the "html" name, this method is called
- // "innerHTML". However, if dojo/NodeList-html has not been loaded yet, this
- // module will define an "html" method that can be used instead. Be careful if you
- // are working in an environment where it is possible that dojo/NodeList-html could
- // have been loaded, since its definition of "html" will take precedence.
- // The nodes represented by the value argument will be cloned if more than one
- // node is in this NodeList. The nodes in this NodeList are returned in the "set"
- // usage of this method, not the HTML that was inserted.
- // returns:
- // if no value is passed, the result is String, the innerHTML of the first node.
- // If a value is passed, the return is this dojo/NodeList
- // example:
- // assume a DOM created by this markup:
- // |
- // |
- // This code inserts `
Hello World
` into both divs:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("div").innerHTML("
Hello World
");
- // | });
- // example:
- // assume a DOM created by this markup:
- // |
Hello Mars
- // |
Hello World
- // This code returns `
Hello Mars
`:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | var message = query("div").innerHTML();
- // | });
- if(arguments.length){
- return this.addContent(value, "only"); // dojo/NodeList
- }else{
- return this[0].innerHTML; //String
- }
- },
-
- /*=====
- html: function(value){
- // summary:
- // see the information for "innerHTML". "html" is an alias for "innerHTML", but is
- // only defined if dojo/NodeList-html has not been loaded.
- // description:
- // An alias for the "innerHTML" method, but only defined if there is not an existing
- // "html" method on dojo/NodeList. Be careful if you are working in an environment
- // where it is possible that dojo/NodeList-html could have been loaded, since its
- // definition of "html" will take precedence. If you are not sure if dojo/NodeList-html
- // could be loaded, use the "innerHTML" method.
- // value: String|DOMNode|NodeList?
- // The HTML fragment to use as innerHTML. If value is not passed, then the innerHTML
- // of the first element in this NodeList is returned.
- // returns:
- // if no value is passed, the result is String, the innerHTML of the first node.
- // If a value is passed, the return is this dojo/NodeList
- return; // dojo/NodeList|String
- },
- =====*/
-
- text: function(/*String*/value){
- // summary:
- // allows setting the text value of each node in the NodeList,
- // if there is a value passed in, otherwise, returns the text value for all the
- // nodes in the NodeList in one string.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
- // This code inserts "Hello World" into both divs:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("div").text("Hello World");
- // | });
- // example:
- // assume a DOM created by this markup:
- // |
Hello Mars today
- // |
Hello World
- // This code returns "Hello Mars today":
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | var message = query("div").text();
- // | });
- // returns:
- // if no value is passed, the result is String, the text value of the first node.
- // If a value is passed, the return is this dojo/NodeList
- if(arguments.length){
- for(var i = 0, node; node = this[i]; i++){
- if(node.nodeType == 1){
- attr.set(node, 'textContent', value);
- }
- }
- return this; // dojo/NodeList
- }else{
- var result = "";
- for(i = 0; node = this[i]; i++){
- result += attr.get(node, 'textContent');
- }
- return result; //String
- }
- },
-
- val: function(/*String||Array*/value){
- // summary:
- // If a value is passed, allows seting the value property of form elements in this
- // NodeList, or properly selecting/checking the right value for radio/checkbox/select
- // elements. If no value is passed, the value of the first node in this NodeList
- // is returned.
- // returns:
- // if no value is passed, the result is String or an Array, for the value of the
- // first node.
- // If a value is passed, the return is this dojo/NodeList
- // example:
- // assume a DOM created by this markup:
- // |
- // |
- // This code gets and sets the values for the form fields above:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query('[type="text"]').val(); //gets value foo
- // | query('[type="text"]').val("bar"); //sets the input's value to "bar"
- // | query("select").val() //gets array value ["red", "yellow"]
- // | query("select").val(["blue", "yellow"]) //Sets the blue and yellow options to selected.
- // | });
-
- //Special work for input elements.
- if(arguments.length){
- var isArray = lang.isArray(value);
- for(var index = 0, node; node = this[index]; index++){
- var name = node.nodeName.toUpperCase();
- var type = node.type;
- var newValue = isArray ? value[index] : value;
-
- if(name == "SELECT"){
- var opts = node.options;
- for(var i = 0; i < opts.length; i++){
- var opt = opts[i];
- if(node.multiple){
- opt.selected = (array.indexOf(value, opt.value) != -1);
- }else{
- opt.selected = (opt.value == newValue);
- }
- }
- }else if(type == "checkbox" || type == "radio"){
- node.checked = (node.value == newValue);
- }else{
- node.value = newValue;
- }
- }
- return this; // dojo/NodeList
- }else{
- //node already declared above.
- node = this[0];
- if(!node || node.nodeType != 1){
- return undefined;
- }
- value = node.value || "";
- if(node.nodeName.toUpperCase() == "SELECT" && node.multiple){
- //A multivalued selectbox. Do the pain.
- value = [];
- //opts declared above in if block.
- opts = node.options;
- //i declared above in if block;
- for(i = 0; i < opts.length; i++){
- //opt declared above in if block
- opt = opts[i];
- if(opt.selected){
- value.push(opt.value);
- }
- }
- if(!value.length){
- value = null;
- }
- }
- return value; //String||Array
- }
- },
-
- append: function(/*String||DOMNode||NodeList*/content){
- // summary:
- // appends the content to every node in the NodeList.
- // description:
- // The content will be cloned if the length of NodeList
- // is greater than 1. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the appended content.
- // example:
- // assume a DOM created by this markup:
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("div").append("append");
- // | });
- // Results in this DOM structure:
- // |
Hello Mars
append
- // |
Hello World
append
- return this.addContent(content, "last"); // dojo/NodeList
- },
-
- appendTo: function(/*String*/query){
- // summary:
- // appends nodes in this NodeList to the nodes matched by
- // the query passed to appendTo.
- // description:
- // The nodes in this NodeList will be cloned if the query
- // matches more than one element. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the matched nodes from the query.
- // example:
- // assume a DOM created by this markup:
- // | append
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("span").appendTo("p");
- // | });
- // Results in this DOM structure:
- // |
Hello Marsappend
- // |
Hello Worldappend
- return this._placeMultiple(query, "last"); // dojo/NodeList
- },
-
- prepend: function(/*String||DOMNode||NodeList*/content){
- // summary:
- // prepends the content to every node in the NodeList.
- // description:
- // The content will be cloned if the length of NodeList
- // is greater than 1. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the appended content.
- // assume a DOM created by this markup:
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("div").prepend("prepend");
- // | });
- // Results in this DOM structure:
- // |
prepend
Hello Mars
- // |
prepend
Hello World
- return this.addContent(content, "first"); // dojo/NodeList
- },
-
- prependTo: function(/*String*/query){
- // summary:
- // prepends nodes in this NodeList to the nodes matched by
- // the query passed to prependTo.
- // description:
- // The nodes in this NodeList will be cloned if the query
- // matches more than one element. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the matched nodes from the query.
- // example:
- // assume a DOM created by this markup:
- // | prepend
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("span").prependTo("p");
- // | });
- // Results in this DOM structure:
- // |
prependHello Mars
- // |
prependHello World
- return this._placeMultiple(query, "first"); // dojo/NodeList
- },
-
- after: function(/*String||Element||NodeList*/content){
- // summary:
- // Places the content after every node in the NodeList.
- // description:
- // The content will be cloned if the length of NodeList
- // is greater than 1. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the appended content.
- // example:
- // assume a DOM created by this markup:
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("div").after("after");
- // | });
- // Results in this DOM structure:
- // |
Hello Mars
after
- // |
Hello World
after
- return this.addContent(content, "after"); // dojo/NodeList
- },
-
- insertAfter: function(/*String*/query){
- // summary:
- // The nodes in this NodeList will be placed after the nodes
- // matched by the query passed to insertAfter.
- // description:
- // The nodes in this NodeList will be cloned if the query
- // matches more than one element. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the matched nodes from the query.
- // example:
- // assume a DOM created by this markup:
- // | after
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("span").insertAfter("p");
- // | });
- // Results in this DOM structure:
- // |
Hello Mars
after
- // |
Hello World
after
- return this._placeMultiple(query, "after"); // dojo/NodeList
- },
-
- before: function(/*String||DOMNode||NodeList*/content){
- // summary:
- // Places the content before every node in the NodeList.
- // description:
- // The content will be cloned if the length of NodeList
- // is greater than 1. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the appended content.
- // example:
- // assume a DOM created by this markup:
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("div").before("before");
- // | });
- // Results in this DOM structure:
- // | before
Hello Mars
- // | before
Hello World
- return this.addContent(content, "before"); // dojo/NodeList
- },
-
- insertBefore: function(/*String*/query){
- // summary:
- // The nodes in this NodeList will be placed after the nodes
- // matched by the query passed to insertAfter.
- // description:
- // The nodes in this NodeList will be cloned if the query
- // matches more than one element. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // dojo/NodeList, the nodes currently in this NodeList will be returned,
- // not the matched nodes from the query.
- // example:
- // assume a DOM created by this markup:
- // | before
- // |
Hello Mars
- // |
Hello World
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("span").insertBefore("p");
- // | });
- // Results in this DOM structure:
- // | before
Hello Mars
- // | before
Hello World
- return this._placeMultiple(query, "before"); // dojo/NodeList
- },
-
- /*=====
- remove: function(simpleFilter){
- // summary:
- // alias for dojo/NodeList's orphan method. Removes elements
- // in this list that match the simple filter from their parents
- // and returns them as a new NodeList.
- // simpleFilter: String
- // single-expression CSS rule. For example, ".thinger" or
- // "#someId[attrName='value']" but not "div > span". In short,
- // anything which does not invoke a descent to evaluate but
- // can instead be used to test a single node is acceptable.
-
- return; // dojo/NodeList
- },
- =====*/
- remove: NodeList.prototype.orphan,
-
- wrap: function(/*String||DOMNode*/html){
- // summary:
- // Wrap each node in the NodeList with html passed to wrap.
- // description:
- // html will be cloned if the NodeList has more than one
- // element. Only DOM nodes are cloned, not any attached
- // event handlers.
- // returns:
- // the nodes in the current NodeList will be returned,
- // not the nodes from html argument.
- // example:
- // assume a DOM created by this markup:
- // | one
- // | two
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query("b").wrap("
");
- // | });
- // Results in this DOM structure:
- // |
one
- // |
two
- if(this[0]){
- html = makeWrapNode(html, this[0]);
-
- //Now cycle through the elements and do the insertion.
- for(var i = 0, node; node = this[i]; i++){
- //Always clone because if html is used to hold one of
- //the "this" nodes, then on the clone of html it will contain
- //that "this" node, and that would be bad.
- var clone = this._cloneNode(html);
- if(node.parentNode){
- node.parentNode.replaceChild(clone, node);
- }
- //Find deepest element and insert old node in it.
- var insertion = getWrapInsertion(clone);
- insertion.appendChild(node);
- }
- }
- return this; // dojo/NodeList
- },
-
- wrapAll: function(/*String||DOMNode*/html){
- // summary:
- // Insert html where the first node in this NodeList lives, then place all
- // nodes in this NodeList as the child of the html.
- // returns:
- // the nodes in the current NodeList will be returned,
- // not the nodes from html argument.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query(".red").wrapAll('');
- // | });
- // Results in this DOM structure:
- // |
- // |
- // |
Red One
- // |
Red Two
- // |
- // |
Blue One
- // |
Blue Two
- // |
- if(this[0]){
- html = makeWrapNode(html, this[0]);
-
- //Place the wrap HTML in place of the first node.
- this[0].parentNode.replaceChild(html, this[0]);
-
- //Now cycle through the elements and move them inside
- //the wrap.
- var insertion = getWrapInsertion(html);
- for(var i = 0, node; node = this[i]; i++){
- insertion.appendChild(node);
- }
- }
- return this; // dojo/NodeList
- },
-
- wrapInner: function(/*String||DOMNode*/html){
- // summary:
- // For each node in the NodeList, wrap all its children with the passed in html.
- // description:
- // html will be cloned if the NodeList has more than one
- // element. Only DOM nodes are cloned, not any attached
- // event handlers.
- // returns:
- // the nodes in the current NodeList will be returned,
- // not the nodes from html argument.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query(".red").wrapInner('');
- // | });
- // Results in this DOM structure:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- if(this[0]){
- html = makeWrapNode(html, this[0]);
- for(var i = 0; i < this.length; i++){
- //Always clone because if html is used to hold one of
- //the "this" nodes, then on the clone of html it will contain
- //that "this" node, and that would be bad.
- var clone = this._cloneNode(html);
-
- //Need to convert the childNodes to an array since wrapAll modifies the
- //DOM and can change the live childNodes NodeList.
- this._wrap(lang._toArray(this[i].childNodes), null, this._NodeListCtor).wrapAll(clone);
- }
- }
- return this; // dojo/NodeList
- },
-
- replaceWith: function(/*String||DOMNode||NodeList*/content){
- // summary:
- // Replaces each node in ths NodeList with the content passed to replaceWith.
- // description:
- // The content will be cloned if the length of NodeList
- // is greater than 1. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // The nodes currently in this NodeList will be returned, not the replacing content.
- // Note that the returned nodes have been removed from the DOM.
- // example:
- // assume a DOM created by this markup:
- // |
');
- // | });
- // Results in this DOM structure:
- // |
- // |
Green
- // |
Blue One
- // |
Green
- // |
Blue Two
- // |
- content = this._normalize(content, this[0]);
- for(var i = 0, node; node = this[i]; i++){
- this._place(content, node, "before", i > 0);
- node.parentNode.removeChild(node);
- }
- return this; // dojo/NodeList
- },
-
- replaceAll: function(/*String*/query){
- // summary:
- // replaces nodes matched by the query passed to replaceAll with the nodes
- // in this NodeList.
- // description:
- // The nodes in this NodeList will be cloned if the query
- // matches more than one element. Only the DOM nodes are cloned, not
- // any attached event handlers.
- // returns:
- // The nodes currently in this NodeList will be returned, not the matched nodes
- // from the query. The nodes currently in this NodeLIst could have
- // been cloned, so the returned NodeList will include the cloned nodes.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
___
- // |
Red One
- // |
___
- // |
Blue One
- // |
___
- // |
Red Two
- // |
___
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query(".red").replaceAll(".blue");
- // | });
- // Results in this DOM structure:
- // |
- // |
___
- // |
___
- // |
Red One
- // |
Red Two
- // |
___
- // |
___
- // |
Red One
- // |
Red Two
- // |
- var nl = dquery(query);
- var content = this._normalize(this, this[0]);
- for(var i = 0, node; node = nl[i]; i++){
- this._place(content, node, "before", i > 0);
- node.parentNode.removeChild(node);
- }
- return this; // dojo/NodeList
- },
-
- clone: function(){
- // summary:
- // Clones all the nodes in this NodeList and returns them as a new NodeList.
- // description:
- // Only the DOM nodes are cloned, not any attached event handlers.
- // returns:
- // a cloned set of the original nodes.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-manipulate"
- // | ], function(query){
- // | query(".red").clone().appendTo(".container");
- // | });
- // Results in this DOM structure:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
Red One
- // |
Red Two
- // |
-
- //TODO: need option to clone events?
- var ary = [];
- for(var i = 0; i < this.length; i++){
- ary.push(this._cloneNode(this[i]));
- }
- return this._wrap(ary, this, this._NodeListCtor); // dojo/NodeList
- }
- });
-
- //set up html method if one does not exist
- if(!NodeList.prototype.html){
- NodeList.prototype.html = NodeList.prototype.innerHTML;
- }
-
- return NodeList;
-});
diff --git a/lib/dojo/NodeList-traverse.js b/lib/dojo/NodeList-traverse.js
deleted file mode 100644
index c850def..0000000
--- a/lib/dojo/NodeList-traverse.js
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/NodeList-traverse",["./query","./_base/lang","./_base/array"],function(_1,_2,_3){
-var _4=_1.NodeList;
-_2.extend(_4,{_buildArrayFromCallback:function(_5){
-var _6=[];
-for(var i=0;i
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".container").children();
- // | });
- // returns the four divs that are children of the container div.
- // Running this code:
- // | dojo.query(".container").children(".red");
- // returns the two divs that have the class "red".
- return this._getRelatedUniqueNodes(query, function(node, ary){
- return lang._toArray(node.childNodes);
- }); // dojo/NodeList
- },
-
- closest: function(/*String*/ query, /*String|DOMNode?*/ root){
- // summary:
- // Returns closest parent that matches query, including current node in this
- // dojo/NodeList if it matches the query.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // root:
- // If specified, query is relative to "root" rather than document body.
- // returns:
- // the closest parent that matches the query, including the current
- // node in this dojo/NodeList if it matches the query.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".red").closest(".container");
- // | });
- // returns the div with class "container".
- return this._getRelatedUniqueNodes(null, function(node, ary){
- do{
- if(dquery._filterResult([node], query, root).length){
- return node;
- }
- }while(node != root && (node = node.parentNode) && node.nodeType == 1);
- return null; //To make rhino strict checking happy.
- }); // dojo/NodeList
- },
-
- parent: function(/*String?*/ query){
- // summary:
- // Returns immediate parent elements for nodes in this dojo/NodeList.
- // Optionally takes a query to filter the parent elements.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // returns:
- // immediate parent elements for nodes in this dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".text").parent();
- // | });
- // returns the two divs with class "blue".
- // Running this code:
- // | query(".text").parent(".first");
- // returns the one div with class "blue" and "first".
- return this._getRelatedUniqueNodes(query, function(node, ary){
- return node.parentNode;
- }); // dojo/NodeList
- },
-
- parents: function(/*String?*/ query){
- // summary:
- // Returns all parent elements for nodes in this dojo/NodeList.
- // Optionally takes a query to filter the child elements.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // returns:
- // all parent elements for nodes in this dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".text").parents();
- // | });
- // returns the two divs with class "blue", the div with class "container",
- // | the body element and the html element.
- // Running this code:
- // | query(".text").parents(".container");
- // returns the one div with class "container".
- return this._getRelatedUniqueNodes(query, function(node, ary){
- var pary = [];
- while(node.parentNode){
- node = node.parentNode;
- pary.push(node);
- }
- return pary;
- }); // dojo/NodeList
- },
-
- siblings: function(/*String?*/ query){
- // summary:
- // Returns all sibling elements for nodes in this dojo/NodeList.
- // Optionally takes a query to filter the sibling elements.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // returns:
- // all sibling elements for nodes in this dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".first").siblings();
- // | });
- // returns the two divs with class "red" and the other div
- // | with class "blue" that does not have "first".
- // Running this code:
- // | query(".first").siblings(".red");
- // returns the two div with class "red".
- return this._getRelatedUniqueNodes(query, function(node, ary){
- var pary = [];
- var nodes = (node.parentNode && node.parentNode.childNodes);
- for(var i = 0; i < nodes.length; i++){
- if(nodes[i] != node){
- pary.push(nodes[i]);
- }
- }
- return pary;
- }); // dojo/NodeList
- },
-
- next: function(/*String?*/ query){
- // summary:
- // Returns the next element for nodes in this dojo/NodeList.
- // Optionally takes a query to filter the next elements.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // returns:
- // the next element for nodes in this dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".first").next();
- // | });
- // returns the div with class "red" and has innerHTML of "Red Two".
- // Running this code:
- // | dojo.query(".last").next(".red");
- // does not return any elements.
- return this._getRelatedUniqueNodes(query, function(node, ary){
- var next = node.nextSibling;
- while(next && next.nodeType != 1){
- next = next.nextSibling;
- }
- return next;
- }); // dojo/NodeList
- },
-
- nextAll: function(/*String?*/ query){
- // summary:
- // Returns all sibling elements that come after the nodes in this dojo/NodeList.
- // Optionally takes a query to filter the sibling elements.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // returns:
- // all sibling elements that come after the nodes in this dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".first").nextAll();
- // | });
- // returns the two divs with class of "next".
- // Running this code:
- // | query(".first").nextAll(".red");
- // returns the one div with class "red" and innerHTML "Red Two".
- return this._getRelatedUniqueNodes(query, function(node, ary){
- var pary = [];
- var next = node;
- while((next = next.nextSibling)){
- if(next.nodeType == 1){
- pary.push(next);
- }
- }
- return pary;
- }); // dojo/NodeList
- },
-
- prev: function(/*String?*/ query){
- // summary:
- // Returns the previous element for nodes in this dojo/NodeList.
- // Optionally takes a query to filter the previous elements.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // returns:
- // the previous element for nodes in this dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".first").prev();
- // | });
- // returns the div with class "red" and has innerHTML of "Red One".
- // Running this code:
- // | query(".first").prev(".blue");
- // does not return any elements.
- return this._getRelatedUniqueNodes(query, function(node, ary){
- var prev = node.previousSibling;
- while(prev && prev.nodeType != 1){
- prev = prev.previousSibling;
- }
- return prev;
- }); // dojo/NodeList
- },
-
- prevAll: function(/*String?*/ query){
- // summary:
- // Returns all sibling elements that come before the nodes in this dojo/NodeList.
- // Optionally takes a query to filter the sibling elements.
- // description:
- // The returned nodes will be in reverse DOM order -- the first node in the list will
- // be the node closest to the original node/NodeList.
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // query:
- // a CSS selector.
- // returns:
- // all sibling elements that come before the nodes in this dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".second").prevAll();
- // | });
- // returns the two divs with class of "prev".
- // Running this code:
- // | query(".first").prevAll(".red");
- // returns the one div with class "red prev" and innerHTML "Red One".
- return this._getRelatedUniqueNodes(query, function(node, ary){
- var pary = [];
- var prev = node;
- while((prev = prev.previousSibling)){
- if(prev.nodeType == 1){
- pary.push(prev);
- }
- }
- return pary;
- }); // dojo/NodeList
- },
-
- andSelf: function(){
- // summary:
- // Adds the nodes from the previous dojo/NodeList to the current dojo/NodeList.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // | Some Text
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".second").prevAll().andSelf();
- // | });
- // returns the two divs with class of "prev", as well as the div with class "second".
- return this.concat(this._parent); // dojo/NodeList
- },
-
- //Alternate methods for the :first/:last/:even/:odd pseudos.
- first: function(){
- // summary:
- // Returns the first node in this dojo/NodeList as a dojo/NodeList.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // returns:
- // the first node in this dojo/NodeList
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".blue").first();
- // | });
- // returns the div with class "blue" and "first".
- return this._wrap(((this[0] && [this[0]]) || []), this); // dojo/NodeList
- },
-
- last: function(){
- // summary:
- // Returns the last node in this dojo/NodeList as a dojo/NodeList.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // returns:
- // the last node in this dojo/NodeList
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".blue").last();
- // | });
- // returns the last div with class "blue",
- return this._wrap((this.length ? [this[this.length - 1]] : []), this); // dojo/NodeList
- },
-
- even: function(){
- // summary:
- // Returns the even nodes in this dojo/NodeList as a dojo/NodeList.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // returns:
- // the even nodes in this dojo/NodeList
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".interior").even();
- // | });
- // returns the two divs with class "blue"
- return this.filter(function(item, i){
- return i % 2 != 0;
- }); // dojo/NodeList
- },
-
- odd: function(){
- // summary:
- // Returns the odd nodes in this dojo/NodeList as a dojo/NodeList.
- // description:
- // .end() can be used on the returned dojo/NodeList to get back to the
- // original dojo/NodeList.
- // returns:
- // the odd nodes in this dojo/NodeList
- // example:
- // assume a DOM created by this markup:
- // |
- // |
Red One
- // |
Blue One
- // |
Red Two
- // |
Blue Two
- // |
- // Running this code:
- // | require(["dojo/query", "dojo/NodeList-traverse"
- // | ], function(query){
- // | query(".interior").odd();
- // | });
- // returns the two divs with class "red"
- return this.filter(function(item, i){
- return i % 2 == 0;
- }); // dojo/NodeList
- }
-});
-
-return NodeList;
-});
diff --git a/lib/dojo/NodeList.js b/lib/dojo/NodeList.js
deleted file mode 100644
index 694e230..0000000
--- a/lib/dojo/NodeList.js
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/NodeList",["./query"],function(_1){
-return _1.NodeList;
-});
diff --git a/lib/dojo/NodeList.js.uncompressed.js b/lib/dojo/NodeList.js.uncompressed.js
deleted file mode 100644
index 680e325..0000000
--- a/lib/dojo/NodeList.js.uncompressed.js
+++ /dev/null
@@ -1,6 +0,0 @@
-define("dojo/NodeList", ["./query"], function(query){
- // This class is just for documentation purposes, so NodeList shows up well in the API viewer,
- // and to simplify writing API doc for all the methods that take NodeList as a parameter, or return a NodeList.
- return query.NodeList;
-});
-
diff --git a/lib/dojo/OpenAjax.js b/lib/dojo/OpenAjax.js
deleted file mode 100644
index 0b3c891..0000000
--- a/lib/dojo/OpenAjax.js
+++ /dev/null
@@ -1,192 +0,0 @@
-/*******************************************************************************
- * OpenAjax.js
- *
- * Reference implementation of the OpenAjax Hub, as specified by OpenAjax Alliance.
- * Specification is under development at:
- *
- * http://www.openajax.org/member/wiki/OpenAjax_Hub_Specification
- *
- * Copyright 2006-2007 OpenAjax Alliance
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0 . Unless
- * required by applicable law or agreed to in writing, software distributed
- * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
- * CONDITIONS OF ANY KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations under the License.
- *
- ******************************************************************************/
-
-// prevent re-definition of the OpenAjax object
-if(!window["OpenAjax"]){
- OpenAjax = new function(){
- // summary:
- // the OpenAjax hub
- // description:
- // see http://www.openajax.org/member/wiki/OpenAjax_Hub_Specification
-
- var libs = {};
- var ooh = "org.openajax.hub.";
-
- var h = {};
- this.hub = h;
- h.implementer = "http://openajax.org";
- h.implVersion = "0.6";
- h.specVersion = "0.6";
- h.implExtraData = {};
- h.libraries = libs;
-
- h.registerLibrary = function(prefix, nsURL, version, extra){
- libs[prefix] = {
- prefix: prefix,
- namespaceURI: nsURL,
- version: version,
- extraData: extra
- };
- this.publish(ooh+"registerLibrary", libs[prefix]);
- };
- h.unregisterLibrary = function(prefix){
- this.publish(ooh+"unregisterLibrary", libs[prefix]);
- delete libs[prefix];
- };
-
- h._subscriptions = { c:{}, s:[] };
- h._cleanup = [];
- h._subIndex = 0;
- h._pubDepth = 0;
-
- h.subscribe = function(name, callback, scope, subscriberData, filter){
- if(!scope){
- scope = window;
- }
- var handle = name + "." + this._subIndex;
- var sub = { scope: scope, cb: callback, fcb: filter, data: subscriberData, sid: this._subIndex++, hdl: handle };
- var path = name.split(".");
- this._subscribe(this._subscriptions, path, 0, sub);
- return handle;
- };
-
- h.publish = function(name, message){
- var path = name.split(".");
- this._pubDepth++;
- this._publish(this._subscriptions, path, 0, name, message);
- this._pubDepth--;
- if((this._cleanup.length > 0) && (this._pubDepth == 0)){
- for(var i = 0; i < this._cleanup.length; i++){
- this.unsubscribe(this._cleanup[i].hdl);
- }
- delete(this._cleanup);
- this._cleanup = [];
- }
- };
-
- h.unsubscribe = function(sub){
- var path = sub.split(".");
- var sid = path.pop();
- this._unsubscribe(this._subscriptions, path, 0, sid);
- };
-
- h._subscribe = function(tree, path, index, sub){
- var token = path[index];
- if(index == path.length){
- tree.s.push(sub);
- }else{
- if(typeof tree.c == "undefined"){
- tree.c = {};
- }
- if(typeof tree.c[token] == "undefined"){
- tree.c[token] = { c: {}, s: [] };
- }
- this._subscribe(tree.c[token], path, index + 1, sub);
- }
- };
-
- h._publish = function(tree, path, index, name, msg){
- if(typeof tree != "undefined"){
- var node;
- if(index == path.length){
- node = tree;
- }else{
- this._publish(tree.c[path[index]], path, index + 1, name, msg);
- this._publish(tree.c["*"], path, index + 1, name, msg);
- node = tree.c["**"];
- }
- if(typeof node != "undefined"){
- var callbacks = node.s;
- var max = callbacks.length;
- for(var i = 0; i < max; i++){
- if(callbacks[i].cb){
- var sc = callbacks[i].scope;
- var cb = callbacks[i].cb;
- var fcb = callbacks[i].fcb;
- var d = callbacks[i].data;
- if(typeof cb == "string"){
- // get a function object
- cb = sc[cb];
- }
- if(typeof fcb == "string"){
- // get a function object
- fcb = sc[fcb];
- }
- if((!fcb) ||
- (fcb.call(sc, name, msg, d))){
- cb.call(sc, name, msg, d);
- }
- }
- }
- }
- }
- };
-
- h._unsubscribe = function(tree, path, index, sid){
- if(typeof tree != "undefined"){
- if(index < path.length){
- var childNode = tree.c[path[index]];
- this._unsubscribe(childNode, path, index + 1, sid);
- if(childNode.s.length == 0){
- for(var x in childNode.c)
- return;
- delete tree.c[path[index]];
- }
- return;
- }
- else{
- var callbacks = tree.s;
- var max = callbacks.length;
- for(var i = 0; i < max; i++){
- if(sid == callbacks[i].sid){
- if(this._pubDepth > 0){
- callbacks[i].cb = null;
- this._cleanup.push(callbacks[i]);
- }
- else
- callbacks.splice(i, 1);
- return;
- }
- }
- }
- }
- };
-
- // The following function is provided for automatic testing purposes.
- // It is not expected to be deployed in run-time OpenAjax Hub implementations.
- h.reinit = function(){
- for (var lib in OpenAjax.hub.libraries){
- delete OpenAjax.hub.libraries[lib];
- }
- OpenAjax.hub.registerLibrary("OpenAjax", "http://openajax.org/hub", "0.6", {});
-
- delete OpenAjax._subscriptions;
- OpenAjax._subscriptions = {c:{},s:[]};
- delete OpenAjax._cleanup;
- OpenAjax._cleanup = [];
- OpenAjax._subIndex = 0;
- OpenAjax._pubDepth = 0;
- };
- };
-
- // Register the OpenAjax Hub itself as a library.
- OpenAjax.hub.registerLibrary("OpenAjax", "http://openajax.org/hub", "0.6", {});
-
-}
diff --git a/lib/dojo/README.md b/lib/dojo/README.md
deleted file mode 100644
index 5eb5ac3..0000000
--- a/lib/dojo/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# dojo
-
-**dojo** is the foundation package of the Dojo Toolkit. Sometimes referred to as the “core”, it contains the most
-generally applicable sub-packages and modules. The dojo package covers a wide range of functionality like AJAX, DOM
-manipulation, class-type programming, events, promises, data stores, drag-and-drop and internationalization libraries.
-
-## Installing
-
-Installation instructions are available at [dojotoolkit.org/download][download].
-
-## Getting Started
-
-If you are starting out with Dojo, the following resources are available to you:
-
-* [Tutorials][]
-* [Reference Guide][]
-* [API Documentation][]
-* [Community Forum][]
-
-## License and Copyright
-
-The Dojo Toolkit (including this package) is dual licensed under BSD 3-Clause and AFL. For more information on the
-license please see the [License Information][]. The Dojo Toolkit is Copyright (c) 2005-2013, The Dojo Foundation. All
-rights reserved.
-
-[download]: http://dojotoolkit.org/download/
-[Tutorials]: http://dojotoolkit.org/documentation/
-[Reference Guide]: http://dojotoolkit.org/reference-guide/
-[API Documentation]: http://dojotoolkit.org/api/
-[Community Forum]: http://dojotoolkit.org/community/
-[License Information]: http://dojotoolkit.org/license
\ No newline at end of file
diff --git a/lib/dojo/Stateful.js b/lib/dojo/Stateful.js
deleted file mode 100644
index cee48d0..0000000
--- a/lib/dojo/Stateful.js
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/Stateful",["./_base/declare","./_base/lang","./_base/array","./when"],function(_1,_2,_3,_4){
-return _1("dojo.Stateful",null,{_attrPairNames:{},_getAttrNames:function(_5){
-var _6=this._attrPairNames;
-if(_6[_5]){
-return _6[_5];
-}
-return (_6[_5]={s:"_"+_5+"Setter",g:"_"+_5+"Getter"});
-},postscript:function(_7){
-if(_7){
-this.set(_7);
-}
-},_get:function(_8,_9){
-return typeof this[_9.g]==="function"?this[_9.g]():this[_8];
-},get:function(_a){
-return this._get(_a,this._getAttrNames(_a));
-},set:function(_b,_c){
-if(typeof _b==="object"){
-for(var x in _b){
-if(_b.hasOwnProperty(x)&&x!="_watchCallbacks"){
-this.set(x,_b[x]);
-}
-}
-return this;
-}
-var _d=this._getAttrNames(_b),_e=this._get(_b,_d),_f=this[_d.s],_10;
-if(typeof _f==="function"){
-_10=_f.apply(this,Array.prototype.slice.call(arguments,1));
-}else{
-this[_b]=_c;
-}
-if(this._watchCallbacks){
-var _11=this;
-_4(_10,function(){
-_11._watchCallbacks(_b,_e,_c);
-});
-}
-return this;
-},_changeAttrValue:function(_12,_13){
-var _14=this.get(_12);
-this[_12]=_13;
-if(this._watchCallbacks){
-this._watchCallbacks(_12,_14,_13);
-}
-return this;
-},watch:function(_15,_16){
-var _17=this._watchCallbacks;
-if(!_17){
-var _18=this;
-_17=this._watchCallbacks=function(_19,_1a,_1b,_1c){
-var _1d=function(_1e){
-if(_1e){
-_1e=_1e.slice();
-for(var i=0,l=_1e.length;i-1){
-_1f.splice(_21,1);
-}
-};
-return _20;
-}});
-});
diff --git a/lib/dojo/Stateful.js.uncompressed.js b/lib/dojo/Stateful.js.uncompressed.js
deleted file mode 100644
index ad8cbb6..0000000
--- a/lib/dojo/Stateful.js.uncompressed.js
+++ /dev/null
@@ -1,218 +0,0 @@
-define("dojo/Stateful", ["./_base/declare", "./_base/lang", "./_base/array", "./when"], function(declare, lang, array, when){
- // module:
- // dojo/Stateful
-
-return declare("dojo.Stateful", null, {
- // summary:
- // Base class for objects that provide named properties with optional getter/setter
- // control and the ability to watch for property changes
- //
- // The class also provides the functionality to auto-magically manage getters
- // and setters for object attributes/properties.
- //
- // Getters and Setters should follow the format of _xxxGetter or _xxxSetter where
- // the xxx is a name of the attribute to handle. So an attribute of "foo"
- // would have a custom getter of _fooGetter and a custom setter of _fooSetter.
- //
- // example:
- // | require(["dojo/Stateful", function(Stateful) {
- // | var obj = new Stateful();
- // | obj.watch("foo", function(){
- // | console.log("foo changed to " + this.get("foo"));
- // | });
- // | obj.set("foo","bar");
- // | });
-
- // _attrPairNames: Hash
- // Used across all instances a hash to cache attribute names and their getter
- // and setter names.
- _attrPairNames: {},
-
- _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]; }
- return (apn[name] = {
- s: "_" + name + "Setter",
- g: "_" + name + "Getter"
- });
- },
-
- postscript: function(/*Object?*/ params){
- // Automatic setting of params during construction
- if (params){ this.set(params); }
- },
-
- _get: function(name, names){
- // summary:
- // Private function that does a get based off a hash of names
- // names:
- // Hash of names of custom attributes
- return typeof this[names.g] === "function" ? this[names.g]() : this[name];
- },
- get: function(/*String*/name){
- // summary:
- // Get a property on a Stateful instance.
- // name:
- // The property to get.
- // returns:
- // The property value on this Stateful instance.
- // description:
- // Get a named property on a Stateful object. The property may
- // potentially be retrieved via a getter method in subclasses. In the base class
- // this just retrieves the object's property.
- // example:
- // | require(["dojo/Stateful", function(Stateful) {
- // | var stateful = new Stateful({foo: 3});
- // | stateful.get("foo") // returns 3
- // | stateful.foo // returns 3
- // | });
-
- return this._get(name, this._getAttrNames(name)); //Any
- },
- set: function(/*String*/name, /*Object*/value){
- // summary:
- // Set a property on a Stateful instance
- // name:
- // The property to set.
- // value:
- // The value to set in the property.
- // returns:
- // The function returns this dojo.Stateful instance.
- // description:
- // Sets named properties on a stateful object and notifies any watchers of
- // the property. A programmatic setter may be defined in subclasses.
- // example:
- // | require(["dojo/Stateful", function(Stateful) {
- // | var stateful = new Stateful();
- // | stateful.watch(function(name, oldValue, value){
- // | // this will be called on the set below
- // | }
- // | stateful.set(foo, 5);
- // set() may also be called with a hash of name/value pairs, ex:
- // | stateful.set({
- // | foo: "Howdy",
- // | bar: 3
- // | });
- // | });
- // This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
-
- // If an object is used, iterate through object
- if(typeof name === "object"){
- for(var x in name){
- if(name.hasOwnProperty(x) && x !="_watchCallbacks"){
- this.set(x, name[x]);
- }
- }
- return this;
- }
-
- var names = this._getAttrNames(name),
- oldValue = this._get(name, names),
- setter = this[names.s],
- result;
- if(typeof setter === "function"){
- // use the explicit setter
- result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
- }else{
- // no setter so set attribute directly
- this[name] = value;
- }
- if(this._watchCallbacks){
- var self = this;
- // If setter returned a promise, wait for it to complete, otherwise call watches immediately
- when(result, function(){
- self._watchCallbacks(name, oldValue, value);
- });
- }
- return this; // dojo/Stateful
- },
- _changeAttrValue: function(name, value){
- // summary:
- // Internal helper for directly changing an attribute value.
- //
- // name: String
- // The property to set.
- // value: Mixed
- // The value to set in the property.
- //
- // description:
- // Directly change the value of an attribute on an object, bypassing any
- // accessor setter. Also handles the calling of watch and emitting events.
- // It is designed to be used by descendant class when there are two values
- // of attributes that are linked, but calling .set() is not appropriate.
-
- var oldValue = this.get(name);
- this[name] = value;
- if(this._watchCallbacks){
- this._watchCallbacks(name, oldValue, value);
- }
- return this; // dojo/Stateful
- },
- watch: function(/*String?*/name, /*Function*/callback){
- // summary:
- // Watches a property for changes
- // name:
- // Indicates the property to watch. This is optional (the callback may be the
- // only parameter), and if omitted, all the properties will be watched
- // returns:
- // An object handle for the watch. The unwatch method of this object
- // can be used to discontinue watching this property:
- // | var watchHandle = obj.watch("foo", callback);
- // | watchHandle.unwatch(); // callback won't be called now
- // callback:
- // The function to execute when the property changes. This will be called after
- // the property has been changed. The callback will be called with the |this|
- // set to the instance, the first argument as the name of the property, the
- // second argument as the old value and the third argument as the new value.
-
- var callbacks = this._watchCallbacks;
- if(!callbacks){
- var self = this;
- callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
- var notify = function(propertyCallbacks){
- if(propertyCallbacks){
- propertyCallbacks = propertyCallbacks.slice();
- for(var i = 0, l = propertyCallbacks.length; i < l; i++){
- propertyCallbacks[i].call(self, name, oldValue, value);
- }
- }
- };
- notify(callbacks['_' + name]);
- if(!ignoreCatchall){
- notify(callbacks["*"]); // the catch-all
- }
- }; // we use a function instead of an object so it will be ignored by JSON conversion
- }
- if(!callback && typeof name === "function"){
- callback = name;
- name = "*";
- }else{
- // prepend with dash to prevent name conflicts with function (like "name" property)
- name = '_' + name;
- }
- var propertyCallbacks = callbacks[name];
- if(typeof propertyCallbacks !== "object"){
- propertyCallbacks = callbacks[name] = [];
- }
- propertyCallbacks.push(callback);
-
- // TODO: Remove unwatch in 2.0
- var handle = {};
- handle.unwatch = handle.remove = function(){
- var index = array.indexOf(propertyCallbacks, callback);
- if(index > -1){
- propertyCallbacks.splice(index, 1);
- }
- };
- return handle; //Object
- }
-
-});
-
-});
diff --git a/lib/dojo/_base/Color.js b/lib/dojo/_base/Color.js
deleted file mode 100644
index e16aeb1..0000000
--- a/lib/dojo/_base/Color.js
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/Color",["./kernel","./lang","./array","./config"],function(_1,_2,_3,_4){
-var _5=_1.Color=function(_6){
-if(_6){
-this.setColor(_6);
-}
-};
-_5.named={"black":[0,0,0],"silver":[192,192,192],"gray":[128,128,128],"white":[255,255,255],"maroon":[128,0,0],"red":[255,0,0],"purple":[128,0,128],"fuchsia":[255,0,255],"green":[0,128,0],"lime":[0,255,0],"olive":[128,128,0],"yellow":[255,255,0],"navy":[0,0,128],"blue":[0,0,255],"teal":[0,128,128],"aqua":[0,255,255],"transparent":_4.transparentColor||[0,0,0,0]};
-_2.extend(_5,{r:255,g:255,b:255,a:1,_set:function(r,g,b,a){
-var t=this;
-t.r=r;
-t.g=g;
-t.b=b;
-t.a=a;
-},setColor:function(_7){
-if(_2.isString(_7)){
-_5.fromString(_7,this);
-}else{
-if(_2.isArray(_7)){
-_5.fromArray(_7,this);
-}else{
-this._set(_7.r,_7.g,_7.b,_7.a);
-if(!(_7 instanceof _5)){
-this.sanitize();
-}
-}
-}
-return this;
-},sanitize:function(){
-return this;
-},toRgb:function(){
-var t=this;
-return [t.r,t.g,t.b];
-},toRgba:function(){
-var t=this;
-return [t.r,t.g,t.b,t.a];
-},toHex:function(){
-var _8=_3.map(["r","g","b"],function(x){
-var s=this[x].toString(16);
-return s.length<2?"0"+s:s;
-},this);
-return "#"+_8.join("");
-},toCss:function(_9){
-var t=this,_a=t.r+", "+t.g+", "+t.b;
-return (_9?"rgba("+_a+", "+t.a:"rgb("+_a)+")";
-},toString:function(){
-return this.toCss(true);
-}});
-_5.blendColors=_1.blendColors=function(_b,_c,_d,_e){
-var t=_e||new _5();
-_3.forEach(["r","g","b","a"],function(x){
-t[x]=_b[x]+(_c[x]-_b[x])*_d;
-if(x!="a"){
-t[x]=Math.round(t[x]);
-}
-});
-return t.sanitize();
-};
-_5.fromRgb=_1.colorFromRgb=function(_f,obj){
-var m=_f.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
-return m&&_5.fromArray(m[1].split(/\s*,\s*/),obj);
-};
-_5.fromHex=_1.colorFromHex=function(_10,obj){
-var t=obj||new _5(),_11=(_10.length==4)?4:8,_12=(1<<_11)-1;
-_10=Number("0x"+_10.substr(1));
-if(isNaN(_10)){
-return null;
-}
-_3.forEach(["b","g","r"],function(x){
-var c=_10&_12;
-_10>>=_11;
-t[x]=_11==4?17*c:c;
-});
-t.a=1;
-return t;
-};
-_5.fromArray=_1.colorFromArray=function(a,obj){
-var t=obj||new _5();
-t._set(Number(a[0]),Number(a[1]),Number(a[2]),Number(a[3]));
-if(isNaN(t.a)){
-t.a=1;
-}
-return t.sanitize();
-};
-_5.fromString=_1.colorFromString=function(str,obj){
-var a=_5.named[str];
-return a&&_5.fromArray(a,obj)||_5.fromRgb(str,obj)||_5.fromHex(str,obj);
-};
-return _5;
-});
diff --git a/lib/dojo/_base/Color.js.uncompressed.js b/lib/dojo/_base/Color.js.uncompressed.js
deleted file mode 100644
index 52eeb63..0000000
--- a/lib/dojo/_base/Color.js.uncompressed.js
+++ /dev/null
@@ -1,229 +0,0 @@
-define("dojo/_base/Color", ["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){
-
- var Color = dojo.Color = function(/*Array|String|Object*/ color){
- // summary:
- // Takes a named string, hex string, array of rgb or rgba values,
- // an object with r, g, b, and a properties, or another `Color` object
- // and creates a new Color instance to work from.
- //
- // example:
- // Work with a Color instance:
- // | require(["dojo/_base/color"], function(Color){
- // | var c = new Color();
- // | c.setColor([0,0,0]); // black
- // | var hex = c.toHex(); // #000000
- // | });
- //
- // example:
- // Work with a node's color:
- // |
- // | require(["dojo/_base/color", "dojo/dom-style"], function(Color, domStyle){
- // | var color = domStyle("someNode", "backgroundColor");
- // | var n = new Color(color);
- // | // adjust the color some
- // | n.r *= .5;
- // | console.log(n.toString()); // rgb(128, 255, 255);
- // | });
- if(color){ this.setColor(color); }
- };
-
- // FIXME:
- // there's got to be a more space-efficient way to encode or discover
- // these!! Use hex?
- Color.named = {
- // summary:
- // Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
- "black": [0,0,0],
- "silver": [192,192,192],
- "gray": [128,128,128],
- "white": [255,255,255],
- "maroon": [128,0,0],
- "red": [255,0,0],
- "purple": [128,0,128],
- "fuchsia":[255,0,255],
- "green": [0,128,0],
- "lime": [0,255,0],
- "olive": [128,128,0],
- "yellow": [255,255,0],
- "navy": [0,0,128],
- "blue": [0,0,255],
- "teal": [0,128,128],
- "aqua": [0,255,255],
- "transparent": config.transparentColor || [0,0,0,0]
- };
-
- lang.extend(Color, {
- r: 255, g: 255, b: 255, a: 1,
- _set: function(r, g, b, a){
- var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
- },
- setColor: function(/*Array|String|Object*/ color){
- // summary:
- // Takes a named string, hex string, array of rgb or rgba values,
- // an object with r, g, b, and a properties, or another `Color` object
- // and sets this color instance to that value.
- //
- // example:
- // | require(["dojo/_base/color"], function(Color){
- // | var c = new Color(); // no color
- // | c.setColor("#ededed"); // greyish
- // | });
- if(lang.isString(color)){
- Color.fromString(color, this);
- }else if(lang.isArray(color)){
- Color.fromArray(color, this);
- }else{
- this._set(color.r, color.g, color.b, color.a);
- if(!(color instanceof Color)){ this.sanitize(); }
- }
- return this; // Color
- },
- sanitize: function(){
- // summary:
- // Ensures the object has correct attributes
- // description:
- // the default implementation does nothing, include dojo.colors to
- // augment it with real checks
- return this; // Color
- },
- toRgb: function(){
- // summary:
- // Returns 3 component array of rgb values
- // example:
- // | require(["dojo/_base/color"], function(Color){
- // | var c = new Color("#000000");
- // | console.log(c.toRgb()); // [0,0,0]
- // | });
- var t = this;
- return [t.r, t.g, t.b]; // Array
- },
- toRgba: function(){
- // summary:
- // Returns a 4 component array of rgba values from the color
- // represented by this object.
- var t = this;
- return [t.r, t.g, t.b, t.a]; // Array
- },
- toHex: function(){
- // summary:
- // Returns a CSS color string in hexadecimal representation
- // example:
- // | require(["dojo/_base/color"], function(Color){
- // | console.log(new Color([0,0,0]).toHex()); // #000000
- // | });
- var arr = ArrayUtil.map(["r", "g", "b"], function(x){
- var s = this[x].toString(16);
- return s.length < 2 ? "0" + s : s;
- }, this);
- return "#" + arr.join(""); // String
- },
- toCss: function(/*Boolean?*/ includeAlpha){
- // summary:
- // Returns a css color string in rgb(a) representation
- // example:
- // | require(["dojo/_base/color"], function(Color){
- // | var c = new Color("#FFF").toCss();
- // | console.log(c); // rgb('255','255','255')
- // | });
- var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
- return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")"; // String
- },
- toString: function(){
- // summary:
- // Returns a visual representation of the color
- return this.toCss(true); // String
- }
- });
-
- Color.blendColors = dojo.blendColors = function(
- /*Color*/ start,
- /*Color*/ end,
- /*Number*/ weight,
- /*Color?*/ obj
- ){
- // summary:
- // Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
- // can reuse a previously allocated Color object for the result
- var t = obj || new Color();
- ArrayUtil.forEach(["r", "g", "b", "a"], function(x){
- t[x] = start[x] + (end[x] - start[x]) * weight;
- if(x != "a"){ t[x] = Math.round(t[x]); }
- });
- return t.sanitize(); // Color
- };
-
- Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*Color?*/ obj){
- // summary:
- // Returns a `Color` instance from a string of the form
- // "rgb(...)" or "rgba(...)". Optionally accepts a `Color`
- // object to update with the parsed value and return instead of
- // creating a new object.
- // returns:
- // A Color object. If obj is passed, it will be the return value.
- var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
- return m && Color.fromArray(m[1].split(/\s*,\s*/), obj); // Color
- };
-
- Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*Color?*/ obj){
- // summary:
- // Converts a hex string with a '#' prefix to a color object.
- // Supports 12-bit #rgb shorthand. Optionally accepts a
- // `Color` object to update with the parsed value.
- //
- // returns:
- // A Color object. If obj is passed, it will be the return value.
- //
- // example:
- // | require(["dojo/_base/color"], function(Color){
- // | var thing = new Color().fromHex("#ededed"); // grey, longhand
- // | var thing2 = new Color().fromHex("#000"); // black, shorthand
- // | });
- var t = obj || new Color(),
- bits = (color.length == 4) ? 4 : 8,
- mask = (1 << bits) - 1;
- color = Number("0x" + color.substr(1));
- if(isNaN(color)){
- return null; // Color
- }
- ArrayUtil.forEach(["b", "g", "r"], function(x){
- var c = color & mask;
- color >>= bits;
- t[x] = bits == 4 ? 17 * c : c;
- });
- t.a = 1;
- return t; // Color
- };
-
- Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*Color?*/ obj){
- // summary:
- // Builds a `Color` from a 3 or 4 element array, mapping each
- // element in sequence to the rgb(a) values of the color.
- // example:
- // | require(["dojo/_base/color"], function(Color){
- // | var myColor = new Color().fromArray([237,237,237,0.5]); // grey, 50% alpha
- // | });
- // returns:
- // A Color object. If obj is passed, it will be the return value.
- var t = obj || new Color();
- t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
- if(isNaN(t.a)){ t.a = 1; }
- return t.sanitize(); // Color
- };
-
- Color.fromString = dojo.colorFromString = function(/*String*/ str, /*Color?*/ obj){
- // summary:
- // Parses `str` for a color value. Accepts hex, rgb, and rgba
- // style color values.
- // description:
- // Acceptable input values for str may include arrays of any form
- // accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
- // rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
- // 10, 50)"
- // returns:
- // A Color object. If obj is passed, it will be the return value.
- var a = Color.named[str];
- return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj); // Color
- };
-
- return Color;
-});
diff --git a/lib/dojo/_base/Deferred.js b/lib/dojo/_base/Deferred.js
deleted file mode 100644
index 6d7b2d5..0000000
--- a/lib/dojo/_base/Deferred.js
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/Deferred",["./kernel","../Deferred","../promise/Promise","../errors/CancelError","../has","./lang","../when"],function(_1,_2,_3,_4,_5,_6,_7){
-var _8=function(){
-};
-var _9=Object.freeze||function(){
-};
-var _a=_1.Deferred=function(_b){
-var _c,_d,_e,_f,_10,_11,_12;
-var _13=(this.promise=new _3());
-function _14(_15){
-if(_d){
-throw new Error("This deferred has already been resolved");
-}
-_c=_15;
-_d=true;
-_16();
-};
-function _16(){
-var _17;
-while(!_17&&_12){
-var _18=_12;
-_12=_12.next;
-if((_17=(_18.progress==_8))){
-_d=false;
-}
-var _19=(_10?_18.error:_18.resolved);
-if(_5("config-useDeferredInstrumentation")){
-if(_10&&_2.instrumentRejected){
-_2.instrumentRejected(_c,!!_19);
-}
-}
-if(_19){
-try{
-var _1a=_19(_c);
-if(_1a&&typeof _1a.then==="function"){
-_1a.then(_6.hitch(_18.deferred,"resolve"),_6.hitch(_18.deferred,"reject"),_6.hitch(_18.deferred,"progress"));
-continue;
-}
-var _1b=_17&&_1a===undefined;
-if(_17&&!_1b){
-_10=_1a instanceof Error;
-}
-_18.deferred[_1b&&_10?"reject":"resolve"](_1b?_c:_1a);
-}
-catch(e){
-_18.deferred.reject(e);
-}
-}else{
-if(_10){
-_18.deferred.reject(_c);
-}else{
-_18.deferred.resolve(_c);
-}
-}
-}
-};
-this.isResolved=_13.isResolved=function(){
-return _f==0;
-};
-this.isRejected=_13.isRejected=function(){
-return _f==1;
-};
-this.isFulfilled=_13.isFulfilled=function(){
-return _f>=0;
-};
-this.isCanceled=_13.isCanceled=function(){
-return _e;
-};
-this.resolve=this.callback=function(_1c){
-this.fired=_f=0;
-this.results=[_1c,null];
-_14(_1c);
-};
-this.reject=this.errback=function(_1d){
-_10=true;
-this.fired=_f=1;
-if(_5("config-useDeferredInstrumentation")){
-if(_2.instrumentRejected){
-_2.instrumentRejected(_1d,!!_12);
-}
-}
-_14(_1d);
-this.results=[null,_1d];
-};
-this.progress=function(_1e){
-var _1f=_12;
-while(_1f){
-var _20=_1f.progress;
-_20&&_20(_1e);
-_1f=_1f.next;
-}
-};
-this.addCallbacks=function(_21,_22){
-this.then(_21,_22,_8);
-return this;
-};
-_13.then=this.then=function(_23,_24,_25){
-var _26=_25==_8?this:new _a(_13.cancel);
-var _27={resolved:_23,error:_24,progress:_25,deferred:_26};
-if(_12){
-_11=_11.next=_27;
-}else{
-_12=_11=_27;
-}
-if(_d){
-_16();
-}
-return _26.promise;
-};
-var _28=this;
-_13.cancel=this.cancel=function(){
-if(!_d){
-var _29=_b&&_b(_28);
-if(!_d){
-if(!(_29 instanceof Error)){
-_29=new _4(_29);
-}
-_29.log=false;
-_28.reject(_29);
-}
-}
-_e=true;
-};
-_9(_13);
-};
-_6.extend(_a,{addCallback:function(_2a){
-return this.addCallbacks(_6.hitch.apply(_1,arguments));
-},addErrback:function(_2b){
-return this.addCallbacks(null,_6.hitch.apply(_1,arguments));
-},addBoth:function(_2c){
-var _2d=_6.hitch.apply(_1,arguments);
-return this.addCallbacks(_2d,_2d);
-},fired:-1});
-_a.when=_1.when=_7;
-return _a;
-});
diff --git a/lib/dojo/_base/Deferred.js.uncompressed.js b/lib/dojo/_base/Deferred.js.uncompressed.js
deleted file mode 100644
index 45800cf..0000000
--- a/lib/dojo/_base/Deferred.js.uncompressed.js
+++ /dev/null
@@ -1,383 +0,0 @@
-define("dojo/_base/Deferred", [
- "./kernel",
- "../Deferred",
- "../promise/Promise",
- "../errors/CancelError",
- "../has",
- "./lang",
- "../when"
-], function(dojo, NewDeferred, Promise, CancelError, has, lang, when){
- // module:
- // dojo/_base/Deferred
-
- var mutator = function(){};
- var freeze = Object.freeze || function(){};
- // A deferred provides an API for creating and resolving a promise.
- var Deferred = dojo.Deferred = function(/*Function?*/ canceller){
- // summary:
- // Deprecated. This module defines the legacy dojo/_base/Deferred API.
- // New code should use dojo/Deferred instead.
- // description:
- // The Deferred API is based on the concept of promises that provide a
- // generic interface into the eventual completion of an asynchronous action.
- // The motivation for promises fundamentally is about creating a
- // separation of concerns that allows one to achieve the same type of
- // call patterns and logical data flow in asynchronous code as can be
- // achieved in synchronous code. Promises allows one
- // to be able to call a function purely with arguments needed for
- // execution, without conflating the call with concerns of whether it is
- // sync or async. One shouldn't need to alter a call's arguments if the
- // implementation switches from sync to async (or vice versa). By having
- // async functions return promises, the concerns of making the call are
- // separated from the concerns of asynchronous interaction (which are
- // handled by the promise).
- //
- // The Deferred is a type of promise that provides methods for fulfilling the
- // promise with a successful result or an error. The most important method for
- // working with Dojo's promises is the then() method, which follows the
- // CommonJS proposed promise API. An example of using a Dojo promise:
- //
- // | var resultingPromise = someAsyncOperation.then(function(result){
- // | ... handle result ...
- // | },
- // | function(error){
- // | ... handle error ...
- // | });
- //
- // The .then() call returns a new promise that represents the result of the
- // execution of the callback. The callbacks will never affect the original promises value.
- //
- // The Deferred instances also provide the following functions for backwards compatibility:
- //
- // - addCallback(handler)
- // - addErrback(handler)
- // - callback(result)
- // - errback(result)
- //
- // Callbacks are allowed to return promises themselves, so
- // you can build complicated sequences of events with ease.
- //
- // The creator of the Deferred may specify a canceller. The canceller
- // is a function that will be called if Deferred.cancel is called
- // before the Deferred fires. You can use this to implement clean
- // aborting of an XMLHttpRequest, etc. Note that cancel will fire the
- // deferred with a CancelledError (unless your canceller returns
- // another kind of error), so the errbacks should be prepared to
- // handle that error for cancellable Deferreds.
- // example:
- // | var deferred = new Deferred();
- // | setTimeout(function(){ deferred.callback({success: true}); }, 1000);
- // | return deferred;
- // example:
- // Deferred objects are often used when making code asynchronous. It
- // may be easiest to write functions in a synchronous manner and then
- // split code using a deferred to trigger a response to a long-lived
- // operation. For example, instead of register a callback function to
- // denote when a rendering operation completes, the function can
- // simply return a deferred:
- //
- // | // callback style:
- // | function renderLotsOfData(data, callback){
- // | var success = false
- // | try{
- // | for(var x in data){
- // | renderDataitem(data[x]);
- // | }
- // | success = true;
- // | }catch(e){ }
- // | if(callback){
- // | callback(success);
- // | }
- // | }
- //
- // | // using callback style
- // | renderLotsOfData(someDataObj, function(success){
- // | // handles success or failure
- // | if(!success){
- // | promptUserToRecover();
- // | }
- // | });
- // | // NOTE: no way to add another callback here!!
- // example:
- // Using a Deferred doesn't simplify the sending code any, but it
- // provides a standard interface for callers and senders alike,
- // providing both with a simple way to service multiple callbacks for
- // an operation and freeing both sides from worrying about details
- // such as "did this get called already?". With Deferreds, new
- // callbacks can be added at any time.
- //
- // | // Deferred style:
- // | function renderLotsOfData(data){
- // | var d = new Deferred();
- // | try{
- // | for(var x in data){
- // | renderDataitem(data[x]);
- // | }
- // | d.callback(true);
- // | }catch(e){
- // | d.errback(new Error("rendering failed"));
- // | }
- // | return d;
- // | }
- //
- // | // using Deferred style
- // | renderLotsOfData(someDataObj).then(null, function(){
- // | promptUserToRecover();
- // | });
- // | // NOTE: addErrback and addCallback both return the Deferred
- // | // again, so we could chain adding callbacks or save the
- // | // deferred for later should we need to be notified again.
- // example:
- // In this example, renderLotsOfData is synchronous and so both
- // versions are pretty artificial. Putting the data display on a
- // timeout helps show why Deferreds rock:
- //
- // | // Deferred style and async func
- // | function renderLotsOfData(data){
- // | var d = new Deferred();
- // | setTimeout(function(){
- // | try{
- // | for(var x in data){
- // | renderDataitem(data[x]);
- // | }
- // | d.callback(true);
- // | }catch(e){
- // | d.errback(new Error("rendering failed"));
- // | }
- // | }, 100);
- // | return d;
- // | }
- //
- // | // using Deferred style
- // | renderLotsOfData(someDataObj).then(null, function(){
- // | promptUserToRecover();
- // | });
- //
- // Note that the caller doesn't have to change his code at all to
- // handle the asynchronous case.
-
- var result, finished, canceled, fired, isError, head, nextListener;
- var promise = (this.promise = new Promise());
-
- function complete(value){
- if(finished){
- throw new Error("This deferred has already been resolved");
- }
- result = value;
- finished = true;
- notify();
- }
- function notify(){
- var mutated;
- while(!mutated && nextListener){
- var listener = nextListener;
- nextListener = nextListener.next;
- if((mutated = (listener.progress == mutator))){ // assignment and check
- finished = false;
- }
-
- var func = (isError ? listener.error : listener.resolved);
- if(has("config-useDeferredInstrumentation")){
- if(isError && NewDeferred.instrumentRejected){
- NewDeferred.instrumentRejected(result, !!func);
- }
- }
- if(func){
- try{
- var newResult = func(result);
- if (newResult && typeof newResult.then === "function"){
- newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
- continue;
- }
- var unchanged = mutated && newResult === undefined;
- if(mutated && !unchanged){
- isError = newResult instanceof Error;
- }
- listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
- }catch(e){
- listener.deferred.reject(e);
- }
- }else{
- if(isError){
- listener.deferred.reject(result);
- }else{
- listener.deferred.resolve(result);
- }
- }
- }
- }
-
- this.isResolved = promise.isResolved = function(){
- // summary:
- // Checks whether the deferred has been resolved.
- // returns: Boolean
-
- return fired == 0;
- };
-
- this.isRejected = promise.isRejected = function(){
- // summary:
- // Checks whether the deferred has been rejected.
- // returns: Boolean
-
- return fired == 1;
- };
-
- this.isFulfilled = promise.isFulfilled = function(){
- // summary:
- // Checks whether the deferred has been resolved or rejected.
- // returns: Boolean
-
- return fired >= 0;
- };
-
- this.isCanceled = promise.isCanceled = function(){
- // summary:
- // Checks whether the deferred has been canceled.
- // returns: Boolean
-
- return canceled;
- };
-
- // calling resolve will resolve the promise
- this.resolve = this.callback = function(value){
- // summary:
- // Fulfills the Deferred instance successfully with the provide value
- this.fired = fired = 0;
- this.results = [value, null];
- complete(value);
- };
-
-
- // calling error will indicate that the promise failed
- this.reject = this.errback = function(error){
- // summary:
- // Fulfills the Deferred instance as an error with the provided error
- isError = true;
- this.fired = fired = 1;
- if(has("config-useDeferredInstrumentation")){
- if(NewDeferred.instrumentRejected){
- NewDeferred.instrumentRejected(error, !!nextListener);
- }
- }
- complete(error);
- this.results = [null, error];
- };
- // call progress to provide updates on the progress on the completion of the promise
- this.progress = function(update){
- // summary:
- // Send progress events to all listeners
- var listener = nextListener;
- while(listener){
- var progress = listener.progress;
- progress && progress(update);
- listener = listener.next;
- }
- };
- this.addCallbacks = function(callback, errback){
- // summary:
- // Adds callback and error callback for this deferred instance.
- // callback: Function?
- // The callback attached to this deferred object.
- // errback: Function?
- // The error callback attached to this deferred object.
- // returns:
- // Returns this deferred object.
- this.then(callback, errback, mutator);
- return this; // Deferred
- };
- // provide the implementation of the promise
- promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
- // summary:
- // Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
- // completion of a promise. The fulfilledHandler is called when the promise
- // is fulfilled. The errorHandler is called when a promise fails. The
- // progressHandler is called for progress events. All arguments are optional
- // and non-function values are ignored. The progressHandler is not only an
- // optional argument, but progress events are purely optional. Promise
- // providers are not required to ever create progress events.
- //
- // This function will return a new promise that is fulfilled when the given
- // fulfilledHandler or errorHandler callback is finished. This allows promise
- // operations to be chained together. The value returned from the callback
- // handler is the fulfillment value for the returned promise. If the callback
- // throws an error, the returned promise will be moved to failed state.
- //
- // returns:
- // Returns a new promise that represents the result of the
- // execution of the callback. The callbacks will never affect the original promises value.
- // example:
- // An example of using a CommonJS compliant promise:
- // | asyncComputeTheAnswerToEverything().
- // | then(addTwo).
- // | then(printResult, onError);
- // | >44
- //
- var returnDeferred = progressCallback == mutator ? this : new Deferred(promise.cancel);
- var listener = {
- resolved: resolvedCallback,
- error: errorCallback,
- progress: progressCallback,
- deferred: returnDeferred
- };
- if(nextListener){
- head = head.next = listener;
- }
- else{
- nextListener = head = listener;
- }
- if(finished){
- notify();
- }
- return returnDeferred.promise; // Promise
- };
- var deferred = this;
- promise.cancel = this.cancel = function(){
- // summary:
- // Cancels the asynchronous operation
- if(!finished){
- var error = canceller && canceller(deferred);
- if(!finished){
- if (!(error instanceof Error)){
- error = new CancelError(error);
- }
- error.log = false;
- deferred.reject(error);
- }
- }
- canceled = true;
- };
- freeze(promise);
- };
- lang.extend(Deferred, {
- addCallback: function(/*Function*/ callback){
- // summary:
- // Adds successful callback for this deferred instance.
- // returns:
- // Returns this deferred object.
- return this.addCallbacks(lang.hitch.apply(dojo, arguments)); // Deferred
- },
-
- addErrback: function(/*Function*/ errback){
- // summary:
- // Adds error callback for this deferred instance.
- // returns:
- // Returns this deferred object.
- return this.addCallbacks(null, lang.hitch.apply(dojo, arguments)); // Deferred
- },
-
- addBoth: function(/*Function*/ callback){
- // summary:
- // Add handler as both successful callback and error callback for this deferred instance.
- // returns:
- // Returns this deferred object.
- var enclosed = lang.hitch.apply(dojo, arguments);
- return this.addCallbacks(enclosed, enclosed); // Deferred
- },
- fired: -1
- });
-
- Deferred.when = dojo.when = when;
-
- return Deferred;
-});
diff --git a/lib/dojo/_base/NodeList.js b/lib/dojo/_base/NodeList.js
deleted file mode 100644
index 4a176ad..0000000
--- a/lib/dojo/_base/NodeList.js
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/NodeList",["./kernel","../query","./array","./html","../NodeList-dom"],function(_1,_2,_3){
-var _4=_2.NodeList,_5=_4.prototype;
-_5.connect=_4._adaptAsForEach(function(){
-return _1.connect.apply(this,arguments);
-});
-_5.coords=_4._adaptAsMap(_1.coords);
-_4.events=["blur","focus","change","click","error","keydown","keypress","keyup","load","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","submit"];
-_3.forEach(_4.events,function(_6){
-var _7="on"+_6;
-_5[_7]=function(a,b){
-return this.connect(_7,a,b);
-};
-});
-_1.NodeList=_4;
-return _4;
-});
diff --git a/lib/dojo/_base/NodeList.js.uncompressed.js b/lib/dojo/_base/NodeList.js.uncompressed.js
deleted file mode 100644
index f9e9070..0000000
--- a/lib/dojo/_base/NodeList.js.uncompressed.js
+++ /dev/null
@@ -1,110 +0,0 @@
-define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
- // module:
- // dojo/_base/NodeList
-
- /*=====
- return {
- // summary:
- // This module extends dojo/NodeList with the legacy connect(), coords(),
- // blur(), focus(), change(), click(), error(), keydown(), keypress(),
- // keyup(), load(), mousedown(), mouseenter(), mouseleave(), mousemove(),
- // mouseout(), mouseover(), mouseup(), and submit() methods.
- };
- =====*/
-
- var NodeList = query.NodeList,
- nlp = NodeList.prototype;
-
- nlp.connect = NodeList._adaptAsForEach(function(){
- // don't bind early to dojo.connect since we no longer explicitly depend on it
- return dojo.connect.apply(this, arguments);
- });
- /*=====
- nlp.connect = function(methodName, objOrFunc, funcName){
- // summary:
- // Attach event handlers to every item of the NodeList. Uses dojo.connect()
- // so event properties are normalized.
- //
- // Application must manually require() "dojo/_base/connect" before using this method.
- // methodName: String
- // the name of the method to attach to. For DOM events, this should be
- // the lower-case name of the event
- // objOrFunc: Object|Function|String
- // if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
- // reference a function or be the name of the function in the global
- // namespace to attach. If 3 arguments are provided
- // (methodName, objOrFunc, funcName), objOrFunc must be the scope to
- // locate the bound function in
- // funcName: String?
- // optional. A string naming the function in objOrFunc to bind to the
- // event. May also be a function reference.
- // example:
- // add an onclick handler to every button on the page
- // | query("div:nth-child(odd)").connect("onclick", function(e){
- // | console.log("clicked!");
- // | });
- // example:
- // attach foo.bar() to every odd div's onmouseover
- // | query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
-
- return null; // NodeList
- };
- =====*/
-
- nlp.coords = NodeList._adaptAsMap(dojo.coords);
- /*=====
- nlp.coords = function(){
- // summary:
- // Deprecated: Use position() for border-box x/y/w/h
- // or marginBox() for margin-box w/h/l/t.
- // Returns the box objects of all elements in a node list as
- // an Array (*not* a NodeList). Acts like `domGeom.coords`, though assumes
- // the node passed is each node in this list.
-
- return []; // Array
- };
- =====*/
-
- NodeList.events = [
- // summary:
- // list of all DOM events used in NodeList
- "blur", "focus", "change", "click", "error", "keydown", "keypress",
- "keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
- "mouseout", "mouseover", "mouseup", "submit"
- ];
-
- // FIXME: pseudo-doc the above automatically generated on-event functions
-
- // syntactic sugar for DOM events
- array.forEach(NodeList.events, function(evt){
- var _oe = "on" + evt;
- nlp[_oe] = function(a, b){
- return this.connect(_oe, a, b);
- };
- // FIXME: should these events trigger publishes?
- /*
- return (a ? this.connect(_oe, a, b) :
- this.forEach(function(n){
- // FIXME:
- // listeners get buried by
- // addEventListener and can't be dug back
- // out to be triggered externally.
- // see:
- // http://developer.mozilla.org/en/docs/DOM:element
-
- console.log(n, evt, _oe);
-
- // FIXME: need synthetic event support!
- var _e = { target: n, faux: true, type: evt };
- // dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
- try{ n[evt](_e); }catch(e){ console.log(e); }
- try{ n[_oe](_e); }catch(e){ console.log(e); }
- })
- );
- */
- }
- );
-
- dojo.NodeList = NodeList;
- return NodeList;
-});
diff --git a/lib/dojo/_base/array.js b/lib/dojo/_base/array.js
deleted file mode 100644
index 65ac6ec..0000000
--- a/lib/dojo/_base/array.js
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/array",["./kernel","../has","./lang"],function(_1,_2,_3){
-var _4={},u;
-function _5(fn){
-return _4[fn]=new Function("item","index","array",fn);
-};
-function _6(_7){
-var _8=!_7;
-return function(a,fn,o){
-var i=0,l=a&&a.length||0,_9;
-if(l&&typeof a=="string"){
-a=a.split("");
-}
-if(typeof fn=="string"){
-fn=_4[fn]||_5(fn);
-}
-if(o){
-for(;i0){
-return _10.lastIndexOf(a,x,_e);
-}
-var l=a&&a.length||0,end=up?l+_d:_c,i;
-if(_e===u){
-i=up?_c:l+_d;
-}else{
-if(_e<0){
-i=l+_e;
-if(i<0){
-i=_c;
-}
-}else{
-i=_e>=l?l+_d:_e;
-}
-}
-if(l&&typeof a=="string"){
-a=a.split("");
-}
-for(;i!=end;i+=_b){
-if(a[i]==x){
-return i;
-}
-}
-return -1;
-};
-};
-var _10={every:_6(false),some:_6(true),indexOf:_a(true),lastIndexOf:_a(false),forEach:function(arr,_11,_12){
-var i=0,l=arr&&arr.length||0;
-if(l&&typeof arr=="string"){
-arr=arr.split("");
-}
-if(typeof _11=="string"){
-_11=_4[_11]||_5(_11);
-}
-if(_12){
-for(;i 0){
- // TODO: why do we use a non-standard signature? why do we need "last"?
- return array.lastIndexOf(a, x, from);
- }
- var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
- if(from === u){
- i = up ? lOver : l + uOver;
- }else{
- if(from < 0){
- i = l + from;
- if(i < 0){
- i = lOver;
- }
- }else{
- i = from >= l ? l + uOver : from;
- }
- }
- if(l && typeof a == "string") a = a.split("");
- for(; i != end; i += delta){
- if(a[i] == x){
- return i; // Number
- }
- }
- return -1; // Number
- };
- }
-
- var array = {
- // summary:
- // The Javascript v1.6 array extensions.
-
- every: everyOrSome(false),
- /*=====
- every: function(arr, callback, thisObject){
- // summary:
- // Determines whether or not every item in arr satisfies the
- // condition implemented by callback.
- // arr: Array|String
- // the array to iterate on. If a string, operates on individual characters.
- // callback: Function|String
- // a function is invoked with three arguments: item, index,
- // and array and returns true if the condition is met.
- // thisObject: Object?
- // may be used to scope the call to callback
- // returns: Boolean
- // description:
- // This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
- // run over sparse arrays, this implementation passes the "holes" in the sparse array to
- // the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
- // For more details, see:
- // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
- // example:
- // | // returns false
- // | array.every([1, 2, 3, 4], function(item){ return item>1; });
- // example:
- // | // returns true
- // | array.every([1, 2, 3, 4], function(item){ return item>0; });
- },
- =====*/
-
- some: everyOrSome(true),
- /*=====
- some: function(arr, callback, thisObject){
- // summary:
- // Determines whether or not any item in arr satisfies the
- // condition implemented by callback.
- // arr: Array|String
- // the array to iterate over. If a string, operates on individual characters.
- // callback: Function|String
- // a function is invoked with three arguments: item, index,
- // and array and returns true if the condition is met.
- // thisObject: Object?
- // may be used to scope the call to callback
- // returns: Boolean
- // description:
- // This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
- // run over sparse arrays, this implementation passes the "holes" in the sparse array to
- // the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
- // For more details, see:
- // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
- // example:
- // | // is true
- // | array.some([1, 2, 3, 4], function(item){ return item>1; });
- // example:
- // | // is false
- // | array.some([1, 2, 3, 4], function(item){ return item<1; });
- },
- =====*/
-
- indexOf: index(true),
- /*=====
- indexOf: function(arr, value, fromIndex, findLast){
- // summary:
- // locates the first index of the provided value in the
- // passed array. If the value is not found, -1 is returned.
- // description:
- // This method corresponds to the JavaScript 1.6 Array.indexOf method, with two differences:
- //
- // 1. when run over sparse arrays, the Dojo function invokes the callback for every index
- // whereas JavaScript 1.6's indexOf skips the holes in the sparse array.
- // 2. uses equality (==) rather than strict equality (===)
- //
- // For details on this method, see:
- // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
- // arr: Array
- // value: Object
- // fromIndex: Integer?
- // findLast: Boolean?
- // Makes indexOf() work like lastIndexOf(). Used internally; not meant for external usage.
- // returns: Number
- },
- =====*/
-
- lastIndexOf: index(false),
- /*=====
- lastIndexOf: function(arr, value, fromIndex){
- // summary:
- // locates the last index of the provided value in the passed
- // array. If the value is not found, -1 is returned.
- // description:
- // This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with two differences:
- //
- // 1. when run over sparse arrays, the Dojo function invokes the callback for every index
- // whereas JavaScript 1.6's lasIndexOf skips the holes in the sparse array.
- // 2. uses equality (==) rather than strict equality (===)
- //
- // For details on this method, see:
- // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
- // arr: Array,
- // value: Object,
- // fromIndex: Integer?
- // returns: Number
- },
- =====*/
-
- forEach: function(arr, callback, thisObject){
- // summary:
- // for every item in arr, callback is invoked. Return values are ignored.
- // If you want to break out of the loop, consider using array.every() or array.some().
- // forEach does not allow breaking out of the loop over the items in arr.
- // arr:
- // the array to iterate over. If a string, operates on individual characters.
- // callback:
- // a function is invoked with three arguments: item, index, and array
- // thisObject:
- // may be used to scope the call to callback
- // description:
- // This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
- // run over sparse arrays, this implementation passes the "holes" in the sparse array to
- // the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
- // For more details, see:
- // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
- // example:
- // | // log out all members of the array:
- // | array.forEach(
- // | [ "thinger", "blah", "howdy", 10 ],
- // | function(item){
- // | console.log(item);
- // | }
- // | );
- // example:
- // | // log out the members and their indexes
- // | array.forEach(
- // | [ "thinger", "blah", "howdy", 10 ],
- // | function(item, idx, arr){
- // | console.log(item, "at index:", idx);
- // | }
- // | );
- // example:
- // | // use a scoped object member as the callback
- // |
- // | var obj = {
- // | prefix: "logged via obj.callback:",
- // | callback: function(item){
- // | console.log(this.prefix, item);
- // | }
- // | };
- // |
- // | // specifying the scope function executes the callback in that scope
- // | array.forEach(
- // | [ "thinger", "blah", "howdy", 10 ],
- // | obj.callback,
- // | obj
- // | );
- // |
- // | // alternately, we can accomplish the same thing with lang.hitch()
- // | array.forEach(
- // | [ "thinger", "blah", "howdy", 10 ],
- // | lang.hitch(obj, "callback")
- // | );
- // arr: Array|String
- // callback: Function|String
- // thisObject: Object?
-
- var i = 0, l = arr && arr.length || 0;
- if(l && typeof arr == "string") arr = arr.split("");
- if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
- if(thisObject){
- for(; i < l; ++i){
- callback.call(thisObject, arr[i], i, arr);
- }
- }else{
- for(; i < l; ++i){
- callback(arr[i], i, arr);
- }
- }
- },
-
- map: function(arr, callback, thisObject, Ctr){
- // summary:
- // applies callback to each element of arr and returns
- // an Array with the results
- // arr: Array|String
- // the array to iterate on. If a string, operates on
- // individual characters.
- // callback: Function|String
- // a function is invoked with three arguments, (item, index,
- // array), and returns a value
- // thisObject: Object?
- // may be used to scope the call to callback
- // returns: Array
- // description:
- // This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
- // run over sparse arrays, this implementation passes the "holes" in the sparse array to
- // the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
- // For more details, see:
- // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
- // example:
- // | // returns [2, 3, 4, 5]
- // | array.map([1, 2, 3, 4], function(item){ return item+1 });
-
- // TODO: why do we have a non-standard signature here? do we need "Ctr"?
- var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l);
- if(l && typeof arr == "string") arr = arr.split("");
- if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
- if(thisObject){
- for(; i < l; ++i){
- out[i] = callback.call(thisObject, arr[i], i, arr);
- }
- }else{
- for(; i < l; ++i){
- out[i] = callback(arr[i], i, arr);
- }
- }
- return out; // Array
- },
-
- filter: function(arr, callback, thisObject){
- // summary:
- // Returns a new Array with those items from arr that match the
- // condition implemented by callback.
- // arr: Array
- // the array to iterate over.
- // callback: Function|String
- // a function that is invoked with three arguments (item,
- // index, array). The return of this function is expected to
- // be a boolean which determines whether the passed-in item
- // will be included in the returned array.
- // thisObject: Object?
- // may be used to scope the call to callback
- // returns: Array
- // description:
- // This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
- // run over sparse arrays, this implementation passes the "holes" in the sparse array to
- // the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
- // For more details, see:
- // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
- // example:
- // | // returns [2, 3, 4]
- // | array.filter([1, 2, 3, 4], function(item){ return item>1; });
-
- // TODO: do we need "Ctr" here like in map()?
- var i = 0, l = arr && arr.length || 0, out = [], value;
- if(l && typeof arr == "string") arr = arr.split("");
- if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
- if(thisObject){
- for(; i < l; ++i){
- value = arr[i];
- if(callback.call(thisObject, value, i, arr)){
- out.push(value);
- }
- }
- }else{
- for(; i < l; ++i){
- value = arr[i];
- if(callback(value, i, arr)){
- out.push(value);
- }
- }
- }
- return out; // Array
- },
-
- clearCache: function(){
- cache = {};
- }
- };
-
-
- 1 && lang.mixin(dojo, array);
-
- return array;
-});
diff --git a/lib/dojo/_base/browser.js b/lib/dojo/_base/browser.js
deleted file mode 100644
index 6ad031c..0000000
--- a/lib/dojo/_base/browser.js
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-if(require.has){
-require.has.add("config-selectorEngine","acme");
-}
-define("dojo/_base/browser",["../ready","./kernel","./connect","./unload","./window","./event","./html","./NodeList","../query","./xhr","./fx"],function(_1){
-return _1;
-});
diff --git a/lib/dojo/_base/browser.js.uncompressed.js b/lib/dojo/_base/browser.js.uncompressed.js
deleted file mode 100644
index 4c607fd..0000000
--- a/lib/dojo/_base/browser.js.uncompressed.js
+++ /dev/null
@@ -1,28 +0,0 @@
-if(require.has){
- require.has.add("config-selectorEngine", "acme");
-}
-define("dojo/_base/browser", [
- "../ready",
- "./kernel",
- "./connect", // until we decide if connect is going back into non-browser environments
- "./unload",
- "./window",
- "./event",
- "./html",
- "./NodeList",
- "../query",
- "./xhr",
- "./fx"], function(dojo){
-
- // module:
- // dojo/_base/browser
-
- /*=====
- return {
- // summary:
- // This module causes the browser-only base modules to be loaded.
- };
- =====*/
-
- return dojo;
-});
diff --git a/lib/dojo/_base/config.js b/lib/dojo/_base/config.js
deleted file mode 100644
index 771a39e..0000000
--- a/lib/dojo/_base/config.js
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/config",["../has","require"],function(_1,_2){
-var _3={};
-if(1){
-var _4=_2.rawConfig,p;
-for(p in _4){
-_3[p]=_4[p];
-}
-}else{
-var _5=function(_6,_7,_8){
-for(p in _6){
-p!="has"&&_1.add(_7+p,_6[p],0,_8);
-}
-};
-_3=1?_2.rawConfig:this.dojoConfig||this.djConfig||{};
-_5(_3,"config",1);
-_5(_3.has,"",1);
-}
-if(!_3.locale&&typeof navigator!="undefined"){
-var _9=(navigator.language||navigator.userLanguage);
-if(_9){
-_3.locale=_9.toLowerCase();
-}
-}
-return _3;
-});
diff --git a/lib/dojo/_base/config.js.uncompressed.js b/lib/dojo/_base/config.js.uncompressed.js
deleted file mode 100644
index def9f69..0000000
--- a/lib/dojo/_base/config.js.uncompressed.js
+++ /dev/null
@@ -1,196 +0,0 @@
-define("dojo/_base/config", ["../has", "require"], function(has, require){
- // module:
- // dojo/_base/config
-
-/*=====
-return {
- // summary:
- // This module defines the user configuration during bootstrap.
- // description:
- // By defining user configuration as a module value, an entire configuration can be specified in a build,
- // thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
- // Also, when multiple instances of dojo exist in a single application, each will necessarily be located
- // at an unique absolute module identifier as given by the package configuration. Implementing configuration
- // as a module allows for specifying unique, per-instance configurations.
- // example:
- // Create a second instance of dojo with a different, instance-unique configuration (assume the loader and
- // dojo.js are already loaded).
- // | // specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
- // | require({
- // | packages:[{
- // | name:"myDojo",
- // | location:".", //assume baseUrl points to dojo.js
- // | }]
- // | });
- // |
- // | // specify a configuration for the myDojo instance
- // | define("myDojo/config", {
- // | // normal configuration variables go here, e.g.,
- // | locale:"fr-ca"
- // | });
- // |
- // | // load and use the new instance of dojo
- // | require(["myDojo"], function(dojo){
- // | // dojo is the new instance of dojo
- // | // use as required
- // | });
-
- // isDebug: Boolean
- // Defaults to `false`. If set to `true`, ensures that Dojo provides
- // extended debugging feedback via Firebug. If Firebug is not available
- // on your platform, setting `isDebug` to `true` will force Dojo to
- // pull in (and display) the version of Firebug Lite which is
- // integrated into the Dojo distribution, thereby always providing a
- // debugging/logging console when `isDebug` is enabled. Note that
- // Firebug's `console.*` methods are ALWAYS defined by Dojo. If
- // `isDebug` is false and you are on a platform without Firebug, these
- // methods will be defined as no-ops.
- isDebug: false,
-
- // locale: String
- // The locale to assume for loading localized resources in this page,
- // specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
- // Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
- // See the documentation for `dojo.i18n` and `dojo.requireLocalization`
- // for details on loading localized resources. If no locale is specified,
- // Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
- // or `navigator.language` properties.
- locale: undefined,
-
- // extraLocale: Array
- // No default value. Specifies additional locales whose
- // resources should also be loaded alongside the default locale when
- // calls to `dojo.requireLocalization()` are processed.
- extraLocale: undefined,
-
- // baseUrl: String
- // The directory in which `dojo.js` is located. Under normal
- // conditions, Dojo auto-detects the correct location from which it
- // was loaded. You may need to manually configure `baseUrl` in cases
- // where you have renamed `dojo.js` or in which `` tags confuse
- // some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
- // either the value of `djConfig.baseUrl` if one is provided or the
- // auto-detected root if not. Other modules are located relative to
- // this path. The path should end in a slash.
- baseUrl: undefined,
-
- // modulePaths: [deprecated] Object
- // A map of module names to paths relative to `dojo.baseUrl`. The
- // key/value pairs correspond directly to the arguments which
- // `dojo.registerModulePath` accepts. Specifying
- // `djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
- // of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
- // modules may be configured via `djConfig.modulePaths`.
- modulePaths: {},
-
- // addOnLoad: Function|Array
- // Adds a callback via dojo/ready. Useful when Dojo is added after
- // the page loads and djConfig.afterOnLoad is true. Supports the same
- // arguments as dojo/ready. When using a function reference, use
- // `djConfig.addOnLoad = function(){};`. For object with function name use
- // `djConfig.addOnLoad = [myObject, "functionName"];` and for object with
- // function reference use
- // `djConfig.addOnLoad = [myObject, function(){}];`
- addOnLoad: null,
-
- // parseOnLoad: Boolean
- // Run the parser after the page is loaded
- parseOnLoad: false,
-
- // require: String[]
- // An array of module names to be loaded immediately after dojo.js has been included
- // in a page.
- require: [],
-
- // defaultDuration: Number
- // Default duration, in milliseconds, for wipe and fade animations within dijits.
- // Assigned to dijit.defaultDuration.
- defaultDuration: 200,
-
- // dojoBlankHtmlUrl: String
- // Used by some modules to configure an empty iframe. Used by dojo/io/iframe and
- // dojo/back, and dijit/popup support in IE where an iframe is needed to make sure native
- // controls do not bleed through the popups. Normally this configuration variable
- // does not need to be set, except when using cross-domain/CDN Dojo builds.
- // Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
- // to the path on your domain your copy of blank.html.
- dojoBlankHtmlUrl: undefined,
-
- // ioPublish: Boolean?
- // Set this to true to enable publishing of topics for the different phases of
- // IO operations. Publishing is done via dojo/topic.publish(). See dojo/main.__IoPublish for a list
- // of topics that are published.
- ioPublish: false,
-
- // useCustomLogger: Anything?
- // If set to a value that evaluates to true such as a string or array and
- // isDebug is true and Firebug is not available or running, then it bypasses
- // the creation of Firebug Lite allowing you to define your own console object.
- useCustomLogger: undefined,
-
- // transparentColor: Array
- // Array containing the r, g, b components used as transparent color in dojo.Color;
- // if undefined, [255,255,255] (white) will be used.
- transparentColor: undefined,
-
- // deps: Function|Array
- // Defines dependencies to be used before the loader has been loaded.
- // When provided, they cause the loader to execute require(deps, callback)
- // once it has finished loading. Should be used with callback.
- deps: undefined,
-
- // callback: Function|Array
- // Defines a callback to be used when dependencies are defined before
- // the loader has been loaded. When provided, they cause the loader to
- // execute require(deps, callback) once it has finished loading.
- // Should be used with deps.
- callback: undefined,
-
- // deferredInstrumentation: Boolean
- // Whether deferred instrumentation should be loaded or included
- // in builds.
- deferredInstrumentation: true,
-
- // useDeferredInstrumentation: Boolean|String
- // Whether the deferred instrumentation should be used.
- //
- // * `"report-rejections"`: report each rejection as it occurs.
- // * `true` or `1` or `"report-unhandled-rejections"`: wait 1 second
- // in an attempt to detect unhandled rejections.
- useDeferredInstrumentation: "report-unhandled-rejections"
-};
-=====*/
-
- var result = {};
- if( 1 ){
- // must be the dojo loader; take a shallow copy of require.rawConfig
- var src = require.rawConfig, p;
- for(p in src){
- result[p] = src[p];
- }
- }else{
- var adviseHas = function(featureSet, prefix, booting){
- for(p in featureSet){
- p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
- }
- };
- result = 1 ?
- // must be a built version of the dojo loader; all config stuffed in require.rawConfig
- require.rawConfig :
- // a foreign loader
- this.dojoConfig || this.djConfig || {};
- adviseHas(result, "config", 1);
- adviseHas(result.has, "", 1);
- }
-
- if(!result.locale && typeof navigator != "undefined"){
- // Default locale for browsers.
- var language = (navigator.language || navigator.userLanguage);
- if(language){
- result.locale = language.toLowerCase();
- }
- }
-
- return result;
-});
-
diff --git a/lib/dojo/_base/configFirefoxExtension.js b/lib/dojo/_base/configFirefoxExtension.js
deleted file mode 100644
index 4115c61..0000000
--- a/lib/dojo/_base/configFirefoxExtension.js
+++ /dev/null
@@ -1,336 +0,0 @@
-// TODO: this file needs to be converted to the v1.7 loader
-
-// a host environment specifically built for Mozilla extensions, but derived
-// from the browser host environment
-if(typeof window != 'undefined'){
- dojo.isBrowser = true;
- dojo._name = "browser";
-
-
- // FIXME: PORTME
- // http://developer.mozilla.org/en/mozIJSSubScriptLoader
-
-
- // attempt to figure out the path to dojo if it isn't set in the config
- (function(){
- // this is a scope protection closure. We set browser versions and grab
- // the URL we were loaded from here.
-
- // FIXME: need to probably use a different reference to "document" to get the hosting XUL environment
-
- dojo.baseUrl = dojo.config.baseUrl;
-
- // fill in the rendering support information in dojo.render.*
- var n = navigator;
- var dua = n.userAgent;
- var dav = n.appVersion;
- var tv = parseFloat(dav);
-
- dojo.isMozilla = dojo.isMoz = tv;
- if(dojo.isMoz){
- dojo.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined;
- }
-
- // FIXME
- dojo.isQuirks = document.compatMode == "BackCompat";
-
- // FIXME
- // TODO: is the HTML LANG attribute relevant?
- dojo.locale = dojo.config.locale || n.language.toLowerCase();
-
- dojo._xhrObj = function(){
- return new XMLHttpRequest();
- };
-
- // monkey-patch _loadUri to handle file://, chrome://, and resource:// url's
- var oldLoadUri = dojo._loadUri;
- dojo._loadUri = function(uri, cb){
- var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
- return String(uri).indexOf(prefix) == 0;
- });
- if(handleLocal){
- // see:
- // http://developer.mozilla.org/en/mozIJSSubScriptLoader
- var l = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
- .getService(Components.interfaces.mozIJSSubScriptLoader);
- var value = l.loadSubScript(uri, dojo.global);
- if(cb){ cb(value); }
- return true;
- }else{
- // otherwise, call the pre-existing version
- return oldLoadUri.apply(dojo, arguments);
- }
- };
-
- // FIXME: PORTME
- dojo._isDocumentOk = function(http){
- var stat = http.status || 0;
- return (stat >= 200 && stat < 300) || // Boolean
- stat == 304 || // allow any 2XX response code
- stat == 1223 || // get it out of the cache
- (!stat && (location.protocol == "file:" || location.protocol == "chrome:") );
- };
-
- // FIXME: PORTME
- // var owloc = window.location+"";
- // var base = document.getElementsByTagName("base");
- // var hasBase = (base && base.length > 0);
- var hasBase = false;
-
- dojo._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
- // summary:
- // Read the contents of the specified uri and return those contents.
- // uri:
- // A relative or absolute uri. If absolute, it still must be in
- // the same "domain" as we are.
- // fail_ok:
- // Default false. If fail_ok and loading fails, return null
- // instead of throwing.
- // returns:
- // The response text. null is returned when there is a
- // failure and failure is okay (an exception otherwise)
-
- // alert("_getText: " + uri);
-
- // NOTE: must be declared before scope switches ie. this._xhrObj()
- var http = dojo._xhrObj();
-
- if(!hasBase && dojo._Url){
- uri = (new dojo._Url(uri)).toString();
- }
- if(dojo.config.cacheBust){
- //Make sure we have a string before string methods are used on uri
- uri += "";
- uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(dojo.config.cacheBust).replace(/\W+/g, "");
- }
- var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
- return String(uri).indexOf(prefix) == 0;
- });
- if(handleLocal){
- // see:
- // http://forums.mozillazine.org/viewtopic.php?p=921150#921150
- var ioService = Components.classes["@mozilla.org/network/io-service;1"]
- .getService(Components.interfaces.nsIIOService);
- var scriptableStream = Components
- .classes["@mozilla.org/scriptableinputstream;1"]
- .getService(Components.interfaces.nsIScriptableInputStream);
-
- var channel = ioService.newChannel(uri, null, null);
- var input = channel.open();
- scriptableStream.init(input);
- var str = scriptableStream.read(input.available());
- scriptableStream.close();
- input.close();
- return str;
- }else{
- http.open('GET', uri, false);
- try{
- http.send(null);
- // alert(http);
- if(!dojo._isDocumentOk(http)){
- var err = Error("Unable to load " + uri + " status:" + http.status);
- err.status = http.status;
- err.responseText = http.responseText;
- throw err;
- }
- }catch(e){
- if(fail_ok){
- return null;
- } // null
- // rethrow the exception
- throw e;
- }
- return http.responseText; // String
- }
- };
-
- dojo._windowUnloaders = [];
-
- // FIXME: PORTME
- dojo.windowUnloaded = function(){
- // summary:
- // signal fired by impending window destruction. You may use
- // dojo.addOnWIndowUnload() or dojo.connect() to this method to perform
- // page/application cleanup methods. See dojo.addOnWindowUnload for more info.
- var mll = dojo._windowUnloaders;
- while(mll.length){
- (mll.pop())();
- }
- };
-
- // FIXME: PORTME
- dojo.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
- // summary:
- // registers a function to be triggered when window.onunload fires.
- // Be careful trying to modify the DOM or access JavaScript properties
- // during this phase of page unloading: they may not always be available.
- // Consider dojo.addOnUnload() if you need to modify the DOM or do heavy
- // JavaScript work.
- // example:
- // | dojo.addOnWindowUnload(functionPointer)
- // | dojo.addOnWindowUnload(object, "functionName")
- // | dojo.addOnWindowUnload(object, function(){ /* ... */});
-
- dojo._onto(dojo._windowUnloaders, obj, functionName);
- };
-
- // XUL specific APIs
- var contexts = [];
- var current = null;
- dojo._defaultContext = [ window, document ];
-
- dojo.pushContext = function(/*Object|String?*/g, /*MDocumentElement?*/d){
- // summary:
- // causes subsequent calls to Dojo methods to assume the
- // passed object and, optionally, document as the default
- // scopes to use. A 2-element array of the previous global and
- // document are returned.
- // description:
- // dojo.pushContext treats contexts as a stack. The
- // auto-detected contexts which are initially provided using
- // dojo.setContext() require authors to keep state in order to
- // "return" to a previous context, whereas the
- // dojo.pushContext and dojo.popContext methods provide a more
- // natural way to augment blocks of code to ensure that they
- // execute in a different window or frame without issue. If
- // called without any arguments, the default context (the
- // context when Dojo is first loaded) is instead pushed into
- // the stack. If only a single string is passed, a node in the
- // intitial context's document is looked up and its
- // contextWindow and contextDocument properties are used as
- // the context to push. This means that iframes can be given
- // an ID and code can be executed in the scope of the iframe's
- // document in subsequent calls easily.
- // g:
- // The global context. If a string, the id of the frame to
- // search for a context and document.
- // d:
- // The document element to execute subsequent code with.
- var old = [dojo.global, dojo.doc];
- contexts.push(old);
- var n;
- if(!g && !d){
- n = dojo._defaultContext;
- }else{
- n = [ g, d ];
- if(!d && dojo.isString(g)){
- var t = document.getElementById(g);
- if(t.contentDocument){
- n = [t.contentWindow, t.contentDocument];
- }
- }
- }
- current = n;
- dojo.setContext.apply(dojo, n);
- return old; // Array
- };
-
- dojo.popContext = function(){
- // summary:
- // If the context stack contains elements, ensure that
- // subsequent code executes in the *previous* context to the
- // current context. The current context set ([global,
- // document]) is returned.
- var oc = current;
- if(!contexts.length){
- return oc;
- }
- dojo.setContext.apply(dojo, contexts.pop());
- return oc;
- };
-
- // FIXME:
- // don't really like the current arguments and order to
- // _inContext, so don't make it public until it's right!
- dojo._inContext = function(g, d, f){
- var a = dojo._toArray(arguments);
- f = a.pop();
- if(a.length == 1){
- d = null;
- }
- dojo.pushContext(g, d);
- var r = f();
- dojo.popContext();
- return r;
- };
-
- })();
-
- dojo._initFired = false;
- // BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/)
- dojo._loadInit = function(e){
- dojo._initFired = true;
- // allow multiple calls, only first one will take effect
- // A bug in khtml calls events callbacks for document for event which isnt supported
- // for example a created contextmenu event calls DOMContentLoaded, workaround
- var type = (e && e.type) ? e.type.toLowerCase() : "load";
- if(arguments.callee.initialized || (type != "domcontentloaded" && type != "load")){ return; }
- arguments.callee.initialized = true;
- if(dojo._inFlightCount == 0){
- dojo._modulesLoaded();
- }
- };
-
- /*
- (function(){
- var _w = window;
- var _handleNodeEvent = function(evtName, fp){
- // summary:
- // non-destructively adds the specified function to the node's
- // evtName handler.
- // evtName: should be in the form "onclick" for "onclick" handlers.
- // Make sure you pass in the "on" part.
- var oldHandler = _w[evtName] || function(){};
- _w[evtName] = function(){
- fp.apply(_w, arguments);
- oldHandler.apply(_w, arguments);
- };
- };
- // FIXME: PORT
- // FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper.
- _handleNodeEvent("onbeforeunload", function(){ dojo.unloaded(); });
- _handleNodeEvent("onunload", function(){ dojo.windowUnloaded(); });
- })();
- */
-
-
- // FIXME: PORTME
- // this event fires a lot, namely for all plugin XUL overlays and for
- // all iframes (in addition to window navigations). We only want
- // Dojo's to fire once..but we might care if pages navigate. We'll
- // probably need an extension-specific API
- if(!dojo.config.afterOnLoad){
- window.addEventListener("DOMContentLoaded", function(e){
- dojo._loadInit(e);
- // console.log("DOM content loaded", e);
- }, false);
- }
-
-} //if (typeof window != 'undefined')
-
-//Register any module paths set up in djConfig. Need to do this
-//in the hostenvs since hostenv_browser can read djConfig from a
-//script tag's attribute.
-(function(){
- var mp = dojo.config["modulePaths"];
- if(mp){
- for(var param in mp){
- dojo.registerModulePath(param, mp[param]);
- }
- }
-})();
-
-//Load debug code if necessary.
-if(dojo.config.isDebug){
- // logging stub for extension logging
- console.log = function(m){
- var s = Components.classes["@mozilla.org/consoleservice;1"].getService(
- Components.interfaces.nsIConsoleService
- );
- s.logStringMessage(m);
- };
- console.debug = function(){
- console.log(dojo._toArray(arguments).join(" "));
- };
- // FIXME: what about the rest of the console.* methods? And is there any way to reach into firebug and log into it directly?
-}
diff --git a/lib/dojo/_base/configNode.js b/lib/dojo/_base/configNode.js
deleted file mode 100644
index 1866795..0000000
--- a/lib/dojo/_base/configNode.js
+++ /dev/null
@@ -1,87 +0,0 @@
-exports.config = function(config){
- // summary:
- // This module provides bootstrap configuration for running dojo in node.js
-
- // any command line arguments with the load flag are pushed into deps
- for(var deps = [], args = [], i = 0; i < process.argv.length; i++){
- var arg = (process.argv[i] + "").split("=");
- if(arg[0] == "load"){
- deps.push(arg[1]);
- }else{
- args.push(arg);
- }
- }
-
- var fs = require("fs");
-
- // make sure global require exists
- //if (typeof global.require=="undefined"){
- // global.require= {};
- //}
-
- // reset the has cache with node-appropriate values;
- var hasCache = {
- "host-node":1,
- "host-browser":0,
- "dom":0,
- "dojo-has-api":1,
- "dojo-xhr-factory":0,
- "dojo-inject-api":1,
- "dojo-timeout-api":0,
- "dojo-trace-api":1,
- "dojo-dom-ready-api":0,
- "dojo-publish-privates":1,
- "dojo-sniff":0,
- "dojo-loader":1,
- "dojo-test-xd":0,
- "dojo-test-sniff":0
- };
- for(var p in hasCache){
- config.hasCache[p] = hasCache[p];
- }
-
- var vm = require('vm'),
- path = require('path');
-
- // reset some configuration switches with node-appropriate values
- var nodeConfig = {
- baseUrl: path.dirname(process.argv[1]),
- commandLineArgs:args,
- deps:deps,
- timeout:0,
-
- // TODO: really get the locale
- locale:"en-us",
-
- loaderPatch: {
- log:function(item){
- // define debug for console messages during dev instead of console.log
- // (node's heavy async makes console.log confusing sometimes)
- var util = require("util");
- util.debug(util.inspect(item));
- },
-
- eval: function(__text, __urlHint){
- return vm.runInThisContext(__text, __urlHint);
- },
-
- injectUrl: function(url, callback){
- try{
- vm.runInThisContext(fs.readFileSync(url, "utf8"), url);
- callback();
- }catch(e){
- this.log("failed to load resource (" + url + ")");
- this.log(e);
- }
- },
-
- getText: function(url, sync, onLoad){
- // TODO: implement async and http/https handling
- onLoad(fs.readFileSync(url, "utf8"));
- }
- }
- };
- for(p in nodeConfig){
- config[p] = nodeConfig[p];
- }
-};
diff --git a/lib/dojo/_base/configRhino.js b/lib/dojo/_base/configRhino.js
deleted file mode 100644
index 2cbbf88..0000000
--- a/lib/dojo/_base/configRhino.js
+++ /dev/null
@@ -1,121 +0,0 @@
-function rhinoDojoConfig(config, baseUrl, rhinoArgs){
- // summary:
- // This module provides bootstrap configuration for running dojo in rhino.
-
- // TODO: v1.6 tries to set dojo.doc and dojo.body in rhino; why?
-
- // get a minimal console up
- var log = function(hint, args){
- print((hint ? hint + ":" : "") + args[0]);
- for(var i = 1; i < args.length; i++){
- print(", " + args[i]);
- }
- };
- // intentionally define console in the global namespace
- console= {
- log: function(){ log(0, arguments); },
- error: function(){ log("ERROR", arguments); },
- warn: function(){ log("WARN", arguments); }
- };
-
- // any command line arguments with the load flag are pushed into deps
- for(var deps = [], i = 0; i < rhinoArgs.length; i++){
- var arg = (rhinoArgs[i] + "").split("=");
- if(arg[0] == "load"){
- deps.push(arg[1]);
- }
- }
-
- // provides timed callbacks using Java threads
- if(typeof setTimeout == "undefined" || typeof clearTimeout == "undefined"){
- var timeouts = [];
- clearTimeout = function(idx){
- if(!timeouts[idx]){ return; }
- timeouts[idx].stop();
- };
-
- setTimeout = function(func, delay){
- var def = {
- sleepTime:delay,
- hasSlept:false,
-
- run:function(){
- if(!this.hasSlept){
- this.hasSlept = true;
- java.lang.Thread.currentThread().sleep(this.sleepTime);
- }
- try{
- func();
- }catch(e){
- console.debug("Error running setTimeout thread:" + e);
- }
- }
- };
-
- var runnable = new java.lang.Runnable(def);
- var thread = new java.lang.Thread(runnable);
- thread.start();
- return timeouts.push(thread) - 1;
- };
- }
-
- var isLocal = function(url){
- return (new java.io.File(url)).exists();
- };
-
- // reset the has cache with node-appropriate values;
- var hasCache = {
- "host-rhino":1,
- "host-browser":0,
- "dom":0,
- "dojo-has-api":1,
- "dojo-xhr-factory":0,
- "dojo-inject-api":1,
- "dojo-timeout-api":0,
- "dojo-trace-api":1,
- "dojo-loader-catches":1,
- "dojo-dom-ready-api":0,
- "dojo-publish-privates":1,
- "dojo-sniff":0,
- "dojo-loader":1,
- "dojo-test-xd":0,
- "dojo-test-sniff":0
- };
- for(var p in hasCache){
- config.hasCache[p] = hasCache[p];
- }
-
- // reset some configuration switches with rhino-appropriate values
- var rhinoConfig = {
- baseUrl:baseUrl,
- commandLineArgs:rhinoArgs,
- deps:deps,
- timeout:0,
- locale:String(java.util.Locale.getDefault().toString().replace('_', '-').toLowerCase()),
-
- loaderPatch:{
- injectUrl: function(url, callback){
- try{
- if(isLocal(url)){
- load(url);
- }else{
- require.eval(readUrl(url, "UTF-8"));
- }
- callback();
- }catch(e){
- console.log("failed to load resource (" + url + ")");
- console.log(e);
- }
- },
-
- getText: function(url, sync, onLoad){
- // TODO: test https://bugzilla.mozilla.org/show_bug.cgi?id=471005; see v1.6 hostenv_rhino
- // note: async mode not supported in rhino
- onLoad(isLocal(url) ? readFile(url, "UTF-8") : readUrl(url, "UTF-8"));
- }
- }
- };
- for(p in rhinoConfig){
- config[p] = rhinoConfig[p];
- }
-}
diff --git a/lib/dojo/_base/configSpidermonkey.js b/lib/dojo/_base/configSpidermonkey.js
deleted file mode 100644
index af16fda..0000000
--- a/lib/dojo/_base/configSpidermonkey.js
+++ /dev/null
@@ -1,80 +0,0 @@
-// TODO: this file needs to be converted to the v1.7 loader
-
-// module:
-// configSpidermonkey
-// summary:
-// SpiderMonkey host environment
-
-if(dojo.config["baseUrl"]){
- dojo.baseUrl = dojo.config["baseUrl"];
-}else{
- dojo.baseUrl = "./";
-}
-
-dojo._name = 'spidermonkey';
-
-
-
-dojo.isSpidermonkey = true;
-dojo.exit = function(exitcode){
- quit(exitcode);
-};
-
-if(typeof print == "function"){
- console.debug = print;
-}
-
-if(typeof line2pc == 'undefined'){
- throw new Error("attempt to use SpiderMonkey host environment when no 'line2pc' global");
-}
-
-dojo._spidermonkeyCurrentFile = function(depth){
- //
- // This is a hack that determines the current script file by parsing a
- // generated stack trace (relying on the non-standard "stack" member variable
- // of the SpiderMonkey Error object).
- //
- // If param depth is passed in, it'll return the script file which is that far down
- // the stack, but that does require that you know how deep your stack is when you are
- // calling.
- //
- var s = '';
- try{
- throw Error("whatever");
- }catch(e){
- s = e.stack;
- }
- // lines are like: bu_getCurrentScriptURI_spidermonkey("ScriptLoader.js")@burst/Runtime.js:101
- var matches = s.match(/[^@]*\.js/gi);
- if(!matches){
- throw Error("could not parse stack string: '" + s + "'");
- }
- var fname = (typeof depth != 'undefined' && depth) ? matches[depth + 1] : matches[matches.length - 1];
- if(!fname){
- throw Error("could not find file name in stack string '" + s + "'");
- }
- //print("SpiderMonkeyRuntime got fname '" + fname + "' from stack string '" + s + "'");
- return fname;
-};
-
-// print(dojo._spidermonkeyCurrentFile(0));
-
-dojo._loadUri = function(uri){
- // spidermonkey load() evaluates the contents into the global scope (which
- // is what we want).
- // TODO: sigh, load() does not return a useful value.
- // Perhaps it is returning the value of the last thing evaluated?
- // var ok =
- load(uri);
- // console.log("spidermonkey load(", uri, ") returned ", ok);
- return 1;
-};
-
-//Register any module paths set up in djConfig. Need to do this
-//in the hostenvs since hostenv_browser can read djConfig from a
-//script tag's attribute.
-if(dojo.config["modulePaths"]){
- for(var param in dojo.config["modulePaths"]){
- dojo.registerModulePath(param, dojo.config["modulePaths"][param]);
- }
-}
diff --git a/lib/dojo/_base/connect.js b/lib/dojo/_base/connect.js
deleted file mode 100644
index 77d0ab9..0000000
--- a/lib/dojo/_base/connect.js
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/connect",["./kernel","../on","../topic","../aspect","./event","../mouse","./sniff","./lang","../keys"],function(_1,on,_2,_3,_4,_5,_6,_7){
-_6.add("events-keypress-typed",function(){
-var _8={charCode:0};
-try{
-_8=document.createEvent("KeyboardEvent");
-(_8.initKeyboardEvent||_8.initKeyEvent).call(_8,"keypress",true,true,null,false,false,false,false,9,3);
-}
-catch(e){
-}
-return _8.charCode==0&&!_6("opera");
-});
-function _9(_a,_b,_c,_d,_e){
-_d=_7.hitch(_c,_d);
-if(!_a||!(_a.addEventListener||_a.attachEvent)){
-return _3.after(_a||_1.global,_b,_d,true);
-}
-if(typeof _b=="string"&&_b.substring(0,2)=="on"){
-_b=_b.substring(2);
-}
-if(!_a){
-_a=_1.global;
-}
-if(!_e){
-switch(_b){
-case "keypress":
-_b=_f;
-break;
-case "mouseenter":
-_b=_5.enter;
-break;
-case "mouseleave":
-_b=_5.leave;
-break;
-}
-}
-return on(_a,_b,_d,_e);
-};
-var _10={106:42,111:47,186:59,187:43,188:44,189:45,190:46,191:47,192:96,219:91,220:92,221:93,222:39,229:113};
-var _11=_6("mac")?"metaKey":"ctrlKey";
-var _12=function(evt,_13){
-var _14=_7.mixin({},evt,_13);
-_15(_14);
-_14.preventDefault=function(){
-evt.preventDefault();
-};
-_14.stopPropagation=function(){
-evt.stopPropagation();
-};
-return _14;
-};
-function _15(evt){
-evt.keyChar=evt.charCode?String.fromCharCode(evt.charCode):"";
-evt.charOrCode=evt.keyChar||evt.keyCode;
-};
-var _f;
-if(_6("events-keypress-typed")){
-var _16=function(e,_17){
-try{
-return (e.keyCode=_17);
-}
-catch(e){
-return 0;
-}
-};
-_f=function(_18,_19){
-var _1a=on(_18,"keydown",function(evt){
-var k=evt.keyCode;
-var _1b=(k!=13)&&k!=32&&(k!=27||!_6("ie"))&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222)&&k!=229;
-if(_1b||evt.ctrlKey){
-var c=_1b?0:k;
-if(evt.ctrlKey){
-if(k==3||k==13){
-return _19.call(evt.currentTarget,evt);
-}else{
-if(c>95&&c<106){
-c-=48;
-}else{
-if((!evt.shiftKey)&&(c>=65&&c<=90)){
-c+=32;
-}else{
-c=_10[c]||c;
-}
-}
-}
-}
-var _1c=_12(evt,{type:"keypress",faux:true,charCode:c});
-_19.call(evt.currentTarget,_1c);
-if(_6("ie")){
-_16(evt,_1c.keyCode);
-}
-}
-});
-var _1d=on(_18,"keypress",function(evt){
-var c=evt.charCode;
-c=c>=32?c:0;
-evt=_12(evt,{charCode:c,faux:true});
-return _19.call(this,evt);
-});
-return {remove:function(){
-_1a.remove();
-_1d.remove();
-}};
-};
-}else{
-if(_6("opera")){
-_f=function(_1e,_1f){
-return on(_1e,"keypress",function(evt){
-var c=evt.which;
-if(c==3){
-c=99;
-}
-c=c<32&&!evt.shiftKey?0:c;
-if(evt.ctrlKey&&!evt.shiftKey&&c>=65&&c<=90){
-c+=32;
-}
-return _1f.call(this,_12(evt,{charCode:c}));
-});
-};
-}else{
-_f=function(_20,_21){
-return on(_20,"keypress",function(evt){
-_15(evt);
-return _21.call(this,evt);
-});
-};
-}
-}
-var _22={_keypress:_f,connect:function(obj,_23,_24,_25,_26){
-var a=arguments,_27=[],i=0;
-_27.push(typeof a[0]=="string"?null:a[i++],a[i++]);
-var a1=a[i+1];
-_27.push(typeof a1=="string"||typeof a1=="function"?a[i++]:null,a[i++]);
-for(var l=a.length;i90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
- // synthesize keypress for most unprintables and CTRL-keys
- if(unprintable||evt.ctrlKey){
- var c = unprintable ? 0 : k;
- if(evt.ctrlKey){
- if(k==3 || k==13){
- return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
- }else if(c>95 && c<106){
- c -= 48; // map CTRL-[numpad 0-9] to ASCII
- }else if((!evt.shiftKey)&&(c>=65&&c<=90)){
- c += 32; // map CTRL-[A-Z] to lowercase
- }else{
- c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII
- }
- }
- // simulate a keypress event
- var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
- listener.call(evt.currentTarget, faux);
- if(has("ie")){
- _trySetKeyCode(evt, faux.keyCode);
- }
- }
- });
- var keypressSignal = on(object, "keypress", function(evt){
- var c = evt.charCode;
- c = c>=32 ? c : 0;
- evt = _synthesizeEvent(evt, {charCode: c, faux: true});
- return listener.call(this, evt);
- });
- return {
- remove: function(){
- keydownSignal.remove();
- keypressSignal.remove();
- }
- };
- };
-}else{
- if(has("opera")){
- keypress = function(object, listener){
- return on(object, "keypress", function(evt){
- var c = evt.which;
- if(c==3){
- c=99; // Mozilla maps CTRL-BREAK to CTRL-c
- }
- // can't trap some keys at all, like INSERT and DELETE
- // there is no differentiating info between DELETE and ".", or INSERT and "-"
- c = c<32 && !evt.shiftKey ? 0 : c;
- if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
- // lowercase CTRL-[A-Z] keys
- c += 32;
- }
- return listener.call(this, _synthesizeEvent(evt, { charCode: c }));
- });
- };
- }else{
- keypress = function(object, listener){
- return on(object, "keypress", function(evt){
- setKeyChar(evt);
- return listener.call(this, evt);
- });
- };
- }
-}
-
-var connect = {
- // summary:
- // This module defines the dojo.connect API.
- // This modules also provides keyboard event handling helpers.
- // This module exports an extension event for emulating Firefox's keypress handling.
- // However, this extension event exists primarily for backwards compatibility and
- // is not recommended. WebKit and IE uses an alternate keypress handling (only
- // firing for printable characters, to distinguish from keydown events), and most
- // consider the WebKit/IE behavior more desirable.
-
- _keypress:keypress,
-
- connect:function(obj, event, context, method, dontFix){
- // summary:
- // `dojo.connect` is a deprecated event handling and delegation method in
- // Dojo. It allows one function to "listen in" on the execution of
- // any other, triggering the second whenever the first is called. Many
- // listeners may be attached to a function, and source functions may
- // be either regular function calls or DOM events.
- //
- // description:
- // Connects listeners to actions, so that after event fires, a
- // listener is called with the same arguments passed to the original
- // function.
- //
- // Since `dojo.connect` allows the source of events to be either a
- // "regular" JavaScript function or a DOM event, it provides a uniform
- // interface for listening to all the types of events that an
- // application is likely to deal with though a single, unified
- // interface. DOM programmers may want to think of it as
- // "addEventListener for everything and anything".
- //
- // When setting up a connection, the `event` parameter must be a
- // string that is the name of the method/event to be listened for. If
- // `obj` is null, `kernel.global` is assumed, meaning that connections
- // to global methods are supported but also that you may inadvertently
- // connect to a global by passing an incorrect object name or invalid
- // reference.
- //
- // `dojo.connect` generally is forgiving. If you pass the name of a
- // function or method that does not yet exist on `obj`, connect will
- // not fail, but will instead set up a stub method. Similarly, null
- // arguments may simply be omitted such that fewer than 4 arguments
- // may be required to set up a connection See the examples for details.
- //
- // The return value is a handle that is needed to
- // remove this connection with `dojo.disconnect`.
- //
- // obj: Object?
- // The source object for the event function.
- // Defaults to `kernel.global` if null.
- // If obj is a DOM node, the connection is delegated
- // to the DOM event manager (unless dontFix is true).
- //
- // event: String
- // String name of the event function in obj.
- // I.e. identifies a property `obj[event]`.
- //
- // context: Object|null
- // The object that method will receive as "this".
- //
- // If context is null and method is a function, then method
- // inherits the context of event.
- //
- // If method is a string then context must be the source
- // object object for method (context[method]). If context is null,
- // kernel.global is used.
- //
- // method: String|Function
- // A function reference, or name of a function in context.
- // The function identified by method fires after event does.
- // method receives the same arguments as the event.
- // See context argument comments for information on method's scope.
- //
- // dontFix: Boolean?
- // If obj is a DOM node, set dontFix to true to prevent delegation
- // of this connection to the DOM event manager.
- //
- // example:
- // When obj.onchange(), do ui.update():
- // | dojo.connect(obj, "onchange", ui, "update");
- // | dojo.connect(obj, "onchange", ui, ui.update); // same
- //
- // example:
- // Using return value for disconnect:
- // | var link = dojo.connect(obj, "onchange", ui, "update");
- // | ...
- // | dojo.disconnect(link);
- //
- // example:
- // When onglobalevent executes, watcher.handler is invoked:
- // | dojo.connect(null, "onglobalevent", watcher, "handler");
- //
- // example:
- // When ob.onCustomEvent executes, customEventHandler is invoked:
- // | dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
- // | dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
- //
- // example:
- // When ob.onCustomEvent executes, customEventHandler is invoked
- // with the same scope (this):
- // | dojo.connect(ob, "onCustomEvent", null, customEventHandler);
- // | dojo.connect(ob, "onCustomEvent", customEventHandler); // same
- //
- // example:
- // When globalEvent executes, globalHandler is invoked
- // with the same scope (this):
- // | dojo.connect(null, "globalEvent", null, globalHandler);
- // | dojo.connect("globalEvent", globalHandler); // same
-
- // normalize arguments
- var a=arguments, args=[], i=0;
- // if a[0] is a String, obj was omitted
- args.push(typeof a[0] == "string" ? null : a[i++], a[i++]);
- // if the arg-after-next is a String or Function, context was NOT omitted
- var a1 = a[i+1];
- args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]);
- // absorb any additional arguments
- for(var l=a.length; i= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/declare",["./kernel","../has","./lang"],function(_1,_2,_3){
-var _4=_3.mixin,op=Object.prototype,_5=op.toString,_6=new Function,_7=0,_8="constructor";
-function _9(_a,_b){
-throw new Error("declare"+(_b?" "+_b:"")+": "+_a);
-};
-function _c(_d,_e){
-var _f=[],_10=[{cls:0,refs:[]}],_11={},_12=1,l=_d.length,i=0,j,lin,_13,top,_14,rec,_15,_16;
-for(;i=0;--j){
-_14=lin[j].prototype;
-if(!_14.hasOwnProperty("declaredClass")){
-_14.declaredClass="uniqName_"+(_7++);
-}
-_15=_14.declaredClass;
-if(!_11.hasOwnProperty(_15)){
-_11[_15]={count:0,refs:[],cls:lin[j]};
-++_12;
-}
-rec=_11[_15];
-if(top&&top!==rec){
-rec.refs.push(top);
-++top.count;
-}
-top=rec;
-}
-++top.count;
-_10[0].refs.push(top);
-}
-while(_10.length){
-top=_10.pop();
-_f.push(top.cls);
---_12;
-while(_16=top.refs,_16.length==1){
-top=_16[0];
-if(!top||--top.count){
-top=0;
-break;
-}
-_f.push(top.cls);
---_12;
-}
-if(top){
-for(i=0,l=_16.length;i=0;--i){
-f=_3a[i];
-m=f._meta;
-f=m?m.ctor:f;
-if(f){
-f.apply(this,_3d?_3d[i]:a);
-}
-}
-f=this.postscript;
-if(f){
-f.apply(this,_3c);
-}
-};
-};
-function _3f(_40,_41){
-return function(){
-var a=arguments,t=a,a0=a[0],f;
-if(!(this instanceof a.callee)){
-return _3e(a);
-}
-if(_41){
-if(a0){
-f=a0.preamble;
-if(f){
-t=f.apply(this,t)||t;
-}
-}
-f=this.preamble;
-if(f){
-f.apply(this,t);
-}
-}
-if(_40){
-_40.apply(this,a);
-}
-f=this.postscript;
-if(f){
-f.apply(this,a);
-}
-};
-};
-function _42(_43){
-return function(){
-var a=arguments,i=0,f,m;
-if(!(this instanceof a.callee)){
-return _3e(a);
-}
-for(;f=_43[i];++i){
-m=f._meta;
-f=m?m.ctor:f;
-if(f){
-f.apply(this,a);
-break;
-}
-}
-f=this.postscript;
-if(f){
-f.apply(this,a);
-}
-};
-};
-function _44(_45,_46,_47){
-return function(){
-var b,m,f,i=0,_48=1;
-if(_47){
-i=_46.length-1;
-_48=-1;
-}
-for(;b=_46[i];i+=_48){
-m=b._meta;
-f=(m?m.hidden:b.prototype)[_45];
-if(f){
-f.apply(this,arguments);
-}
-}
-};
-};
-function _49(_4a){
-_6.prototype=_4a.prototype;
-var t=new _6;
-_6.prototype=null;
-return t;
-};
-function _3e(_4b){
-var _4c=_4b.callee,t=_49(_4c);
-_4c.apply(t,_4b);
-return t;
-};
-function _35(_4d,_4e,_4f){
-if(typeof _4d!="string"){
-_4f=_4e;
-_4e=_4d;
-_4d="";
-}
-_4f=_4f||{};
-var _50,i,t,_51,_52,_53,_54,_55=1,_56=_4e;
-if(_5.call(_4e)=="[object Array]"){
-_53=_c(_4e,_4d);
-t=_53[0];
-_55=_53.length-t;
-_4e=_53[_55];
-}else{
-_53=[0];
-if(_4e){
-if(_5.call(_4e)=="[object Function]"){
-t=_4e._meta;
-_53=_53.concat(t?t.bases:_4e);
-}else{
-_9("base class is not a callable constructor.",_4d);
-}
-}else{
-if(_4e!==null){
-_9("unknown base class. Did you use dojo.require to pull it in?",_4d);
-}
-}
-}
-if(_4e){
-for(i=_55-1;;--i){
-_50=_49(_4e);
-if(!i){
-break;
-}
-t=_53[i];
-(t._meta?_29:_4)(_50,t.prototype);
-_51=new Function;
-_51.superclass=_4e;
-_51.prototype=_50;
-_4e=_50.constructor=_51;
-}
-}else{
-_50={};
-}
-_35.safeMixin(_50,_4f);
-t=_4f.constructor;
-if(t!==op.constructor){
-t.nom=_8;
-_50.constructor=t;
-}
-for(i=_55-1;i;--i){
-t=_53[i]._meta;
-if(t&&t.chains){
-_54=_4(_54||{},t.chains);
-}
-}
-if(_50["-chains-"]){
-_54=_4(_54||{},_50["-chains-"]);
-}
-t=!_54||!_54.hasOwnProperty(_8);
-_53[0]=_51=(_54&&_54.constructor==="manual")?_42(_53):(_53.length==1?_3f(_4f.constructor,t):_39(_53,t));
-_51._meta={bases:_53,hidden:_4f,chains:_54,parents:_56,ctor:_4f.constructor};
-_51.superclass=_4e&&_4e.prototype;
-_51.extend=_33;
-_51.createSubclass=_36;
-_51.prototype=_50;
-_50.constructor=_51;
-_50.getInherited=_21;
-_50.isInstanceOf=_27;
-_50.inherited=_26;
-_50.__inherited=_17;
-if(_4d){
-_50.declaredClass=_4d;
-_3.setObject(_4d,_51);
-}
-if(_54){
-for(_52 in _54){
-if(_50[_52]&&typeof _54[_52]=="string"&&_52!=_8){
-t=_50[_52]=_44(_52,_53,_54[_52]==="after");
-t.nom=_52;
-}
-}
-}
-return _51;
-};
-_1.safeMixin=_35.safeMixin=_2e;
-_1.declare=_35;
-return _35;
-});
diff --git a/lib/dojo/_base/declare.js.uncompressed.js b/lib/dojo/_base/declare.js.uncompressed.js
deleted file mode 100644
index bc22ff2..0000000
--- a/lib/dojo/_base/declare.js.uncompressed.js
+++ /dev/null
@@ -1,1098 +0,0 @@
-define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
- // module:
- // dojo/_base/declare
-
- var mix = lang.mixin, op = Object.prototype, opts = op.toString,
- xtor = new Function, counter = 0, cname = "constructor";
-
- function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
-
- // C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
- function c3mro(bases, className){
- var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
- l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
-
- // build a list of bases naming them if needed
- for(; i < l; ++i){
- base = bases[i];
- if(!base){
- err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
- }else if(opts.call(base) != "[object Function]"){
- err("mixin #" + i + " is not a callable constructor.", className);
- }
- lin = base._meta ? base._meta.bases : [base];
- top = 0;
- // add bases to the name map
- for(j = lin.length - 1; j >= 0; --j){
- proto = lin[j].prototype;
- if(!proto.hasOwnProperty("declaredClass")){
- proto.declaredClass = "uniqName_" + (counter++);
- }
- name = proto.declaredClass;
- if(!nameMap.hasOwnProperty(name)){
- nameMap[name] = {count: 0, refs: [], cls: lin[j]};
- ++clsCount;
- }
- rec = nameMap[name];
- if(top && top !== rec){
- rec.refs.push(top);
- ++top.count;
- }
- top = rec;
- }
- ++top.count;
- roots[0].refs.push(top);
- }
-
- // remove classes without external references recursively
- while(roots.length){
- top = roots.pop();
- result.push(top.cls);
- --clsCount;
- // optimization: follow a single-linked chain
- while(refs = top.refs, refs.length == 1){
- top = refs[0];
- if(!top || --top.count){
- // branch or end of chain => do not end to roots
- top = 0;
- break;
- }
- result.push(top.cls);
- --clsCount;
- }
- if(top){
- // branch
- for(i = 0, l = refs.length; i < l; ++i){
- top = refs[i];
- if(!--top.count){
- roots.push(top);
- }
- }
- }
- }
- if(clsCount){
- err("can't build consistent linearization", className);
- }
-
- // calculate the superclass offset
- base = bases[0];
- result[0] = base ?
- base._meta && base === result[result.length - base._meta.bases.length] ?
- base._meta.bases.length : 1 : 0;
-
- return result;
- }
-
- function inherited(args, a, f){
- var name, chains, bases, caller, meta, base, proto, opf, pos,
- cache = this._inherited = this._inherited || {};
-
- // crack arguments
- if(typeof args == "string"){
- name = args;
- args = a;
- a = f;
- }
- f = 0;
-
- caller = args.callee;
- name = name || caller.nom;
- if(!name){
- err("can't deduce a name to call inherited()", this.declaredClass);
- }
-
- meta = this.constructor._meta;
- bases = meta.bases;
-
- pos = cache.p;
- if(name != cname){
- // method
- if(cache.c !== caller){
- // cache bust
- pos = 0;
- base = bases[0];
- meta = base._meta;
- if(meta.hidden[name] !== caller){
- // error detection
- chains = meta.chains;
- if(chains && typeof chains[name] == "string"){
- err("calling chained method with inherited: " + name, this.declaredClass);
- }
- // find caller
- do{
- meta = base._meta;
- proto = base.prototype;
- if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
- break;
- }
- }while(base = bases[++pos]); // intentional assignment
- pos = base ? pos : -1;
- }
- }
- // find next
- base = bases[++pos];
- if(base){
- proto = base.prototype;
- if(base._meta && proto.hasOwnProperty(name)){
- f = proto[name];
- }else{
- opf = op[name];
- do{
- proto = base.prototype;
- f = proto[name];
- if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
- break;
- }
- }while(base = bases[++pos]); // intentional assignment
- }
- }
- f = base && f || op[name];
- }else{
- // constructor
- if(cache.c !== caller){
- // cache bust
- pos = 0;
- meta = bases[0]._meta;
- if(meta && meta.ctor !== caller){
- // error detection
- chains = meta.chains;
- if(!chains || chains.constructor !== "manual"){
- err("calling chained constructor with inherited", this.declaredClass);
- }
- // find caller
- while(base = bases[++pos]){ // intentional assignment
- meta = base._meta;
- if(meta && meta.ctor === caller){
- break;
- }
- }
- pos = base ? pos : -1;
- }
- }
- // find next
- while(base = bases[++pos]){ // intentional assignment
- meta = base._meta;
- f = meta ? meta.ctor : base;
- if(f){
- break;
- }
- }
- f = base && f;
- }
-
- // cache the found super method
- cache.c = f;
- cache.p = pos;
-
- // now we have the result
- if(f){
- return a === true ? f : f.apply(this, a || args);
- }
- // intentionally no return if a super method was not found
- }
-
- function getInherited(name, args){
- if(typeof name == "string"){
- return this.__inherited(name, args, true);
- }
- return this.__inherited(name, true);
- }
-
- function inherited__debug(args, a1, a2){
- var f = this.getInherited(args, a1);
- if(f){ return f.apply(this, a2 || a1 || args); }
- // intentionally no return if a super method was not found
- }
-
- var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited;
-
- // emulation of "instanceof"
- function isInstanceOf(cls){
- var bases = this.constructor._meta.bases;
- for(var i = 0, l = bases.length; i < l; ++i){
- if(bases[i] === cls){
- return true;
- }
- }
- return this instanceof cls;
- }
-
- function mixOwn(target, source){
- // add props adding metadata for incoming functions skipping a constructor
- for(var name in source){
- if(name != cname && source.hasOwnProperty(name)){
- target[name] = source[name];
- }
- }
- if(has("bug-for-in-skips-shadowed")){
- for(var extraNames= lang._extraNames, i= extraNames.length; i;){
- name = extraNames[--i];
- if(name != cname && source.hasOwnProperty(name)){
- target[name] = source[name];
- }
- }
- }
- }
-
- // implementation of safe mixin function
- function safeMixin(target, source){
- // summary:
- // Mix in properties skipping a constructor and decorating functions
- // like it is done by declare().
- // target: Object
- // Target object to accept new properties.
- // source: Object
- // Source object for new properties.
- // description:
- // This function is used to mix in properties like lang.mixin does,
- // but it skips a constructor property and decorates functions like
- // declare() does.
- //
- // It is meant to be used with classes and objects produced with
- // declare. Functions mixed in with dojo.safeMixin can use
- // this.inherited() like normal methods.
- //
- // This function is used to implement extend() method of a constructor
- // produced with declare().
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){
- // | console.log("A.m1");
- // | },
- // | m2: function(){
- // | console.log("A.m2");
- // | }
- // | });
- // | var B = declare(A, {
- // | m1: function(){
- // | this.inherited(arguments);
- // | console.log("B.m1");
- // | }
- // | });
- // | B.extend({
- // | m2: function(){
- // | this.inherited(arguments);
- // | console.log("B.m2");
- // | }
- // | });
- // | var x = new B();
- // | dojo.safeMixin(x, {
- // | m1: function(){
- // | this.inherited(arguments);
- // | console.log("X.m1");
- // | },
- // | m2: function(){
- // | this.inherited(arguments);
- // | console.log("X.m2");
- // | }
- // | });
- // | x.m2();
- // | // prints:
- // | // A.m1
- // | // B.m1
- // | // X.m1
-
- var name, t;
- // add props adding metadata for incoming functions skipping a constructor
- for(name in source){
- t = source[name];
- if((t !== op[name] || !(name in op)) && name != cname){
- if(opts.call(t) == "[object Function]"){
- // non-trivial function method => attach its name
- t.nom = name;
- }
- target[name] = t;
- }
- }
- if(has("bug-for-in-skips-shadowed")){
- for(var extraNames= lang._extraNames, i= extraNames.length; i;){
- name = extraNames[--i];
- t = source[name];
- if((t !== op[name] || !(name in op)) && name != cname){
- if(opts.call(t) == "[object Function]"){
- // non-trivial function method => attach its name
- t.nom = name;
- }
- target[name] = t;
- }
- }
- }
- return target;
- }
-
- function extend(source){
- declare.safeMixin(this.prototype, source);
- return this;
- }
-
- function createSubclass(mixins, props){
- // crack parameters
- if(!(mixins instanceof Array || typeof mixins == 'function')){
- props = mixins;
- mixins = undefined;
- }
-
- props = props || {};
- mixins = mixins || [];
-
- return declare([this].concat(mixins), props);
- }
-
- // chained constructor compatible with the legacy declare()
- function chainedConstructor(bases, ctorSpecial){
- return function(){
- var a = arguments, args = a, a0 = a[0], f, i, m,
- l = bases.length, preArgs;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) call two types of the preamble
- if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
- // full blown ritual
- preArgs = new Array(bases.length);
- // prepare parameters
- preArgs[0] = a;
- for(i = 0;;){
- // process the preamble of the 1st argument
- a0 = a[0];
- if(a0){
- f = a0.preamble;
- if(f){
- a = f.apply(this, a) || a;
- }
- }
- // process the preamble of this class
- f = bases[i].prototype;
- f = f.hasOwnProperty("preamble") && f.preamble;
- if(f){
- a = f.apply(this, a) || a;
- }
- // one peculiarity of the preamble:
- // it is called if it is not needed,
- // e.g., there is no constructor to call
- // let's watch for the last constructor
- // (see ticket #9795)
- if(++i == l){
- break;
- }
- preArgs[i] = a;
- }
- }
- // 2) call all non-trivial constructors using prepared arguments
- for(i = l - 1; i >= 0; --i){
- f = bases[i];
- m = f._meta;
- f = m ? m.ctor : f;
- if(f){
- f.apply(this, preArgs ? preArgs[i] : a);
- }
- }
- // 3) continue the original ritual: call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, args);
- }
- };
- }
-
-
- // chained constructor compatible with the legacy declare()
- function singleConstructor(ctor, ctorSpecial){
- return function(){
- var a = arguments, t = a, a0 = a[0], f;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) call two types of the preamble
- if(ctorSpecial){
- // full blown ritual
- if(a0){
- // process the preamble of the 1st argument
- f = a0.preamble;
- if(f){
- t = f.apply(this, t) || t;
- }
- }
- f = this.preamble;
- if(f){
- // process the preamble of this class
- f.apply(this, t);
- // one peculiarity of the preamble:
- // it is called even if it is not needed,
- // e.g., there is no constructor to call
- // let's watch for the last constructor
- // (see ticket #9795)
- }
- }
- // 2) call a constructor
- if(ctor){
- ctor.apply(this, a);
- }
- // 3) continue the original ritual: call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, a);
- }
- };
- }
-
- // plain vanilla constructor (can use inherited() to call its base constructor)
- function simpleConstructor(bases){
- return function(){
- var a = arguments, i = 0, f, m;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) do not call the preamble
- // 2) call the top constructor (it can use this.inherited())
- for(; f = bases[i]; ++i){ // intentional assignment
- m = f._meta;
- f = m ? m.ctor : f;
- if(f){
- f.apply(this, a);
- break;
- }
- }
- // 3) call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, a);
- }
- };
- }
-
- function chain(name, bases, reversed){
- return function(){
- var b, m, f, i = 0, step = 1;
- if(reversed){
- i = bases.length - 1;
- step = -1;
- }
- for(; b = bases[i]; i += step){ // intentional assignment
- m = b._meta;
- f = (m ? m.hidden : b.prototype)[name];
- if(f){
- f.apply(this, arguments);
- }
- }
- };
- }
-
- // forceNew(ctor)
- // return a new object that inherits from ctor.prototype but
- // without actually running ctor on the object.
- function forceNew(ctor){
- // create object with correct prototype using a do-nothing
- // constructor
- xtor.prototype = ctor.prototype;
- var t = new xtor;
- xtor.prototype = null; // clean up
- return t;
- }
-
- // applyNew(args)
- // just like 'new ctor()' except that the constructor and its arguments come
- // from args, which must be an array or an arguments object
- function applyNew(args){
- // create an object with ctor's prototype but without
- // calling ctor on it.
- var ctor = args.callee, t = forceNew(ctor);
- // execute the real constructor on the new object
- ctor.apply(t, args);
- return t;
- }
-
- function declare(className, superclass, props){
- // summary:
- // Create a feature-rich constructor from compact notation.
- // className: String?
- // The optional name of the constructor (loosely, a "class")
- // stored in the "declaredClass" property in the created prototype.
- // It will be used as a global name for a created constructor.
- // superclass: Function|Function[]
- // May be null, a Function, or an Array of Functions. This argument
- // specifies a list of bases (the left-most one is the most deepest
- // base).
- // props: Object
- // An object whose properties are copied to the created prototype.
- // Add an instance-initialization function by making it a property
- // named "constructor".
- // returns: dojo/_base/declare.__DeclareCreatedObject
- // New constructor function.
- // description:
- // Create a constructor using a compact notation for inheritance and
- // prototype extension.
- //
- // Mixin ancestors provide a type of multiple inheritance.
- // Prototypes of mixin ancestors are copied to the new class:
- // changes to mixin prototypes will not affect classes to which
- // they have been mixed in.
- //
- // Ancestors can be compound classes created by this version of
- // declare(). In complex cases all base classes are going to be
- // linearized according to C3 MRO algorithm
- // (see http://www.python.org/download/releases/2.3/mro/ for more
- // details).
- //
- // "className" is cached in "declaredClass" property of the new class,
- // if it was supplied. The immediate super class will be cached in
- // "superclass" property of the new class.
- //
- // Methods in "props" will be copied and modified: "nom" property
- // (the declared name of the method) will be added to all copied
- // functions to help identify them for the internal machinery. Be
- // very careful, while reusing methods: if you use the same
- // function under different names, it can produce errors in some
- // cases.
- //
- // It is possible to use constructors created "manually" (without
- // declare()) as bases. They will be called as usual during the
- // creation of an instance, their methods will be chained, and even
- // called by "this.inherited()".
- //
- // Special property "-chains-" governs how to chain methods. It is
- // a dictionary, which uses method names as keys, and hint strings
- // as values. If a hint string is "after", this method will be
- // called after methods of its base classes. If a hint string is
- // "before", this method will be called before methods of its base
- // classes.
- //
- // If "constructor" is not mentioned in "-chains-" property, it will
- // be chained using the legacy mode: using "after" chaining,
- // calling preamble() method before each constructor, if available,
- // and calling postscript() after all constructors were executed.
- // If the hint is "after", it is chained as a regular method, but
- // postscript() will be called after the chain of constructors.
- // "constructor" cannot be chained "before", but it allows
- // a special hint string: "manual", which means that constructors
- // are not going to be chained in any way, and programmer will call
- // them manually using this.inherited(). In the latter case
- // postscript() will be called after the construction.
- //
- // All chaining hints are "inherited" from base classes and
- // potentially can be overridden. Be very careful when overriding
- // hints! Make sure that all chained methods can work in a proposed
- // manner of chaining.
- //
- // Once a method was chained, it is impossible to unchain it. The
- // only exception is "constructor". You don't need to define a
- // method in order to supply a chaining hint.
- //
- // If a method is chained, it cannot use this.inherited() because
- // all other methods in the hierarchy will be called automatically.
- //
- // Usually constructors and initializers of any kind are chained
- // using "after" and destructors of any kind are chained as
- // "before". Note that chaining assumes that chained methods do not
- // return any value: any returned value will be discarded.
- //
- // example:
- // | declare("my.classes.bar", my.classes.foo, {
- // | // properties to be added to the class prototype
- // | someValue: 2,
- // | // initialization function
- // | constructor: function(){
- // | this.myComplicatedObject = new ReallyComplicatedObject();
- // | },
- // | // other functions
- // | someMethod: function(){
- // | doStuff();
- // | }
- // | });
- //
- // example:
- // | var MyBase = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyClass1 = declare(MyBase, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyClass2 = declare(MyBase, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyDiamond = declare([MyClass1, MyClass2], {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- //
- // example:
- // | var F = function(){ console.log("raw constructor"); };
- // | F.prototype.method = function(){
- // | console.log("raw method");
- // | };
- // | var A = declare(F, {
- // | constructor: function(){
- // | console.log("A.constructor");
- // | },
- // | method: function(){
- // | console.log("before calling F.method...");
- // | this.inherited(arguments);
- // | console.log("...back in A");
- // | }
- // | });
- // | new A().method();
- // | // will print:
- // | // raw constructor
- // | // A.constructor
- // | // before calling F.method...
- // | // raw method
- // | // ...back in A
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | destroy: "before"
- // | }
- // | });
- // | var B = declare(A, {
- // | constructor: function(){
- // | console.log("B.constructor");
- // | },
- // | destroy: function(){
- // | console.log("B.destroy");
- // | }
- // | });
- // | var C = declare(B, {
- // | constructor: function(){
- // | console.log("C.constructor");
- // | },
- // | destroy: function(){
- // | console.log("C.destroy");
- // | }
- // | });
- // | new C().destroy();
- // | // prints:
- // | // B.constructor
- // | // C.constructor
- // | // C.destroy
- // | // B.destroy
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | constructor: "manual"
- // | }
- // | });
- // | var B = declare(A, {
- // | constructor: function(){
- // | // ...
- // | // call the base constructor with new parameters
- // | this.inherited(arguments, [1, 2, 3]);
- // | // ...
- // | }
- // | });
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | m1: "before"
- // | },
- // | m1: function(){
- // | console.log("A.m1");
- // | },
- // | m2: function(){
- // | console.log("A.m2");
- // | }
- // | });
- // | var B = declare(A, {
- // | "-chains-": {
- // | m2: "after"
- // | },
- // | m1: function(){
- // | console.log("B.m1");
- // | },
- // | m2: function(){
- // | console.log("B.m2");
- // | }
- // | });
- // | var x = new B();
- // | x.m1();
- // | // prints:
- // | // B.m1
- // | // A.m1
- // | x.m2();
- // | // prints:
- // | // A.m2
- // | // B.m2
-
- // crack parameters
- if(typeof className != "string"){
- props = superclass;
- superclass = className;
- className = "";
- }
- props = props || {};
-
- var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
-
- // build a prototype
- if(opts.call(superclass) == "[object Array]"){
- // C3 MRO
- bases = c3mro(superclass, className);
- t = bases[0];
- mixins = bases.length - t;
- superclass = bases[mixins];
- }else{
- bases = [0];
- if(superclass){
- if(opts.call(superclass) == "[object Function]"){
- t = superclass._meta;
- bases = bases.concat(t ? t.bases : superclass);
- }else{
- err("base class is not a callable constructor.", className);
- }
- }else if(superclass !== null){
- err("unknown base class. Did you use dojo.require to pull it in?", className);
- }
- }
- if(superclass){
- for(i = mixins - 1;; --i){
- proto = forceNew(superclass);
- if(!i){
- // stop if nothing to add (the last base)
- break;
- }
- // mix in properties
- t = bases[i];
- (t._meta ? mixOwn : mix)(proto, t.prototype);
- // chain in new constructor
- ctor = new Function;
- ctor.superclass = superclass;
- ctor.prototype = proto;
- superclass = proto.constructor = ctor;
- }
- }else{
- proto = {};
- }
- // add all properties
- declare.safeMixin(proto, props);
- // add constructor
- t = props.constructor;
- if(t !== op.constructor){
- t.nom = cname;
- proto.constructor = t;
- }
-
- // collect chains and flags
- for(i = mixins - 1; i; --i){ // intentional assignment
- t = bases[i]._meta;
- if(t && t.chains){
- chains = mix(chains || {}, t.chains);
- }
- }
- if(proto["-chains-"]){
- chains = mix(chains || {}, proto["-chains-"]);
- }
-
- // build ctor
- t = !chains || !chains.hasOwnProperty(cname);
- bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
- (bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
-
- // add meta information to the constructor
- ctor._meta = {bases: bases, hidden: props, chains: chains,
- parents: parents, ctor: props.constructor};
- ctor.superclass = superclass && superclass.prototype;
- ctor.extend = extend;
- ctor.createSubclass = createSubclass;
- ctor.prototype = proto;
- proto.constructor = ctor;
-
- // add "standard" methods to the prototype
- proto.getInherited = getInherited;
- proto.isInstanceOf = isInstanceOf;
- proto.inherited = inheritedImpl;
- proto.__inherited = inherited;
-
- // add name if specified
- if(className){
- proto.declaredClass = className;
- lang.setObject(className, ctor);
- }
-
- // build chains and add them to the prototype
- if(chains){
- for(name in chains){
- if(proto[name] && typeof chains[name] == "string" && name != cname){
- t = proto[name] = chain(name, bases, chains[name] === "after");
- t.nom = name;
- }
- }
- }
- // chained methods do not return values
- // no need to chain "invisible" functions
-
- return ctor; // Function
- }
-
- /*=====
- declare.__DeclareCreatedObject = {
- // summary:
- // dojo/_base/declare() returns a constructor `C`. `new C()` returns an Object with the following
- // methods, in addition to the methods and properties specified via the arguments passed to declare().
-
- inherited: function(name, args, newArgs){
- // summary:
- // Calls a super method.
- // name: String?
- // The optional method name. Should be the same as the caller's
- // name. Usually "name" is specified in complex dynamic cases, when
- // the calling method was dynamically added, undecorated by
- // declare(), and it cannot be determined.
- // args: Arguments
- // The caller supply this argument, which should be the original
- // "arguments".
- // newArgs: Object?
- // If "true", the found function will be returned without
- // executing it.
- // If Array, it will be used to call a super method. Otherwise
- // "args" will be used.
- // returns:
- // Whatever is returned by a super method, or a super method itself,
- // if "true" was specified as newArgs.
- // description:
- // This method is used inside method of classes produced with
- // declare() to call a super method (next in the chain). It is
- // used for manually controlled chaining. Consider using the regular
- // chaining, because it is faster. Use "this.inherited()" only in
- // complex cases.
- //
- // This method cannot me called from automatically chained
- // constructors including the case of a special (legacy)
- // constructor chaining. It cannot be called from chained methods.
- //
- // If "this.inherited()" cannot find the next-in-chain method, it
- // does nothing and returns "undefined". The last method in chain
- // can be a default method implemented in Object, which will be
- // called last.
- //
- // If "name" is specified, it is assumed that the method that
- // received "args" is the parent method for this call. It is looked
- // up in the chain list and if it is found the next-in-chain method
- // is called. If it is not found, the first-in-chain method is
- // called.
- //
- // If "name" is not specified, it will be derived from the calling
- // method (using a methoid property "nom").
- //
- // example:
- // | var B = declare(A, {
- // | method1: function(a, b, c){
- // | this.inherited(arguments);
- // | },
- // | method2: function(a, b){
- // | return this.inherited(arguments, [a + b]);
- // | }
- // | });
- // | // next method is not in the chain list because it is added
- // | // manually after the class was created.
- // | B.prototype.method3 = function(){
- // | console.log("This is a dynamically-added method.");
- // | this.inherited("method3", arguments);
- // | };
- // example:
- // | var B = declare(A, {
- // | method: function(a, b){
- // | var super = this.inherited(arguments, true);
- // | // ...
- // | if(!super){
- // | console.log("there is no super method");
- // | return 0;
- // | }
- // | return super.apply(this, arguments);
- // | }
- // | });
- return {}; // Object
- },
-
- getInherited: function(name, args){
- // summary:
- // Returns a super method.
- // name: String?
- // The optional method name. Should be the same as the caller's
- // name. Usually "name" is specified in complex dynamic cases, when
- // the calling method was dynamically added, undecorated by
- // declare(), and it cannot be determined.
- // args: Arguments
- // The caller supply this argument, which should be the original
- // "arguments".
- // returns:
- // Returns a super method (Function) or "undefined".
- // description:
- // This method is a convenience method for "this.inherited()".
- // It uses the same algorithm but instead of executing a super
- // method, it returns it, or "undefined" if not found.
- //
- // example:
- // | var B = declare(A, {
- // | method: function(a, b){
- // | var super = this.getInherited(arguments);
- // | // ...
- // | if(!super){
- // | console.log("there is no super method");
- // | return 0;
- // | }
- // | return super.apply(this, arguments);
- // | }
- // | });
- return {}; // Object
- },
-
- isInstanceOf: function(cls){
- // summary:
- // Checks the inheritance chain to see if it is inherited from this
- // class.
- // cls: Function
- // Class constructor.
- // returns:
- // "true", if this object is inherited from this class, "false"
- // otherwise.
- // description:
- // This method is used with instances of classes produced with
- // declare() to determine of they support a certain interface or
- // not. It models "instanceof" operator.
- //
- // example:
- // | var A = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var B = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var C = declare([A, B], {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var D = declare(A, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // |
- // | var a = new A(), b = new B(), c = new C(), d = new D();
- // |
- // | console.log(a.isInstanceOf(A)); // true
- // | console.log(b.isInstanceOf(A)); // false
- // | console.log(c.isInstanceOf(A)); // true
- // | console.log(d.isInstanceOf(A)); // true
- // |
- // | console.log(a.isInstanceOf(B)); // false
- // | console.log(b.isInstanceOf(B)); // true
- // | console.log(c.isInstanceOf(B)); // true
- // | console.log(d.isInstanceOf(B)); // false
- // |
- // | console.log(a.isInstanceOf(C)); // false
- // | console.log(b.isInstanceOf(C)); // false
- // | console.log(c.isInstanceOf(C)); // true
- // | console.log(d.isInstanceOf(C)); // false
- // |
- // | console.log(a.isInstanceOf(D)); // false
- // | console.log(b.isInstanceOf(D)); // false
- // | console.log(c.isInstanceOf(D)); // false
- // | console.log(d.isInstanceOf(D)); // true
- return {}; // Object
- },
-
- extend: function(source){
- // summary:
- // Adds all properties and methods of source to constructor's
- // prototype, making them available to all instances created with
- // constructor. This method is specific to constructors created with
- // declare().
- // source: Object
- // Source object which properties are going to be copied to the
- // constructor's prototype.
- // description:
- // Adds source properties to the constructor's prototype. It can
- // override existing properties.
- //
- // This method is similar to dojo.extend function, but it is specific
- // to constructors produced by declare(). It is implemented
- // using dojo.safeMixin, and it skips a constructor property,
- // and properly decorates copied functions.
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){},
- // | s1: "Popokatepetl"
- // | });
- // | A.extend({
- // | m1: function(){},
- // | m2: function(){},
- // | f1: true,
- // | d1: 42
- // | });
- },
-
- createSubclass: function(mixins, props){
- // summary:
- // Create a subclass of the declared class from a list of base classes.
- // mixins: Function[]
- // Specifies a list of bases (the left-most one is the most deepest
- // base).
- // props: Object?
- // An optional object whose properties are copied to the created prototype.
- // returns: dojo/_base/declare.__DeclareCreatedObject
- // New constructor function.
- // description:
- // Create a constructor using a compact notation for inheritance and
- // prototype extension.
- //
- // Mixin ancestors provide a type of multiple inheritance.
- // Prototypes of mixin ancestors are copied to the new class:
- // changes to mixin prototypes will not affect classes to which
- // they have been mixed in.
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){},
- // | s1: "bar"
- // | });
- // | var B = declare(null, {
- // | m2: function(){},
- // | s2: "foo"
- // | });
- // | var C = declare(null, {
- // | });
- // | var D1 = A.createSubclass([B, C], {
- // | m1: function(){},
- // | d1: 42
- // | });
- // | var d1 = new D1();
- // |
- // | // this is equivalent to:
- // | var D2 = declare([A, B, C], {
- // | m1: function(){},
- // | d1: 42
- // | });
- // | var d2 = new D2();
- }
- };
- =====*/
-
- // For back-compat, remove for 2.0
- dojo.safeMixin = declare.safeMixin = safeMixin;
- dojo.declare = declare;
-
- return declare;
-});
diff --git a/lib/dojo/_base/event.js b/lib/dojo/_base/event.js
deleted file mode 100644
index eb72029..0000000
--- a/lib/dojo/_base/event.js
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/event",["./kernel","../on","../has","../dom-geometry"],function(_1,on,_2,_3){
-if(on._fixEvent){
-var _4=on._fixEvent;
-on._fixEvent=function(_5,se){
-_5=_4(_5,se);
-if(_5){
-_3.normalizeEvent(_5);
-}
-return _5;
-};
-}
-var _6={fix:function(_7,_8){
-if(on._fixEvent){
-return on._fixEvent(_7,_8);
-}
-return _7;
-},stop:function(_9){
-if(_2("dom-addeventlistener")||(_9&&_9.preventDefault)){
-_9.preventDefault();
-_9.stopPropagation();
-}else{
-_9=_9||window.event;
-_9.cancelBubble=true;
-on._preventDefault.call(_9);
-}
-}};
-if(1){
-_1.fixEvent=_6.fix;
-_1.stopEvent=_6.stop;
-}
-return _6;
-});
diff --git a/lib/dojo/_base/event.js.uncompressed.js b/lib/dojo/_base/event.js.uncompressed.js
deleted file mode 100644
index 8a0597f..0000000
--- a/lib/dojo/_base/event.js.uncompressed.js
+++ /dev/null
@@ -1,59 +0,0 @@
-define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
- // module:
- // dojo/_base/event
-
- if(on._fixEvent){
- var fixEvent = on._fixEvent;
- on._fixEvent = function(evt, se){
- // add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive
- evt = fixEvent(evt, se);
- if(evt){
- dom.normalizeEvent(evt);
- }
- return evt;
- };
- }
-
- var ret = {
- // summary:
- // This module defines dojo DOM event API. Usually you should use dojo/on, and evt.stopPropagation() +
- // evt.preventDefault(), rather than this module.
-
- fix: function(/*Event*/ evt, /*DOMNode*/ sender){
- // summary:
- // normalizes properties on the event object including event
- // bubbling methods, keystroke normalization, and x/y positions
- // evt: Event
- // native event object
- // sender: DOMNode
- // node to treat as "currentTarget"
- if(on._fixEvent){
- return on._fixEvent(evt, sender);
- }
- return evt; // Event
- },
-
- stop: function(/*Event*/ evt){
- // summary:
- // prevents propagation and clobbers the default action of the
- // passed event
- // evt: Event
- // The event object. If omitted, window.event is used on IE.
- if(has("dom-addeventlistener") || (evt && evt.preventDefault)){
- evt.preventDefault();
- evt.stopPropagation();
- }else{
- evt = evt || window.event;
- evt.cancelBubble = true;
- on._preventDefault.call(evt);
- }
- }
- };
-
- if( 1 ){
- dojo.fixEvent = ret.fix;
- dojo.stopEvent = ret.stop;
- }
-
- return ret;
-});
diff --git a/lib/dojo/_base/fx.js b/lib/dojo/_base/fx.js
deleted file mode 100644
index 640e06b..0000000
--- a/lib/dojo/_base/fx.js
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/fx",["./kernel","./config","./lang","../Evented","./Color","../aspect","../sniff","../dom","../dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9){
-var _a=_3.mixin;
-var _b={};
-var _c=_b._Line=function(_d,_e){
-this.start=_d;
-this.end=_e;
-};
-_c.prototype.getValue=function(n){
-return ((this.end-this.start)*n)+this.start;
-};
-var _f=_b.Animation=function(_10){
-_a(this,_10);
-if(_3.isArray(this.curve)){
-this.curve=new _c(this.curve[0],this.curve[1]);
-}
-};
-_f.prototype=new _4();
-_3.extend(_f,{duration:350,repeat:0,rate:20,_percent:0,_startRepeatCount:0,_getStep:function(){
-var _11=this._percent,_12=this.easing;
-return _12?_12(_11):_11;
-},_fire:function(evt,_13){
-var a=_13||[];
-if(this[evt]){
-if(_2.debugAtAllCosts){
-this[evt].apply(this,a);
-}else{
-try{
-this[evt].apply(this,a);
-}
-catch(e){
-console.error("exception in animation handler for:",evt);
-console.error(e);
-}
-}
-}
-return this;
-},play:function(_14,_15){
-var _16=this;
-if(_16._delayTimer){
-_16._clearTimer();
-}
-if(_15){
-_16._stopTimer();
-_16._active=_16._paused=false;
-_16._percent=0;
-}else{
-if(_16._active&&!_16._paused){
-return _16;
-}
-}
-_16._fire("beforeBegin",[_16.node]);
-var de=_14||_16.delay,_17=_3.hitch(_16,"_play",_15);
-if(de>0){
-_16._delayTimer=setTimeout(_17,de);
-return _16;
-}
-_17();
-return _16;
-},_play:function(_18){
-var _19=this;
-if(_19._delayTimer){
-_19._clearTimer();
-}
-_19._startTime=new Date().valueOf();
-if(_19._paused){
-_19._startTime-=_19.duration*_19._percent;
-}
-_19._active=true;
-_19._paused=false;
-var _1a=_19.curve.getValue(_19._getStep());
-if(!_19._percent){
-if(!_19._startRepeatCount){
-_19._startRepeatCount=_19.repeat;
-}
-_19._fire("onBegin",[_1a]);
-}
-_19._fire("onPlay",[_1a]);
-_19._cycle();
-return _19;
-},pause:function(){
-var _1b=this;
-if(_1b._delayTimer){
-_1b._clearTimer();
-}
-_1b._stopTimer();
-if(!_1b._active){
-return _1b;
-}
-_1b._paused=true;
-_1b._fire("onPause",[_1b.curve.getValue(_1b._getStep())]);
-return _1b;
-},gotoPercent:function(_1c,_1d){
-var _1e=this;
-_1e._stopTimer();
-_1e._active=_1e._paused=true;
-_1e._percent=_1c;
-if(_1d){
-_1e.play();
-}
-return _1e;
-},stop:function(_1f){
-var _20=this;
-if(_20._delayTimer){
-_20._clearTimer();
-}
-if(!_20._timer){
-return _20;
-}
-_20._stopTimer();
-if(_1f){
-_20._percent=1;
-}
-_20._fire("onStop",[_20.curve.getValue(_20._getStep())]);
-_20._active=_20._paused=false;
-return _20;
-},destroy:function(){
-this.stop();
-},status:function(){
-if(this._active){
-return this._paused?"paused":"playing";
-}
-return "stopped";
-},_cycle:function(){
-var _21=this;
-if(_21._active){
-var _22=new Date().valueOf();
-var _23=_21.duration===0?1:(_22-_21._startTime)/(_21.duration);
-if(_23>=1){
-_23=1;
-}
-_21._percent=_23;
-if(_21.easing){
-_23=_21.easing(_23);
-}
-_21._fire("onAnimate",[_21.curve.getValue(_23)]);
-if(_21._percent<1){
-_21._startTimer();
-}else{
-_21._active=false;
-if(_21.repeat>0){
-_21.repeat--;
-_21.play(null,true);
-}else{
-if(_21.repeat==-1){
-_21.play(null,true);
-}else{
-if(_21._startRepeatCount){
-_21.repeat=_21._startRepeatCount;
-_21._startRepeatCount=0;
-}
-}
-}
-_21._percent=0;
-_21._fire("onEnd",[_21.node]);
-!_21.repeat&&_21._stopTimer();
-}
-}
-return _21;
-},_clearTimer:function(){
-clearTimeout(this._delayTimer);
-delete this._delayTimer;
-}});
-var ctr=0,_24=null,_25={run:function(){
-}};
-_3.extend(_f,{_startTimer:function(){
-if(!this._timer){
-this._timer=_6.after(_25,"run",_3.hitch(this,"_cycle"),true);
-ctr++;
-}
-if(!_24){
-_24=setInterval(_3.hitch(_25,"run"),this.rate);
-}
-},_stopTimer:function(){
-if(this._timer){
-this._timer.remove();
-this._timer=null;
-ctr--;
-}
-if(ctr<=0){
-clearInterval(_24);
-_24=null;
-ctr=0;
-}
-}});
-var _26=_7("ie")?function(_27){
-var ns=_27.style;
-if(!ns.width.length&&_9.get(_27,"width")=="auto"){
-ns.width="auto";
-}
-}:function(){
-};
-_b._fade=function(_28){
-_28.node=_8.byId(_28.node);
-var _29=_a({properties:{}},_28),_2a=(_29.properties.opacity={});
-_2a.start=!("start" in _29)?function(){
-return +_9.get(_29.node,"opacity")||0;
-}:_29.start;
-_2a.end=_29.end;
-var _2b=_b.animateProperty(_29);
-_6.after(_2b,"beforeBegin",_3.partial(_26,_29.node),true);
-return _2b;
-};
-_b.fadeIn=function(_2c){
-return _b._fade(_a({end:1},_2c));
-};
-_b.fadeOut=function(_2d){
-return _b._fade(_a({end:0},_2d));
-};
-_b._defaultEasing=function(n){
-return 0.5+((Math.sin((n+1.5)*Math.PI))/2);
-};
-var _2e=function(_2f){
-this._properties=_2f;
-for(var p in _2f){
-var _30=_2f[p];
-if(_30.start instanceof _5){
-_30.tempColor=new _5();
-}
-}
-};
-_2e.prototype.getValue=function(r){
-var ret={};
-for(var p in this._properties){
-var _31=this._properties[p],_32=_31.start;
-if(_32 instanceof _5){
-ret[p]=_5.blendColors(_32,_31.end,r,_31.tempColor).toCss();
-}else{
-if(!_3.isArray(_32)){
-ret[p]=((_31.end-_32)*r)+_32+(p!="opacity"?_31.units||"px":0);
-}
-}
-}
-return ret;
-};
-_b.animateProperty=function(_33){
-var n=_33.node=_8.byId(_33.node);
-if(!_33.easing){
-_33.easing=_1._defaultEasing;
-}
-var _34=new _f(_33);
-_6.after(_34,"beforeBegin",_3.hitch(_34,function(){
-var pm={};
-for(var p in this.properties){
-if(p=="width"||p=="height"){
-this.node.display="block";
-}
-var _35=this.properties[p];
-if(_3.isFunction(_35)){
-_35=_35(n);
-}
-_35=pm[p]=_a({},(_3.isObject(_35)?_35:{end:_35}));
-if(_3.isFunction(_35.start)){
-_35.start=_35.start(n);
-}
-if(_3.isFunction(_35.end)){
-_35.end=_35.end(n);
-}
-var _36=(p.toLowerCase().indexOf("color")>=0);
-function _37(_38,p){
-var v={height:_38.offsetHeight,width:_38.offsetWidth}[p];
-if(v!==undefined){
-return v;
-}
-v=_9.get(_38,p);
-return (p=="opacity")?+v:(_36?v:parseFloat(v));
-};
-if(!("end" in _35)){
-_35.end=_37(n,p);
-}else{
-if(!("start" in _35)){
-_35.start=_37(n,p);
-}
-}
-if(_36){
-_35.start=new _5(_35.start);
-_35.end=new _5(_35.end);
-}else{
-_35.start=(p=="opacity")?+_35.start:parseFloat(_35.start);
-}
-}
-this.curve=new _2e(pm);
-}),true);
-_6.after(_34,"onAnimate",_3.hitch(_9,"set",_34.node),true);
-return _34;
-};
-_b.anim=function(_39,_3a,_3b,_3c,_3d,_3e){
-return _b.animateProperty({node:_39,duration:_3b||_f.prototype.duration,properties:_3a,easing:_3c,onEnd:_3d}).play(_3e||0);
-};
-if(1){
-_a(_1,_b);
-_1._Animation=_f;
-}
-return _b;
-});
diff --git a/lib/dojo/_base/fx.js.uncompressed.js b/lib/dojo/_base/fx.js.uncompressed.js
deleted file mode 100644
index 208edbe..0000000
--- a/lib/dojo/_base/fx.js.uncompressed.js
+++ /dev/null
@@ -1,676 +0,0 @@
-define("dojo/_base/fx", ["./kernel", "./config", /*===== "./declare", =====*/ "./lang", "../Evented", "./Color", "../aspect", "../sniff", "../dom", "../dom-style"],
- function(dojo, config, /*===== declare, =====*/ lang, Evented, Color, aspect, has, dom, style){
- // module:
- // dojo/_base/fx
- // notes:
- // Animation loosely package based on Dan Pupius' work, contributed under CLA; see
- // http://pupius.co.uk/js/Toolkit.Drawing.js
-
- var _mixin = lang.mixin;
-
- // Module export
- var basefx = {
- // summary:
- // This module defines the base dojo/_base/fx implementation.
- };
-
- var _Line = basefx._Line = function(/*int*/ start, /*int*/ end){
- // summary:
- // Object used to generate values from a start value to an end value
- // start: int
- // Beginning value for range
- // end: int
- // Ending value for range
- this.start = start;
- this.end = end;
- };
-
- _Line.prototype.getValue = function(/*float*/ n){
- // summary:
- // Returns the point on the line
- // n:
- // a floating point number greater than 0 and less than 1
- return ((this.end - this.start) * n) + this.start; // Decimal
- };
-
- var Animation = basefx.Animation = function(args){
- // summary:
- // A generic animation class that fires callbacks into its handlers
- // object at various states.
- // description:
- // A generic animation class that fires callbacks into its handlers
- // object at various states. Nearly all dojo animation functions
- // return an instance of this method, usually without calling the
- // .play() method beforehand. Therefore, you will likely need to
- // call .play() on instances of `Animation` when one is
- // returned.
- // args: Object
- // The 'magic argument', mixing all the properties into this
- // animation instance.
-
- _mixin(this, args);
- if(lang.isArray(this.curve)){
- this.curve = new _Line(this.curve[0], this.curve[1]);
- }
-
- };
- Animation.prototype = new Evented();
-
- lang.extend(Animation, {
- // duration: Integer
- // The time in milliseconds the animation will take to run
- duration: 350,
-
- /*=====
- // curve: _Line|Array
- // A two element array of start and end values, or a `_Line` instance to be
- // used in the Animation.
- curve: null,
-
- // easing: Function?
- // A Function to adjust the acceleration (or deceleration) of the progress
- // across a _Line
- easing: null,
- =====*/
-
- // repeat: Integer?
- // The number of times to loop the animation
- repeat: 0,
-
- // rate: Integer?
- // the time in milliseconds to wait before advancing to next frame
- // (used as a fps timer: 1000/rate = fps)
- rate: 20 /* 50 fps */,
-
- /*=====
- // delay: Integer?
- // The time in milliseconds to wait before starting animation after it
- // has been .play()'ed
- delay: null,
-
- // beforeBegin: Event?
- // Synthetic event fired before a Animation begins playing (synchronous)
- beforeBegin: null,
-
- // onBegin: Event?
- // Synthetic event fired as a Animation begins playing (useful?)
- onBegin: null,
-
- // onAnimate: Event?
- // Synthetic event fired at each interval of the Animation
- onAnimate: null,
-
- // onEnd: Event?
- // Synthetic event fired after the final frame of the Animation
- onEnd: null,
-
- // onPlay: Event?
- // Synthetic event fired any time the Animation is play()'ed
- onPlay: null,
-
- // onPause: Event?
- // Synthetic event fired when the Animation is paused
- onPause: null,
-
- // onStop: Event
- // Synthetic event fires when the Animation is stopped
- onStop: null,
-
- =====*/
-
- _percent: 0,
- _startRepeatCount: 0,
-
- _getStep: function(){
- var _p = this._percent,
- _e = this.easing
- ;
- return _e ? _e(_p) : _p;
- },
- _fire: function(/*Event*/ evt, /*Array?*/ args){
- // summary:
- // Convenience function. Fire event "evt" and pass it the
- // arguments specified in "args".
- // description:
- // Convenience function. Fire event "evt" and pass it the
- // arguments specified in "args".
- // Fires the callback in the scope of this Animation
- // instance.
- // evt:
- // The event to fire.
- // args:
- // The arguments to pass to the event.
- var a = args||[];
- if(this[evt]){
- if(config.debugAtAllCosts){
- this[evt].apply(this, a);
- }else{
- try{
- this[evt].apply(this, a);
- }catch(e){
- // squelch and log because we shouldn't allow exceptions in
- // synthetic event handlers to cause the internal timer to run
- // amuck, potentially pegging the CPU. I'm not a fan of this
- // squelch, but hopefully logging will make it clear what's
- // going on
- console.error("exception in animation handler for:", evt);
- console.error(e);
- }
- }
- }
- return this; // Animation
- },
-
- play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
- // summary:
- // Start the animation.
- // delay:
- // How many milliseconds to delay before starting.
- // gotoStart:
- // If true, starts the animation from the beginning; otherwise,
- // starts it from its current position.
- // returns: Animation
- // The instance to allow chaining.
-
- var _t = this;
- if(_t._delayTimer){ _t._clearTimer(); }
- if(gotoStart){
- _t._stopTimer();
- _t._active = _t._paused = false;
- _t._percent = 0;
- }else if(_t._active && !_t._paused){
- return _t;
- }
-
- _t._fire("beforeBegin", [_t.node]);
-
- var de = delay || _t.delay,
- _p = lang.hitch(_t, "_play", gotoStart);
-
- if(de > 0){
- _t._delayTimer = setTimeout(_p, de);
- return _t;
- }
- _p();
- return _t; // Animation
- },
-
- _play: function(gotoStart){
- var _t = this;
- if(_t._delayTimer){ _t._clearTimer(); }
- _t._startTime = new Date().valueOf();
- if(_t._paused){
- _t._startTime -= _t.duration * _t._percent;
- }
-
- _t._active = true;
- _t._paused = false;
- var value = _t.curve.getValue(_t._getStep());
- if(!_t._percent){
- if(!_t._startRepeatCount){
- _t._startRepeatCount = _t.repeat;
- }
- _t._fire("onBegin", [value]);
- }
-
- _t._fire("onPlay", [value]);
-
- _t._cycle();
- return _t; // Animation
- },
-
- pause: function(){
- // summary:
- // Pauses a running animation.
- var _t = this;
- if(_t._delayTimer){ _t._clearTimer(); }
- _t._stopTimer();
- if(!_t._active){ return _t; /*Animation*/ }
- _t._paused = true;
- _t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
- return _t; // Animation
- },
-
- gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
- // summary:
- // Sets the progress of the animation.
- // percent:
- // A percentage in decimal notation (between and including 0.0 and 1.0).
- // andPlay:
- // If true, play the animation after setting the progress.
- var _t = this;
- _t._stopTimer();
- _t._active = _t._paused = true;
- _t._percent = percent;
- if(andPlay){ _t.play(); }
- return _t; // Animation
- },
-
- stop: function(/*boolean?*/ gotoEnd){
- // summary:
- // Stops a running animation.
- // gotoEnd:
- // If true, the animation will end.
- var _t = this;
- if(_t._delayTimer){ _t._clearTimer(); }
- if(!_t._timer){ return _t; /* Animation */ }
- _t._stopTimer();
- if(gotoEnd){
- _t._percent = 1;
- }
- _t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
- _t._active = _t._paused = false;
- return _t; // Animation
- },
-
- destroy: function(){
- // summary:
- // cleanup the animation
- this.stop();
- },
-
- status: function(){
- // summary:
- // Returns a string token representation of the status of
- // the animation, one of: "paused", "playing", "stopped"
- if(this._active){
- return this._paused ? "paused" : "playing"; // String
- }
- return "stopped"; // String
- },
-
- _cycle: function(){
- var _t = this;
- if(_t._active){
- var curr = new Date().valueOf();
- // Allow durations of 0 (instant) by setting step to 1 - see #13798
- var step = _t.duration === 0 ? 1 : (curr - _t._startTime) / (_t.duration);
-
- if(step >= 1){
- step = 1;
- }
- _t._percent = step;
-
- // Perform easing
- if(_t.easing){
- step = _t.easing(step);
- }
-
- _t._fire("onAnimate", [_t.curve.getValue(step)]);
-
- if(_t._percent < 1){
- _t._startTimer();
- }else{
- _t._active = false;
-
- if(_t.repeat > 0){
- _t.repeat--;
- _t.play(null, true);
- }else if(_t.repeat == -1){
- _t.play(null, true);
- }else{
- if(_t._startRepeatCount){
- _t.repeat = _t._startRepeatCount;
- _t._startRepeatCount = 0;
- }
- }
- _t._percent = 0;
- _t._fire("onEnd", [_t.node]);
- !_t.repeat && _t._stopTimer();
- }
- }
- return _t; // Animation
- },
-
- _clearTimer: function(){
- // summary:
- // Clear the play delay timer
- clearTimeout(this._delayTimer);
- delete this._delayTimer;
- }
-
- });
-
- // the local timer, stubbed into all Animation instances
- var ctr = 0,
- timer = null,
- runner = {
- run: function(){}
- };
-
- lang.extend(Animation, {
-
- _startTimer: function(){
- if(!this._timer){
- this._timer = aspect.after(runner, "run", lang.hitch(this, "_cycle"), true);
- ctr++;
- }
- if(!timer){
- timer = setInterval(lang.hitch(runner, "run"), this.rate);
- }
- },
-
- _stopTimer: function(){
- if(this._timer){
- this._timer.remove();
- this._timer = null;
- ctr--;
- }
- if(ctr <= 0){
- clearInterval(timer);
- timer = null;
- ctr = 0;
- }
- }
-
- });
-
- var _makeFadeable =
- has("ie") ? function(node){
- // only set the zoom if the "tickle" value would be the same as the
- // default
- var ns = node.style;
- // don't set the width to auto if it didn't already cascade that way.
- // We don't want to f anyones designs
- if(!ns.width.length && style.get(node, "width") == "auto"){
- ns.width = "auto";
- }
- } :
- function(){};
-
- basefx._fade = function(/*Object*/ args){
- // summary:
- // Returns an animation that will fade the node defined by
- // args.node from the start to end values passed (args.start
- // args.end) (end is mandatory, start is optional)
-
- args.node = dom.byId(args.node);
- var fArgs = _mixin({ properties: {} }, args),
- props = (fArgs.properties.opacity = {});
-
- props.start = !("start" in fArgs) ?
- function(){
- return +style.get(fArgs.node, "opacity")||0;
- } : fArgs.start;
- props.end = fArgs.end;
-
- var anim = basefx.animateProperty(fArgs);
- aspect.after(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node), true);
-
- return anim; // Animation
- };
-
- /*=====
- var __FadeArgs = declare(null, {
- // node: DOMNode|String
- // The node referenced in the animation
- // duration: Integer?
- // Duration of the animation in milliseconds.
- // easing: Function?
- // An easing function.
- });
- =====*/
-
- basefx.fadeIn = function(/*__FadeArgs*/ args){
- // summary:
- // Returns an animation that will fade node defined in 'args' from
- // its current opacity to fully opaque.
- return basefx._fade(_mixin({ end: 1 }, args)); // Animation
- };
-
- basefx.fadeOut = function(/*__FadeArgs*/ args){
- // summary:
- // Returns an animation that will fade node defined in 'args'
- // from its current opacity to fully transparent.
- return basefx._fade(_mixin({ end: 0 }, args)); // Animation
- };
-
- basefx._defaultEasing = function(/*Decimal?*/ n){
- // summary:
- // The default easing function for Animation(s)
- return 0.5 + ((Math.sin((n + 1.5) * Math.PI)) / 2); // Decimal
- };
-
- var PropLine = function(properties){
- // PropLine is an internal class which is used to model the values of
- // an a group of CSS properties across an animation lifecycle. In
- // particular, the "getValue" function handles getting interpolated
- // values between start and end for a particular CSS value.
- this._properties = properties;
- for(var p in properties){
- var prop = properties[p];
- if(prop.start instanceof Color){
- // create a reusable temp color object to keep intermediate results
- prop.tempColor = new Color();
- }
- }
- };
-
- PropLine.prototype.getValue = function(r){
- var ret = {};
- for(var p in this._properties){
- var prop = this._properties[p],
- start = prop.start;
- if(start instanceof Color){
- ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss();
- }else if(!lang.isArray(start)){
- ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0);
- }
- }
- return ret;
- };
-
- /*=====
- var __AnimArgs = declare(__FadeArgs, {
- // properties: Object?
- // A hash map of style properties to Objects describing the transition,
- // such as the properties of _Line with an additional 'units' property
- properties: {}
-
- //TODOC: add event callbacks
- });
- =====*/
-
- basefx.animateProperty = function(/*__AnimArgs*/ args){
- // summary:
- // Returns an animation that will transition the properties of
- // node defined in `args` depending how they are defined in
- // `args.properties`
- //
- // description:
- // Foundation of most `dojo/_base/fx`
- // animations. It takes an object of "properties" corresponding to
- // style properties, and animates them in parallel over a set
- // duration.
- //
- // example:
- // A simple animation that changes the width of the specified node.
- // | basefx.animateProperty({
- // | node: "nodeId",
- // | properties: { width: 400 },
- // | }).play();
- // Dojo figures out the start value for the width and converts the
- // integer specified for the width to the more expressive but
- // verbose form `{ width: { end: '400', units: 'px' } }` which you
- // can also specify directly. Defaults to 'px' if omitted.
- //
- // example:
- // Animate width, height, and padding over 2 seconds... the
- // pedantic way:
- // | basefx.animateProperty({ node: node, duration:2000,
- // | properties: {
- // | width: { start: '200', end: '400', units:"px" },
- // | height: { start:'200', end: '400', units:"px" },
- // | paddingTop: { start:'5', end:'50', units:"px" }
- // | }
- // | }).play();
- // Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
- // are written using "mixed case", as the hyphen is illegal as an object key.
- //
- // example:
- // Plug in a different easing function and register a callback for
- // when the animation ends. Easing functions accept values between
- // zero and one and return a value on that basis. In this case, an
- // exponential-in curve.
- // | basefx.animateProperty({
- // | node: "nodeId",
- // | // dojo figures out the start value
- // | properties: { width: { end: 400 } },
- // | easing: function(n){
- // | return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
- // | },
- // | onEnd: function(node){
- // | // called when the animation finishes. The animation
- // | // target is passed to this function
- // | }
- // | }).play(500); // delay playing half a second
- //
- // example:
- // Like all `Animation`s, animateProperty returns a handle to the
- // Animation instance, which fires the events common to Dojo FX. Use `aspect.after`
- // to access these events outside of the Animation definition:
- // | var anim = basefx.animateProperty({
- // | node:"someId",
- // | properties:{
- // | width:400, height:500
- // | }
- // | });
- // | aspect.after(anim, "onEnd", function(){
- // | console.log("animation ended");
- // | }, true);
- // | // play the animation now:
- // | anim.play();
- //
- // example:
- // Each property can be a function whose return value is substituted along.
- // Additionally, each measurement (eg: start, end) can be a function. The node
- // reference is passed directly to callbacks.
- // | basefx.animateProperty({
- // | node:"mine",
- // | properties:{
- // | height:function(node){
- // | // shrink this node by 50%
- // | return domGeom.position(node).h / 2
- // | },
- // | width:{
- // | start:function(node){ return 100; },
- // | end:function(node){ return 200; }
- // | }
- // | }
- // | }).play();
- //
-
- var n = args.node = dom.byId(args.node);
- if(!args.easing){ args.easing = dojo._defaultEasing; }
-
- var anim = new Animation(args);
- aspect.after(anim, "beforeBegin", lang.hitch(anim, function(){
- var pm = {};
- for(var p in this.properties){
- // Make shallow copy of properties into pm because we overwrite
- // some values below. In particular if start/end are functions
- // we don't want to overwrite them or the functions won't be
- // called if the animation is reused.
- if(p == "width" || p == "height"){
- this.node.display = "block";
- }
- var prop = this.properties[p];
- if(lang.isFunction(prop)){
- prop = prop(n);
- }
- prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop }));
-
- if(lang.isFunction(prop.start)){
- prop.start = prop.start(n);
- }
- if(lang.isFunction(prop.end)){
- prop.end = prop.end(n);
- }
- var isColor = (p.toLowerCase().indexOf("color") >= 0);
- function getStyle(node, p){
- // domStyle.get(node, "height") can return "auto" or "" on IE; this is more reliable:
- var v = { height: node.offsetHeight, width: node.offsetWidth }[p];
- if(v !== undefined){ return v; }
- v = style.get(node, p);
- return (p == "opacity") ? +v : (isColor ? v : parseFloat(v));
- }
- if(!("end" in prop)){
- prop.end = getStyle(n, p);
- }else if(!("start" in prop)){
- prop.start = getStyle(n, p);
- }
-
- if(isColor){
- prop.start = new Color(prop.start);
- prop.end = new Color(prop.end);
- }else{
- prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start);
- }
- }
- this.curve = new PropLine(pm);
- }), true);
- aspect.after(anim, "onAnimate", lang.hitch(style, "set", anim.node), true);
- return anim; // Animation
- };
-
- basefx.anim = function( /*DOMNode|String*/ node,
- /*Object*/ properties,
- /*Integer?*/ duration,
- /*Function?*/ easing,
- /*Function?*/ onEnd,
- /*Integer?*/ delay){
- // summary:
- // A simpler interface to `animateProperty()`, also returns
- // an instance of `Animation` but begins the animation
- // immediately, unlike nearly every other Dojo animation API.
- // description:
- // Simpler (but somewhat less powerful) version
- // of `animateProperty`. It uses defaults for many basic properties
- // and allows for positional parameters to be used in place of the
- // packed "property bag" which is used for other Dojo animation
- // methods.
- //
- // The `Animation` object returned will be already playing, so
- // calling play() on it again is (usually) a no-op.
- // node:
- // a DOM node or the id of a node to animate CSS properties on
- // duration:
- // The number of milliseconds over which the animation
- // should run. Defaults to the global animation default duration
- // (350ms).
- // easing:
- // An easing function over which to calculate acceleration
- // and deceleration of the animation through its duration.
- // A default easing algorithm is provided, but you may
- // plug in any you wish. A large selection of easing algorithms
- // are available in `dojo/fx/easing`.
- // onEnd:
- // A function to be called when the animation finishes
- // running.
- // delay:
- // The number of milliseconds to delay beginning the
- // animation by. The default is 0.
- // example:
- // Fade out a node
- // | basefx.anim("id", { opacity: 0 });
- // example:
- // Fade out a node over a full second
- // | basefx.anim("id", { opacity: 0 }, 1000);
- return basefx.animateProperty({ // Animation
- node: node,
- duration: duration || Animation.prototype.duration,
- properties: properties,
- easing: easing,
- onEnd: onEnd
- }).play(delay || 0);
- };
-
-
- if( 1 ){
- _mixin(dojo, basefx);
- // Alias to drop come 2.0:
- dojo._Animation = Animation;
- }
-
- return basefx;
-});
diff --git a/lib/dojo/_base/html.js b/lib/dojo/_base/html.js
deleted file mode 100644
index ec884b6..0000000
--- a/lib/dojo/_base/html.js
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/html",["./kernel","../dom","../dom-style","../dom-attr","../dom-prop","../dom-class","../dom-construct","../dom-geometry"],function(_1,_2,_3,_4,_5,_6,_7,_8){
-_1.byId=_2.byId;
-_1.isDescendant=_2.isDescendant;
-_1.setSelectable=_2.setSelectable;
-_1.getAttr=_4.get;
-_1.setAttr=_4.set;
-_1.hasAttr=_4.has;
-_1.removeAttr=_4.remove;
-_1.getNodeProp=_4.getNodeProp;
-_1.attr=function(_9,_a,_b){
-if(arguments.length==2){
-return _4[typeof _a=="string"?"get":"set"](_9,_a);
-}
-return _4.set(_9,_a,_b);
-};
-_1.hasClass=_6.contains;
-_1.addClass=_6.add;
-_1.removeClass=_6.remove;
-_1.toggleClass=_6.toggle;
-_1.replaceClass=_6.replace;
-_1._toDom=_1.toDom=_7.toDom;
-_1.place=_7.place;
-_1.create=_7.create;
-_1.empty=function(_c){
-_7.empty(_c);
-};
-_1._destroyElement=_1.destroy=function(_d){
-_7.destroy(_d);
-};
-_1._getPadExtents=_1.getPadExtents=_8.getPadExtents;
-_1._getBorderExtents=_1.getBorderExtents=_8.getBorderExtents;
-_1._getPadBorderExtents=_1.getPadBorderExtents=_8.getPadBorderExtents;
-_1._getMarginExtents=_1.getMarginExtents=_8.getMarginExtents;
-_1._getMarginSize=_1.getMarginSize=_8.getMarginSize;
-_1._getMarginBox=_1.getMarginBox=_8.getMarginBox;
-_1.setMarginBox=_8.setMarginBox;
-_1._getContentBox=_1.getContentBox=_8.getContentBox;
-_1.setContentSize=_8.setContentSize;
-_1._isBodyLtr=_1.isBodyLtr=_8.isBodyLtr;
-_1._docScroll=_1.docScroll=_8.docScroll;
-_1._getIeDocumentElementOffset=_1.getIeDocumentElementOffset=_8.getIeDocumentElementOffset;
-_1._fixIeBiDiScrollLeft=_1.fixIeBiDiScrollLeft=_8.fixIeBiDiScrollLeft;
-_1.position=_8.position;
-_1.marginBox=function marginBox(_e,_f){
-return _f?_8.setMarginBox(_e,_f):_8.getMarginBox(_e);
-};
-_1.contentBox=function contentBox(_10,box){
-return box?_8.setContentSize(_10,box):_8.getContentBox(_10);
-};
-_1.coords=function(_11,_12){
-_1.deprecated("dojo.coords()","Use dojo.position() or dojo.marginBox().");
-_11=_2.byId(_11);
-var s=_3.getComputedStyle(_11),mb=_8.getMarginBox(_11,s);
-var abs=_8.position(_11,_12);
-mb.x=abs.x;
-mb.y=abs.y;
-return mb;
-};
-_1.getProp=_5.get;
-_1.setProp=_5.set;
-_1.prop=function(_13,_14,_15){
-if(arguments.length==2){
-return _5[typeof _14=="string"?"get":"set"](_13,_14);
-}
-return _5.set(_13,_14,_15);
-};
-_1.getStyle=_3.get;
-_1.setStyle=_3.set;
-_1.getComputedStyle=_3.getComputedStyle;
-_1.__toPixelValue=_1.toPixelValue=_3.toPixelValue;
-_1.style=function(_16,_17,_18){
-switch(arguments.length){
-case 1:
-return _3.get(_16);
-case 2:
-return _3[typeof _17=="string"?"get":"set"](_16,_17);
-}
-return _3.set(_16,_17,_18);
-};
-return _1;
-});
diff --git a/lib/dojo/_base/html.js.uncompressed.js b/lib/dojo/_base/html.js.uncompressed.js
deleted file mode 100644
index f439d0d..0000000
--- a/lib/dojo/_base/html.js.uncompressed.js
+++ /dev/null
@@ -1,392 +0,0 @@
-define("dojo/_base/html", ["./kernel", "../dom", "../dom-style", "../dom-attr", "../dom-prop", "../dom-class", "../dom-construct", "../dom-geometry"], function(dojo, dom, style, attr, prop, cls, ctr, geom){
- // module:
- // dojo/dom
-
- /*=====
- return {
- // summary:
- // This module is a stub for the core dojo DOM API.
- };
- =====*/
-
- // mix-in dom
- dojo.byId = dom.byId;
- dojo.isDescendant = dom.isDescendant;
- dojo.setSelectable = dom.setSelectable;
-
- // mix-in dom-attr
- dojo.getAttr = attr.get;
- dojo.setAttr = attr.set;
- dojo.hasAttr = attr.has;
- dojo.removeAttr = attr.remove;
- dojo.getNodeProp = attr.getNodeProp;
-
- dojo.attr = function(node, name, value){
- // summary:
- // Gets or sets an attribute on an HTML element.
- // description:
- // Handles normalized getting and setting of attributes on DOM
- // Nodes. If 2 arguments are passed, and a the second argument is a
- // string, acts as a getter.
- //
- // If a third argument is passed, or if the second argument is a
- // map of attributes, acts as a setter.
- //
- // When passing functions as values, note that they will not be
- // directly assigned to slots on the node, but rather the default
- // behavior will be removed and the new behavior will be added
- // using `dojo.connect()`, meaning that event handler properties
- // will be normalized and that some caveats with regards to
- // non-standard behaviors for onsubmit apply. Namely that you
- // should cancel form submission using `dojo.stopEvent()` on the
- // passed event object instead of returning a boolean value from
- // the handler itself.
- // node: DOMNode|String
- // id or reference to the element to get or set the attribute on
- // name: String|Object
- // the name of the attribute to get or set.
- // value: String?
- // The value to set for the attribute
- // returns:
- // when used as a getter, the value of the requested attribute
- // or null if that attribute does not have a specified or
- // default value;
- //
- // when used as a setter, the DOM node
- //
- // example:
- // | // get the current value of the "foo" attribute on a node
- // | dojo.attr(dojo.byId("nodeId"), "foo");
- // | // or we can just pass the id:
- // | dojo.attr("nodeId", "foo");
- //
- // example:
- // | // use attr() to set the tab index
- // | dojo.attr("nodeId", "tabIndex", 3);
- // |
- //
- // example:
- // Set multiple values at once, including event handlers:
- // | dojo.attr("formId", {
- // | "foo": "bar",
- // | "tabIndex": -1,
- // | "method": "POST",
- // | "onsubmit": function(e){
- // | // stop submitting the form. Note that the IE behavior
- // | // of returning true or false will have no effect here
- // | // since our handler is connect()ed to the built-in
- // | // onsubmit behavior and so we need to use
- // | // dojo.stopEvent() to ensure that the submission
- // | // doesn't proceed.
- // | dojo.stopEvent(e);
- // |
- // | // submit the form with Ajax
- // | dojo.xhrPost({ form: "formId" });
- // | }
- // | });
- //
- // example:
- // Style is s special case: Only set with an object hash of styles
- // | dojo.attr("someNode",{
- // | id:"bar",
- // | style:{
- // | width:"200px", height:"100px", color:"#000"
- // | }
- // | });
- //
- // example:
- // Again, only set style as an object hash of styles:
- // | var obj = { color:"#fff", backgroundColor:"#000" };
- // | dojo.attr("someNode", "style", obj);
- // |
- // | // though shorter to use `dojo.style()` in this case:
- // | dojo.style("someNode", obj);
-
- if(arguments.length == 2){
- return attr[typeof name == "string" ? "get" : "set"](node, name);
- }
- return attr.set(node, name, value);
- };
-
- // mix-in dom-class
- dojo.hasClass = cls.contains;
- dojo.addClass = cls.add;
- dojo.removeClass = cls.remove;
- dojo.toggleClass = cls.toggle;
- dojo.replaceClass = cls.replace;
-
- // mix-in dom-construct
- dojo._toDom = dojo.toDom = ctr.toDom;
- dojo.place = ctr.place;
- dojo.create = ctr.create;
- dojo.empty = function(node){ ctr.empty(node); };
- dojo._destroyElement = dojo.destroy = function(node){ ctr.destroy(node); };
-
- // mix-in dom-geometry
- dojo._getPadExtents = dojo.getPadExtents = geom.getPadExtents;
- dojo._getBorderExtents = dojo.getBorderExtents = geom.getBorderExtents;
- dojo._getPadBorderExtents = dojo.getPadBorderExtents = geom.getPadBorderExtents;
- dojo._getMarginExtents = dojo.getMarginExtents = geom.getMarginExtents;
- dojo._getMarginSize = dojo.getMarginSize = geom.getMarginSize;
- dojo._getMarginBox = dojo.getMarginBox = geom.getMarginBox;
- dojo.setMarginBox = geom.setMarginBox;
- dojo._getContentBox = dojo.getContentBox = geom.getContentBox;
- dojo.setContentSize = geom.setContentSize;
- dojo._isBodyLtr = dojo.isBodyLtr = geom.isBodyLtr;
- dojo._docScroll = dojo.docScroll = geom.docScroll;
- dojo._getIeDocumentElementOffset = dojo.getIeDocumentElementOffset = geom.getIeDocumentElementOffset;
- dojo._fixIeBiDiScrollLeft = dojo.fixIeBiDiScrollLeft = geom.fixIeBiDiScrollLeft;
- dojo.position = geom.position;
-
- dojo.marginBox = function marginBox(/*DomNode|String*/node, /*Object?*/box){
- // summary:
- // Getter/setter for the margin-box of node.
- // description:
- // Getter/setter for the margin-box of node.
- // Returns an object in the expected format of box (regardless
- // if box is passed). The object might look like:
- // `{ l: 50, t: 200, w: 300: h: 150 }`
- // for a node offset from its parent 50px to the left, 200px from
- // the top with a margin width of 300px and a margin-height of
- // 150px.
- // node:
- // id or reference to DOM Node to get/set box for
- // box:
- // If passed, denotes that dojo.marginBox() should
- // update/set the margin box for node. Box is an object in the
- // above format. All properties are optional if passed.
- // example:
- // Retrieve the margin box of a passed node
- // | var box = dojo.marginBox("someNodeId");
- // | console.dir(box);
- //
- // example:
- // Set a node's margin box to the size of another node
- // | var box = dojo.marginBox("someNodeId");
- // | dojo.marginBox("someOtherNode", box);
- return box ? geom.setMarginBox(node, box) : geom.getMarginBox(node); // Object
- };
-
- dojo.contentBox = function contentBox(/*DomNode|String*/node, /*Object?*/box){
- // summary:
- // Getter/setter for the content-box of node.
- // description:
- // Returns an object in the expected format of box (regardless if box is passed).
- // The object might look like:
- // `{ l: 50, t: 200, w: 300: h: 150 }`
- // for a node offset from its parent 50px to the left, 200px from
- // the top with a content width of 300px and a content-height of
- // 150px. Note that the content box may have a much larger border
- // or margin box, depending on the box model currently in use and
- // CSS values set/inherited for node.
- // While the getter will return top and left values, the
- // setter only accepts setting the width and height.
- // node:
- // id or reference to DOM Node to get/set box for
- // box:
- // If passed, denotes that dojo.contentBox() should
- // update/set the content box for node. Box is an object in the
- // above format, but only w (width) and h (height) are supported.
- // All properties are optional if passed.
- return box ? geom.setContentSize(node, box) : geom.getContentBox(node); // Object
- };
-
- dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
- // summary:
- // Deprecated: Use position() for border-box x/y/w/h
- // or marginBox() for margin-box w/h/l/t.
- //
- // Returns an object that measures margin-box (w)idth/(h)eight
- // and absolute position x/y of the border-box. Also returned
- // is computed (l)eft and (t)op values in pixels from the
- // node's offsetParent as returned from marginBox().
- // Return value will be in the form:
- //| { l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
- // Does not act as a setter. If includeScroll is passed, the x and
- // y params are affected as one would expect in dojo.position().
- dojo.deprecated("dojo.coords()", "Use dojo.position() or dojo.marginBox().");
- node = dom.byId(node);
- var s = style.getComputedStyle(node), mb = geom.getMarginBox(node, s);
- var abs = geom.position(node, includeScroll);
- mb.x = abs.x;
- mb.y = abs.y;
- return mb; // Object
- };
-
- // mix-in dom-prop
- dojo.getProp = prop.get;
- dojo.setProp = prop.set;
-
- dojo.prop = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){
- // summary:
- // Gets or sets a property on an HTML element.
- // description:
- // Handles normalized getting and setting of properties on DOM
- // Nodes. If 2 arguments are passed, and a the second argument is a
- // string, acts as a getter.
- //
- // If a third argument is passed, or if the second argument is a
- // map of attributes, acts as a setter.
- //
- // When passing functions as values, note that they will not be
- // directly assigned to slots on the node, but rather the default
- // behavior will be removed and the new behavior will be added
- // using `dojo.connect()`, meaning that event handler properties
- // will be normalized and that some caveats with regards to
- // non-standard behaviors for onsubmit apply. Namely that you
- // should cancel form submission using `dojo.stopEvent()` on the
- // passed event object instead of returning a boolean value from
- // the handler itself.
- // node:
- // id or reference to the element to get or set the property on
- // name:
- // the name of the property to get or set.
- // value:
- // The value to set for the property
- // returns:
- // when used as a getter, the value of the requested property
- // or null if that attribute does not have a specified or
- // default value;
- //
- // when used as a setter, the DOM node
- //
- // example:
- // | // get the current value of the "foo" property on a node
- // | dojo.prop(dojo.byId("nodeId"), "foo");
- // | // or we can just pass the id:
- // | dojo.prop("nodeId", "foo");
- //
- // example:
- // | // use prop() to set the tab index
- // | dojo.prop("nodeId", "tabIndex", 3);
- // |
- //
- // example:
- // Set multiple values at once, including event handlers:
- // | dojo.prop("formId", {
- // | "foo": "bar",
- // | "tabIndex": -1,
- // | "method": "POST",
- // | "onsubmit": function(e){
- // | // stop submitting the form. Note that the IE behavior
- // | // of returning true or false will have no effect here
- // | // since our handler is connect()ed to the built-in
- // | // onsubmit behavior and so we need to use
- // | // dojo.stopEvent() to ensure that the submission
- // | // doesn't proceed.
- // | dojo.stopEvent(e);
- // |
- // | // submit the form with Ajax
- // | dojo.xhrPost({ form: "formId" });
- // | }
- // | });
- //
- // example:
- // Style is s special case: Only set with an object hash of styles
- // | dojo.prop("someNode",{
- // | id:"bar",
- // | style:{
- // | width:"200px", height:"100px", color:"#000"
- // | }
- // | });
- //
- // example:
- // Again, only set style as an object hash of styles:
- // | var obj = { color:"#fff", backgroundColor:"#000" };
- // | dojo.prop("someNode", "style", obj);
- // |
- // | // though shorter to use `dojo.style()` in this case:
- // | dojo.style("someNode", obj);
-
- if(arguments.length == 2){
- return prop[typeof name == "string" ? "get" : "set"](node, name);
- }
- // setter
- return prop.set(node, name, value);
- };
-
- // mix-in dom-style
- dojo.getStyle = style.get;
- dojo.setStyle = style.set;
- dojo.getComputedStyle = style.getComputedStyle;
- dojo.__toPixelValue = dojo.toPixelValue = style.toPixelValue;
-
- dojo.style = function(node, name, value){
- // summary:
- // Accesses styles on a node. If 2 arguments are
- // passed, acts as a getter. If 3 arguments are passed, acts
- // as a setter.
- // description:
- // Getting the style value uses the computed style for the node, so the value
- // will be a calculated value, not just the immediate node.style value.
- // Also when getting values, use specific style names,
- // like "borderBottomWidth" instead of "border" since compound values like
- // "border" are not necessarily reflected as expected.
- // If you want to get node dimensions, use `dojo.marginBox()`,
- // `dojo.contentBox()` or `dojo.position()`.
- // node: DOMNode|String
- // id or reference to node to get/set style for
- // name: String|Object?
- // the style property to set in DOM-accessor format
- // ("borderWidth", not "border-width") or an object with key/value
- // pairs suitable for setting each property.
- // value: String?
- // If passed, sets value on the node for style, handling
- // cross-browser concerns. When setting a pixel value,
- // be sure to include "px" in the value. For instance, top: "200px".
- // Otherwise, in some cases, some browsers will not apply the style.
- // returns:
- // when used as a getter, return the computed style of the node if passing in an ID or node,
- // or return the normalized, computed value for the property when passing in a node and a style property
- // example:
- // Passing only an ID or node returns the computed style object of
- // the node:
- // | dojo.style("thinger");
- // example:
- // Passing a node and a style property returns the current
- // normalized, computed value for that property:
- // | dojo.style("thinger", "opacity"); // 1 by default
- //
- // example:
- // Passing a node, a style property, and a value changes the
- // current display of the node and returns the new computed value
- // | dojo.style("thinger", "opacity", 0.5); // == 0.5
- //
- // example:
- // Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
- // | dojo.style("thinger", {
- // | "opacity": 0.5,
- // | "border": "3px solid black",
- // | "height": "300px"
- // | });
- //
- // example:
- // When the CSS style property is hyphenated, the JavaScript property is camelCased.
- // font-size becomes fontSize, and so on.
- // | dojo.style("thinger",{
- // | fontSize:"14pt",
- // | letterSpacing:"1.2em"
- // | });
- //
- // example:
- // dojo/NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
- // dojo.style() on every element of the list. See: `dojo/query` and `dojo/NodeList`
- // | dojo.query(".someClassName").style("visibility","hidden");
- // | // or
- // | dojo.query("#baz > div").style({
- // | opacity:0.75,
- // | fontSize:"13pt"
- // | });
-
- switch(arguments.length){
- case 1:
- return style.get(node);
- case 2:
- return style[typeof name == "string" ? "get" : "set"](node, name);
- }
- // setter
- return style.set(node, name, value);
- };
-
- return dojo;
-});
diff --git a/lib/dojo/_base/json.js b/lib/dojo/_base/json.js
deleted file mode 100644
index b4d4b71..0000000
--- a/lib/dojo/_base/json.js
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/json",["./kernel","../json"],function(_1,_2){
-_1.fromJson=function(js){
-return eval("("+js+")");
-};
-_1._escapeString=_2.stringify;
-_1.toJsonIndentStr="\t";
-_1.toJson=function(it,_3){
-return _2.stringify(it,function(_4,_5){
-if(_5){
-var tf=_5.__json__||_5.json;
-if(typeof tf=="function"){
-return tf.call(_5);
-}
-}
-return _5;
-},_3&&_1.toJsonIndentStr);
-};
-return _1;
-});
diff --git a/lib/dojo/_base/json.js.uncompressed.js b/lib/dojo/_base/json.js.uncompressed.js
deleted file mode 100644
index 525c048..0000000
--- a/lib/dojo/_base/json.js.uncompressed.js
+++ /dev/null
@@ -1,91 +0,0 @@
-define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){
-
-// module:
-// dojo/_base/json
-
-/*=====
-return {
- // summary:
- // This module defines the dojo JSON API.
-};
-=====*/
-
-dojo.fromJson = function(/*String*/ js){
- // summary:
- // Parses a JavaScript expression and returns a JavaScript value.
- // description:
- // Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It
- // always delegates to eval(). The content passed to this method must therefore come
- // from a trusted source.
- // It is recommend that you use dojo/json's parse function for an
- // implementation uses the (faster) native JSON parse when available.
- // js:
- // a string literal of a JavaScript expression, for instance:
- // `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
-
- return eval("(" + js + ")"); // Object
-};
-
-/*=====
-dojo._escapeString = function(){
- // summary:
- // Adds escape sequences for non-visual characters, double quote and
- // backslash and surrounds with double quotes to form a valid string
- // literal.
-};
-=====*/
-dojo._escapeString = json.stringify; // just delegate to json.stringify
-
-dojo.toJsonIndentStr = "\t";
-dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){
- // summary:
- // Returns a [JSON](http://json.org) serialization of an object.
- // description:
- // Returns a [JSON](http://json.org) serialization of an object.
- // Note that this doesn't check for infinite recursion, so don't do that!
- // It is recommend that you use dojo/json's stringify function for an lighter
- // and faster implementation that matches the native JSON API and uses the
- // native JSON serializer when available.
- // it:
- // an object to be serialized. Objects may define their own
- // serialization via a special "__json__" or "json" function
- // property. If a specialized serializer has been defined, it will
- // be used as a fallback.
- // Note that in 1.6, toJson would serialize undefined, but this no longer supported
- // since it is not supported by native JSON serializer.
- // prettyPrint:
- // if true, we indent objects and arrays to make the output prettier.
- // The variable `dojo.toJsonIndentStr` is used as the indent string --
- // to use something other than the default (tab), change that variable
- // before calling dojo.toJson().
- // Note that if native JSON support is available, it will be used for serialization,
- // and native implementations vary on the exact spacing used in pretty printing.
- // returns:
- // A JSON string serialization of the passed-in object.
- // example:
- // simple serialization of a trivial object
- // | var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
- // | doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
- // example:
- // a custom serializer for an objects of a particular class:
- // | dojo.declare("Furby", null, {
- // | furbies: "are strange",
- // | furbyCount: 10,
- // | __json__: function(){
- // | },
- // | });
-
- // use dojo/json
- return json.stringify(it, function(key, value){
- if(value){
- var tf = value.__json__||value.json;
- if(typeof tf == "function"){
- return tf.call(value);
- }
- }
- return value;
- }, prettyPrint && dojo.toJsonIndentStr); // String
-};
-
-return dojo;
-});
diff --git a/lib/dojo/_base/kernel.js b/lib/dojo/_base/kernel.js
deleted file mode 100644
index 94fc9e7..0000000
--- a/lib/dojo/_base/kernel.js
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/kernel",["../has","./config","require","module"],function(_1,_2,_3,_4){
-var i,p,_5={},_6={},_7={config:_2,global:this,dijit:_5,dojox:_6};
-var _8={dojo:["dojo",_7],dijit:["dijit",_5],dojox:["dojox",_6]},_9=(_3.map&&_3.map[_4.id.match(/[^\/]+/)[0]]),_a;
-for(p in _9){
-if(_8[p]){
-_8[p][0]=_9[p];
-}else{
-_8[p]=[_9[p],{}];
-}
-}
-for(p in _8){
-_a=_8[p];
-_a[1]._scopeName=_a[0];
-if(!_2.noGlobals){
-this[_a[0]]=_a[1];
-}
-}
-_7.scopeMap=_8;
-_7.baseUrl=_7.config.baseUrl=_3.baseUrl;
-_7.isAsync=!1||_3.async;
-_7.locale=_2.locale;
-var _b="$Rev: e124479 $".match(/[0-9a-f]{7,}/);
-_7.version={major:1,minor:10,patch:0,flag:"",revision:_b?_b[0]:NaN,toString:function(){
-var v=_7.version;
-return v.major+"."+v.minor+"."+v.patch+v.flag+" ("+v.revision+")";
-}};
-1||_1.add("extend-dojo",1);
-(Function("d","d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(_7);
-if(0){
-_7.exit=function(_c){
-quit(_c);
-};
-}else{
-_7.exit=function(){
-};
-}
-1||_1.add("dojo-guarantee-console",1);
-if(1){
-typeof console!="undefined"||(console={});
-var cn=["assert","count","debug","dir","dirxml","error","group","groupEnd","info","profile","profileEnd","time","timeEnd","trace","warn","log"];
-var tn;
-i=0;
-while((tn=cn[i++])){
-if(!console[tn]){
-(function(){
-var _d=tn+"";
-console[_d]=("log" in console)?function(){
-var a=Array.prototype.slice.call(arguments);
-a.unshift(_d+":");
-console["log"](a.join(" "));
-}:function(){
-};
-console[_d]._fake=true;
-})();
-}
-}
-}
-_1.add("dojo-debug-messages",!!_2.isDebug);
-_7.deprecated=_7.experimental=function(){
-};
-if(_1("dojo-debug-messages")){
-_7.deprecated=function(_e,_f,_10){
-var _11="DEPRECATED: "+_e;
-if(_f){
-_11+=" "+_f;
-}
-if(_10){
-_11+=" -- will be removed in version: "+_10;
-}
-console.warn(_11);
-};
-_7.experimental=function(_12,_13){
-var _14="EXPERIMENTAL: "+_12+" -- APIs subject to change without notice.";
-if(_13){
-_14+=" "+_13;
-}
-console.warn(_14);
-};
-}
-1||_1.add("dojo-modulePaths",1);
-if(1){
-if(_2.modulePaths){
-_7.deprecated("dojo.modulePaths","use paths configuration");
-var _15={};
-for(p in _2.modulePaths){
-_15[p.replace(/\./g,"/")]=_2.modulePaths[p];
-}
-_3({paths:_15});
-}
-}
-1||_1.add("dojo-moduleUrl",1);
-if(1){
-_7.moduleUrl=function(_16,url){
-_7.deprecated("dojo.moduleUrl()","use require.toUrl","2.0");
-var _17=null;
-if(_16){
-_17=_3.toUrl(_16.replace(/\./g,"/")+(url?("/"+url):"")+"/*.*").replace(/\/\*\.\*/,"")+(url?"":"/");
-}
-return _17;
-};
-}
-_7._hasResource={};
-return _7;
-});
diff --git a/lib/dojo/_base/kernel.js.uncompressed.js b/lib/dojo/_base/kernel.js.uncompressed.js
deleted file mode 100644
index 42a8c1b..0000000
--- a/lib/dojo/_base/kernel.js.uncompressed.js
+++ /dev/null
@@ -1,299 +0,0 @@
-define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
- // module:
- // dojo/_base/kernel
-
- // This module is the foundational module of the dojo boot sequence; it defines the dojo object.
-
- var
- // loop variables for this module
- i, p,
-
- // create dojo, dijit, and dojox
- // FIXME: in 2.0 remove dijit, dojox being created by dojo
- dijit = {},
- dojox = {},
- dojo = {
- // summary:
- // This module is the foundational module of the dojo boot sequence; it defines the dojo object.
-
- // notice dojo takes ownership of the value of the config module
- config:config,
- global:this,
- dijit:dijit,
- dojox:dojox
- };
-
-
- // Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
- // a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
- // unique names in the global space.
- //
- // Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
- // where global when in fact they are either global under different names or not global at all. In v1.6-, the
- // config variable "scopeMap" was used to map names as used within a module to global names. This has been
- // subsumed by the AMD map configuration variable which can relocate packages to different names. For backcompat,
- // only the "*" mapping is supported. See http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
- //
- // The following computations contort the packageMap for this dojo instance into a scopeMap.
- var scopeMap =
- // a map from a name used in a legacy module to the (global variable name, object addressed by that name)
- // always map dojo, dijit, and dojox
- {
- dojo:["dojo", dojo],
- dijit:["dijit", dijit],
- dojox:["dojox", dojox]
- },
-
- packageMap =
- // the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
- (require.map && require.map[module.id.match(/[^\/]+/)[0]]),
-
- item;
-
-
- // process all mapped top-level names for this instance of dojo
- for(p in packageMap){
- if(scopeMap[p]){
- // mapped dojo, dijit, or dojox
- scopeMap[p][0] = packageMap[p];
- }else{
- // some other top-level name
- scopeMap[p] = [packageMap[p], {}];
- }
- }
-
- // publish those names to _scopeName and, optionally, the global namespace
- for(p in scopeMap){
- item = scopeMap[p];
- item[1]._scopeName = item[0];
- if(!config.noGlobals){
- this[item[0]] = item[1];
- }
- }
- dojo.scopeMap = scopeMap;
-
- /*===== dojo.__docParserConfigureScopeMap(scopeMap); =====*/
-
- // FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
- dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
- dojo.isAsync = ! 1 || require.async;
- dojo.locale = config.locale;
-
- var rev = "$Rev: e124479 $".match(/[0-9a-f]{7,}/);
- dojo.version = {
- // summary:
- // Version number of the Dojo Toolkit
- // description:
- // Hash about the version, including
- //
- // - major: Integer: Major version. If total version is "1.2.0beta1", will be 1
- // - minor: Integer: Minor version. If total version is "1.2.0beta1", will be 2
- // - patch: Integer: Patch version. If total version is "1.2.0beta1", will be 0
- // - flag: String: Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
- // - revision: Number: The Git rev from which dojo was pulled
-
- major: 1, minor: 10, patch: 0, flag: "",
- revision: rev ? rev[0] : NaN,
- toString: function(){
- var v = dojo.version;
- return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")"; // String
- }
- };
-
- // If 1 is truthy, then as a dojo module is defined it should push it's definitions
- // into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
- // as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
- // is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
- 1 || has.add("extend-dojo", 1);
-
-
- (Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
- /*=====
- dojo.eval = function(scriptText){
- // summary:
- // A legacy method created for use exclusively by internal Dojo methods. Do not use this method
- // directly unless you understand its possibly-different implications on the platforms your are targeting.
- // description:
- // Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
- // that support indirect eval.
- //
- // As usual, IE does not. On IE, the only way to implement global eval is to
- // use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
- // This implementation uses the technique of executing eval in the scope of a function that is a single scope
- // frame below the global scope; thereby coming close to the global scope. Note carefully that
- //
- // dojo.eval("var pi = 3.14;");
- //
- // will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
- // to define a global variable using dojo.eval, write something like
- //
- // dojo.eval("window.pi = 3.14;")
- // scriptText:
- // The text to evaluation.
- // returns:
- // The result of the evaluation. Often `undefined`
- };
- =====*/
-
-
- if( 0 ){
- dojo.exit = function(exitcode){
- quit(exitcode);
- };
- }else{
- dojo.exit = function(){
- };
- }
-
- 1 || has.add("dojo-guarantee-console",
- // ensure that console.log, console.warn, etc. are defined
- 1
- );
- if( 1 ){
- typeof console != "undefined" || (console = {});
- // Be careful to leave 'log' always at the end
- var cn = [
- "assert", "count", "debug", "dir", "dirxml", "error", "group",
- "groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
- "trace", "warn", "log"
- ];
- var tn;
- i = 0;
- while((tn = cn[i++])){
- if(!console[tn]){
- (function(){
- var tcn = tn + "";
- console[tcn] = ('log' in console) ? function(){
- var a = Array.prototype.slice.call(arguments);
- a.unshift(tcn + ":");
- console["log"](a.join(" "));
- } : function(){};
- console[tcn]._fake = true;
- })();
- }
- }
- }
-
- has.add("dojo-debug-messages",
- // include dojo.deprecated/dojo.experimental implementations
- !!config.isDebug
- );
- dojo.deprecated = dojo.experimental = function(){};
- if(has("dojo-debug-messages")){
- dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
- // summary:
- // Log a debug message to indicate that a behavior has been
- // deprecated.
- // behaviour: String
- // The API or behavior being deprecated. Usually in the form
- // of "myApp.someFunction()".
- // extra: String?
- // Text to append to the message. Often provides advice on a
- // new function or facility to achieve the same goal during
- // the deprecation period.
- // removal: String?
- // Text to indicate when in the future the behavior will be
- // removed. Usually a version number.
- // example:
- // | dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
-
- var message = "DEPRECATED: " + behaviour;
- if(extra){ message += " " + extra; }
- if(removal){ message += " -- will be removed in version: " + removal; }
- console.warn(message);
- };
-
- dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
- // summary:
- // Marks code as experimental.
- // description:
- // This can be used to mark a function, file, or module as
- // experimental. Experimental code is not ready to be used, and the
- // APIs are subject to change without notice. Experimental code may be
- // completed deleted without going through the normal deprecation
- // process.
- // moduleName: String
- // The name of a module, or the name of a module file or a specific
- // function
- // extra: String?
- // some additional message for the user
- // example:
- // | dojo.experimental("dojo.data.Result");
- // example:
- // | dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
-
- var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
- if(extra){ message += " " + extra; }
- console.warn(message);
- };
- }
-
- 1 || has.add("dojo-modulePaths",
- // consume dojo.modulePaths processing
- 1
- );
- if( 1 ){
- // notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
- // this is the v1.6- behavior.
- if(config.modulePaths){
- dojo.deprecated("dojo.modulePaths", "use paths configuration");
- var paths = {};
- for(p in config.modulePaths){
- paths[p.replace(/\./g, "/")] = config.modulePaths[p];
- }
- require({paths:paths});
- }
- }
-
- 1 || has.add("dojo-moduleUrl",
- // include dojo.moduleUrl
- 1
- );
- if( 1 ){
- dojo.moduleUrl = function(/*String*/module, /*String?*/url){
- // summary:
- // Returns a URL relative to a module.
- // example:
- // | var pngPath = dojo.moduleUrl("acme","images/small.png");
- // | console.dir(pngPath); // list the object properties
- // | // create an image and set it's source to pngPath's value:
- // | var img = document.createElement("img");
- // | img.src = pngPath;
- // | // add our image to the document
- // | dojo.body().appendChild(img);
- // example:
- // you may de-reference as far as you like down the package
- // hierarchy. This is sometimes handy to avoid lengthy relative
- // urls or for building portable sub-packages. In this example,
- // the `acme.widget` and `acme.util` directories may be located
- // under different roots (see `dojo.registerModulePath`) but the
- // the modules which reference them can be unaware of their
- // relative locations on the filesystem:
- // | // somewhere in a configuration block
- // | dojo.registerModulePath("acme.widget", "../../acme/widget");
- // | dojo.registerModulePath("acme.util", "../../util");
- // |
- // | // ...
- // |
- // | // code in a module using acme resources
- // | var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
- // | var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
-
- dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
-
- // require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
- // remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
- // rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
- // Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
- var result = null;
- if(module){
- result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
- }
- return result;
- };
- }
-
- dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
-
- return dojo;
-});
diff --git a/lib/dojo/_base/lang.js b/lib/dojo/_base/lang.js
deleted file mode 100644
index a65b081..0000000
--- a/lib/dojo/_base/lang.js
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/lang",["./kernel","../has","../sniff"],function(_1,_2){
-_2.add("bug-for-in-skips-shadowed",function(){
-for(var i in {toString:1}){
-return 0;
-}
-return 1;
-});
-var _3=_2("bug-for-in-skips-shadowed")?"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split("."):[],_4=_3.length,_5=function(_6,_7,_8){
-if(!_8){
-if(_6[0]&&_1.scopeMap[_6[0]]){
-_8=_1.scopeMap[_6.shift()][1];
-}else{
-_8=_1.global;
-}
-}
-try{
-for(var i=0;i<_6.length;i++){
-var p=_6[i];
-if(!(p in _8)){
-if(_7){
-_8[p]={};
-}else{
-return;
-}
-}
-_8=_8[p];
-}
-return _8;
-}
-catch(e){
-}
-},_9=Object.prototype.toString,_a=function(_b,_c,_d){
-return (_d||[]).concat(Array.prototype.slice.call(_b,_c||0));
-},_e=/\{([^\}]+)\}/g;
-var _f={_extraNames:_3,_mixin:function(_10,_11,_12){
-var _13,s,i,_14={};
-for(_13 in _11){
-s=_11[_13];
-if(!(_13 in _10)||(_10[_13]!==s&&(!(_13 in _14)||_14[_13]!==s))){
-_10[_13]=_12?_12(s):s;
-}
-}
-if(_2("bug-for-in-skips-shadowed")){
-if(_11){
-for(i=0;i<_4;++i){
-_13=_3[i];
-s=_11[_13];
-if(!(_13 in _10)||(_10[_13]!==s&&(!(_13 in _14)||_14[_13]!==s))){
-_10[_13]=_12?_12(s):s;
-}
-}
-}
-}
-return _10;
-},mixin:function(_15,_16){
-if(!_15){
-_15={};
-}
-for(var i=1,l=arguments.length;i2){
-return _f._hitchArgs.apply(_1,arguments);
-}
-if(!_26){
-_26=_25;
-_25=null;
-}
-if(_f.isString(_26)){
-_25=_25||_1.global;
-if(!_25[_26]){
-throw (["lang.hitch: scope[\"",_26,"\"] is null (scope=\"",_25,"\")"].join(""));
-}
-return function(){
-return _25[_26].apply(_25,arguments||[]);
-};
-}
-return !_25?_26:function(){
-return _26.apply(_25,arguments||[]);
-};
-},delegate:(function(){
-function TMP(){
-};
-return function(obj,_27){
-TMP.prototype=obj;
-var tmp=new TMP();
-TMP.prototype=null;
-if(_27){
-_f._mixin(tmp,_27);
-}
-return tmp;
-};
-})(),_toArray:_2("ie")?(function(){
-function _28(obj,_29,_2a){
-var arr=_2a||[];
-for(var x=_29||0;x 2){
- return lang._hitchArgs.apply(dojo, arguments); // Function
- }
- if(!method){
- method = scope;
- scope = null;
- }
- if(lang.isString(method)){
- scope = scope || dojo.global;
- if(!scope[method]){ throw(['lang.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
- return function(){ return scope[method].apply(scope, arguments || []); }; // Function
- }
- return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
- },
-
- delegate: (function(){
- // boodman/crockford delegation w/ cornford optimization
- function TMP(){}
- return function(obj, props){
- TMP.prototype = obj;
- var tmp = new TMP();
- TMP.prototype = null;
- if(props){
- lang._mixin(tmp, props);
- }
- return tmp; // Object
- };
- })(),
- /*=====
- delegate: function(obj, props){
- // summary:
- // Returns a new object which "looks" to obj for properties which it
- // does not have a value for. Optionally takes a bag of properties to
- // seed the returned object with initially.
- // description:
- // This is a small implementation of the Boodman/Crockford delegation
- // pattern in JavaScript. An intermediate object constructor mediates
- // the prototype chain for the returned object, using it to delegate
- // down to obj for property lookup when object-local lookup fails.
- // This can be thought of similarly to ES4's "wrap", save that it does
- // not act on types but rather on pure objects.
- // obj: Object
- // The object to delegate to for properties not found directly on the
- // return object or in props.
- // props: Object...
- // an object containing properties to assign to the returned object
- // returns:
- // an Object of anonymous type
- // example:
- // | var foo = { bar: "baz" };
- // | var thinger = lang.delegate(foo, { thud: "xyzzy"});
- // | thinger.bar == "baz"; // delegated to foo
- // | foo.thud == undefined; // by definition
- // | thinger.thud == "xyzzy"; // mixed in from props
- // | foo.bar = "thonk";
- // | thinger.bar == "thonk"; // still delegated to foo's bar
- },
- =====*/
-
- _toArray: has("ie") ?
- (function(){
- function slow(obj, offset, startWith){
- var arr = startWith||[];
- for(var x = offset || 0; x < obj.length; x++){
- arr.push(obj[x]);
- }
- return arr;
- }
- return function(obj){
- return ((obj.item) ? slow : efficient).apply(this, arguments);
- };
- })() : efficient,
- /*=====
- _toArray: function(obj, offset, startWith){
- // summary:
- // Converts an array-like object (i.e. arguments, DOMCollection) to an
- // array. Returns a new Array with the elements of obj.
- // obj: Object
- // the object to "arrayify". We expect the object to have, at a
- // minimum, a length property which corresponds to integer-indexed
- // properties.
- // offset: Number?
- // the location in obj to start iterating from. Defaults to 0.
- // Optional.
- // startWith: Array?
- // An array to pack with the properties of obj. If provided,
- // properties in obj are appended at the end of startWith and
- // startWith is the returned array.
- },
- =====*/
-
- partial: function(/*Function|String*/ method /*, ...*/){
- // summary:
- // similar to hitch() except that the scope object is left to be
- // whatever the execution context eventually becomes.
- // description:
- // Calling lang.partial is the functional equivalent of calling:
- // | lang.hitch(null, funcName, ...);
- // method:
- // The function to "wrap"
- var arr = [ null ];
- return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
- },
-
- clone: function(/*anything*/ src){
- // summary:
- // Clones objects (including DOM nodes) and all children.
- // Warning: do not clone cyclic structures.
- // src:
- // The object to clone
- if(!src || typeof src != "object" || lang.isFunction(src)){
- // null, undefined, any non-object, or function
- return src; // anything
- }
- if(src.nodeType && "cloneNode" in src){
- // DOM Node
- return src.cloneNode(true); // Node
- }
- if(src instanceof Date){
- // Date
- return new Date(src.getTime()); // Date
- }
- if(src instanceof RegExp){
- // RegExp
- return new RegExp(src); // RegExp
- }
- var r, i, l;
- if(lang.isArray(src)){
- // array
- r = [];
- for(i = 0, l = src.length; i < l; ++i){
- if(i in src){
- r.push(lang.clone(src[i]));
- }
- }
- // we don't clone functions for performance reasons
- // }else if(d.isFunction(src)){
- // // function
- // r = function(){ return src.apply(this, arguments); };
- }else{
- // generic objects
- r = src.constructor ? new src.constructor() : {};
- }
- return lang._mixin(r, src, lang.clone);
- },
-
-
- trim: String.prototype.trim ?
- function(str){ return str.trim(); } :
- function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
- /*=====
- trim: function(str){
- // summary:
- // Trims whitespace from both sides of the string
- // str: String
- // String to be trimmed
- // returns: String
- // Returns the trimmed string
- // description:
- // This version of trim() was selected for inclusion into the base due
- // to its compact size and relatively good performance
- // (see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
- // Uses String.prototype.trim instead, if available.
- // The fastest but longest version of this function is located at
- // lang.string.trim()
- },
- =====*/
-
- replace: function(tmpl, map, pattern){
- // summary:
- // Performs parameterized substitutions on a string. Throws an
- // exception if any parameter is unmatched.
- // tmpl: String
- // String to be used as a template.
- // map: Object|Function
- // If an object, it is used as a dictionary to look up substitutions.
- // If a function, it is called for every substitution with following parameters:
- // a whole match, a name, an offset, and the whole template
- // string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
- // for more details).
- // pattern: RegEx?
- // Optional regular expression objects that overrides the default pattern.
- // Must be global and match one item. The default is: /\{([^\}]+)\}/g,
- // which matches patterns like that: "{xxx}", where "xxx" is any sequence
- // of characters, which doesn't include "}".
- // returns: String
- // Returns the substituted string.
- // example:
- // | // uses a dictionary for substitutions:
- // | lang.replace("Hello, {name.first} {name.last} AKA {nick}!",
- // | {
- // | nick: "Bob",
- // | name: {
- // | first: "Robert",
- // | middle: "X",
- // | last: "Cringely"
- // | }
- // | });
- // | // returns: Hello, Robert Cringely AKA Bob!
- // example:
- // | // uses an array for substitutions:
- // | lang.replace("Hello, {0} {2}!",
- // | ["Robert", "X", "Cringely"]);
- // | // returns: Hello, Robert Cringely!
- // example:
- // | // uses a function for substitutions:
- // | function sum(a){
- // | var t = 0;
- // | arrayforEach(a, function(x){ t += x; });
- // | return t;
- // | }
- // | lang.replace(
- // | "{count} payments averaging {avg} USD per payment.",
- // | lang.hitch(
- // | { payments: [11, 16, 12] },
- // | function(_, key){
- // | switch(key){
- // | case "count": return this.payments.length;
- // | case "min": return Math.min.apply(Math, this.payments);
- // | case "max": return Math.max.apply(Math, this.payments);
- // | case "sum": return sum(this.payments);
- // | case "avg": return sum(this.payments) / this.payments.length;
- // | }
- // | }
- // | )
- // | );
- // | // prints: 3 payments averaging 13 USD per payment.
- // example:
- // | // uses an alternative PHP-like pattern for substitutions:
- // | lang.replace("Hello, ${0} ${2}!",
- // | ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
- // | // returns: Hello, Robert Cringely!
-
- return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
- map : function(_, k){ return lang.getObject(k, false, map); });
- }
- };
-
- 1 && lang.mixin(dojo, lang);
-
- return lang;
-});
-
diff --git a/lib/dojo/_base/loader.js b/lib/dojo/_base/loader.js
deleted file mode 100644
index 41fcb5d..0000000
--- a/lib/dojo/_base/loader.js
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/loader",["./kernel","../has","require","module","../json","./lang","./array"],function(_1,_2,_3,_4,_5,_6,_7){
-if(!1){
-console.error("cannot load the Dojo v1.x loader with a foreign loader");
-return 0;
-}
-1||_2.add("dojo-fast-sync-require",1);
-var _8=function(id){
-return {src:_4.id,id:id};
-},_9=function(_a){
-return _a.replace(/\./g,"/");
-},_b=/\/\/>>built/,_c=[],_d=[],_e=function(_f,_10,_11){
-_c.push(_11);
-_7.forEach(_f.split(","),function(mid){
-var _12=_13(mid,_10.module);
-_d.push(_12);
-_14(_12);
-});
-_15();
-},_15=(1?function(){
-var _16,mid;
-for(mid in _17){
-_16=_17[mid];
-if(_16.noReqPluginCheck===undefined){
-_16.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;
-}
-if(!_16.executed&&!_16.noReqPluginCheck&&_16.injected==_18){
-return;
-}
-}
-_19(function(){
-var _1a=_c;
-_c=[];
-_7.forEach(_1a,function(cb){
-cb(1);
-});
-});
-}:(function(){
-var _1b,_1c=function(m){
-_1b[m.mid]=1;
-for(var t,_1d,_1e=m.deps||[],i=0;i<_1e.length;i++){
-_1d=_1e[i];
-if(!(t=_1b[_1d.mid])){
-if(t===0||!_1c(_1d)){
-_1b[m.mid]=0;
-return false;
-}
-}
-}
-return true;
-};
-return function(){
-var _1f,mid;
-_1b={};
-for(mid in _17){
-_1f=_17[mid];
-if(_1f.executed||_1f.noReqPluginCheck){
-_1b[mid]=1;
-}else{
-if(_1f.noReqPluginCheck!==0){
-_1f.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;
-}
-if(_1f.noReqPluginCheck){
-_1b[mid]=1;
-}else{
-if(_1f.injected!==_51){
-_1b[mid]=0;
-}
-}
-}
-}
-for(var t,i=0,end=_d.length;i>pure-amd
-
- if (! 1 ){
- console.error("cannot load the Dojo v1.x loader with a foreign loader");
- return 0;
- }
-
- 1 || has.add("dojo-fast-sync-require", 1);
-
-
- var makeErrorToken = function(id){
- return {src:thisModule.id, id:id};
- },
-
- slashName = function(name){
- return name.replace(/\./g, "/");
- },
-
- buildDetectRe = /\/\/>>built/,
-
- dojoRequireCallbacks = [],
- dojoRequireModuleStack = [],
-
- dojoRequirePlugin = function(mid, require, loaded){
- dojoRequireCallbacks.push(loaded);
- array.forEach(mid.split(","), function(mid){
- var module = getModule(mid, require.module);
- dojoRequireModuleStack.push(module);
- injectModule(module);
- });
- checkDojoRequirePlugin();
- },
-
- checkDojoRequirePlugin = ( 1 ?
- // This version of checkDojoRequirePlugin makes the observation that all dojoRequireCallbacks can be released
- // when all *non-dojo/require!, dojo/loadInit!* modules are either executed, not requested, or arrived. This is
- // the case since there are no more modules the loader is waiting for, therefore, dojo/require! must have
- // everything it needs on board.
- //
- // The potential weakness of this algorithm is that dojo/require will not execute callbacks until *all* dependency
- // trees are ready. It is possible that some trees may be ready earlier than others, and this extra wait is non-optimal.
- // Still, for big projects, this seems better than the original algorithm below that proved slow in some cases.
- // Note, however, the original algorithm had the potential to execute partial trees, but that potential was never enabled.
- // There are also other optimization available with the original algorithm that have not been explored.
- function(){
- var module, mid;
- for(mid in modules){
- module = modules[mid];
- if(module.noReqPluginCheck===undefined){
- // tag the module as either a loadInit or require plugin or not for future reference
- module.noReqPluginCheck = /loadInit\!/.test(mid) || /require\!/.test(mid) ? 1 : 0;
- }
- if(!module.executed && !module.noReqPluginCheck && module.injected==requested){
- return;
- }
- }
-
- guardCheckComplete(function(){
- var oldCallbacks = dojoRequireCallbacks;
- dojoRequireCallbacks = [];
- array.forEach(oldCallbacks, function(cb){cb(1);});
- });
- } : (function(){
- // Note: this is the original checkDojoRequirePlugin that is much slower than the algorithm above. However, we know it
- // works, so we leave it here in case the algorithm above fails in some corner case.
- //
- // checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require! dependency
- // to see if they have arrived. The loader does not release *any* of these modules to be instantiated
- // until *all* of these modules are on board, thereby preventing the evaluation of a module with dojo.require's
- // that reference modules that are not available.
- //
- // The algorithm works by traversing the dependency graphs (remember, there can be cycles so they are not trees)
- // of each module in the dojoRequireModuleStack array (which contains the list of modules demanded by dojo/require!).
- // The moment a single module is discovered that is missing, the algorithm gives up and indicates that not all
- // modules are on board. dojo/loadInit! and dojo/require! are ignored because there dependencies are inserted
- // directly in dojoRequireModuleStack. For example, if "your/module" module depends on "dojo/require!my/module", then
- // *both* "dojo/require!my/module" and "my/module" will be in dojoRequireModuleStack. Obviously, if "my/module"
- // is on board, then "dojo/require!my/module" is also satisfied, so the algorithm doesn't check for "dojo/require!my/module".
- //
- // Note: inserting a dojo/require! dependency in the dojoRequireModuleStack achieves nothing
- // with the current algorithm; however, having such modules present makes it possible to optimize the algorithm
- //
- // Note: prior versions of this algorithm had an optimization that signaled loaded on dojo/require! dependencies
- // individually (rather than waiting for them all to be resolved). The implementation proved problematic with cycles
- // and plugins. However, it is possible to reattach that strategy in the future.
-
- // a set from module-id to {undefined | 1 | 0}, where...
- // undefined => the module has not been inspected
- // 0 => the module or at least one of its dependencies has not arrived
- // 1 => the module is a loadInit! or require! plugin resource, or is currently being traversed (therefore, assume
- // OK until proven otherwise), or has been completely traversed and all dependencies have arrived
-
- var touched,
- traverse = function(m){
- touched[m.mid] = 1;
- for(var t, module, deps = m.deps || [], i= 0; i a built module, always AMD
- // extractResult==0 => no sync API
- return 0;
- }
-
- // manufacture a synthetic module id that can never be a real mdule id (just like require does)
- id = module.mid + "-*loadInit";
-
- // construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
- // the dojo/loadInit plugin assumes the first name in names is "dojo"
-
- for(var p in getModule("dojo", module).result.scopeMap){
- names.push(p);
- namesAsStrings.push('"' + p + '"');
- }
-
- // rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
- // don't have to map dojo/init since that will occur when the dependency is resolved
- return "// xdomain rewrite of " + module.mid + "\n" +
- "define('" + id + "',{\n" +
- "\tnames:" + json.stringify(names) + ",\n" +
- "\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
- "});\n\n" +
- "define(" + json.stringify(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
- },
-
- loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
-
- sync =
- loaderVars.sync,
-
- requested =
- loaderVars.requested,
-
- arrived =
- loaderVars.arrived,
-
- nonmodule =
- loaderVars.nonmodule,
-
- executing =
- loaderVars.executing,
-
- executed =
- loaderVars.executed,
-
- syncExecStack =
- loaderVars.syncExecStack,
-
- modules =
- loaderVars.modules,
-
- execQ =
- loaderVars.execQ,
-
- getModule =
- loaderVars.getModule,
-
- injectModule =
- loaderVars.injectModule,
-
- setArrived =
- loaderVars.setArrived,
-
- signal =
- loaderVars.signal,
-
- finishExec =
- loaderVars.finishExec,
-
- execModule =
- loaderVars.execModule,
-
- getLegacyMode =
- loaderVars.getLegacyMode,
-
- guardCheckComplete =
- loaderVars.guardCheckComplete;
-
- // there is exactly one dojoRequirePlugin among possibly-many dojo/_base/loader's (owing to mapping)
- dojoRequirePlugin = loaderVars.dojoRequirePlugin;
-
- dojo.provide = function(mid){
- var executingModule = syncExecStack[0],
- module = lang.mixin(getModule(slashName(mid), require.module), {
- executed:executing,
- result:lang.getObject(mid, true)
- });
- setArrived(module);
- if(executingModule){
- (executingModule.provides || (executingModule.provides = [])).push(function(){
- module.result = lang.getObject(mid);
- delete module.provides;
- module.executed!==executed && finishExec(module);
- });
- }// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
- return module.result;
- };
-
- has.add("config-publishRequireResult", 1, 0, 0);
-
- dojo.require = function(moduleName, omitModuleCheck) {
- // summary:
- // loads a Javascript module from the appropriate URI
- //
- // moduleName: String
- // module name to load, using periods for separators,
- // e.g. "dojo.date.locale". Module paths are de-referenced by dojo's
- // internal mapping of locations to names and are disambiguated by
- // longest prefix. See `dojo.registerModulePath()` for details on
- // registering new modules.
- //
- // omitModuleCheck: Boolean?
- // if `true`, omitModuleCheck skips the step of ensuring that the
- // loaded file actually defines the symbol it is referenced by.
- // For example if it called as `dojo.require("a.b.c")` and the
- // file located at `a/b/c.js` does not define an object `a.b.c`,
- // and exception will be throws whereas no exception is raised
- // when called as `dojo.require("a.b.c", true)`
- //
- // description:
- // Modules are loaded via dojo.require by using one of two loaders: the normal loader
- // and the xdomain loader. The xdomain loader is used when dojo was built with a
- // custom build that specified loader=xdomain and the module lives on a modulePath
- // that is a whole URL, with protocol and a domain. The versions of Dojo that are on
- // the Google and AOL CDNs use the xdomain loader.
- //
- // If the module is loaded via the xdomain loader, it is an asynchronous load, since
- // the module is added via a dynamically created script tag. This
- // means that dojo.require() can return before the module has loaded. However, this
- // should only happen in the case where you do dojo.require calls in the top-level
- // HTML page, or if you purposely avoid the loader checking for dojo.require
- // dependencies in your module by using a syntax like dojo["require"] to load the module.
- //
- // Sometimes it is useful to not have the loader detect the dojo.require calls in the
- // module so that you can dynamically load the modules as a result of an action on the
- // page, instead of right at module load time.
- //
- // Also, for script blocks in an HTML page, the loader does not pre-process them, so
- // it does not know to download the modules before the dojo.require calls occur.
- //
- // So, in those two cases, when you want on-the-fly module loading or for script blocks
- // in the HTML page, special care must be taken if the dojo.required code is loaded
- // asynchronously. To make sure you can execute code that depends on the dojo.required
- // modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
- // callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
- // executing.
- //
- // This type of syntax works with both xdomain and normal loaders, so it is good
- // practice to always use this idiom for on-the-fly code loading and in HTML script
- // blocks. If at some point you change loaders and where the code is loaded from,
- // it will all still work.
- //
- // More on how dojo.require
- // `dojo.require("A.B")` first checks to see if symbol A.B is
- // defined. If it is, it is simply returned (nothing to do).
- //
- // If it is not defined, it will look for `A/B.js` in the script root
- // directory.
- //
- // `dojo.require` throws an exception if it cannot find a file
- // to load, or if the symbol `A.B` is not defined after loading.
- //
- // It returns the object `A.B`, but note the caveats above about on-the-fly loading and
- // HTML script blocks when the xdomain loader is loading a module.
- //
- // `dojo.require()` does nothing about importing symbols into
- // the current namespace. It is presumed that the caller will
- // take care of that.
- //
- // example:
- // To use dojo.require in conjunction with dojo.ready:
- //
- // | dojo.require("foo");
- // | dojo.require("bar");
- // | dojo.addOnLoad(function(){
- // | //you can now safely do something with foo and bar
- // | });
- //
- // example:
- // For example, to import all symbols into a local block, you might write:
- //
- // | with (dojo.require("A.B")) {
- // | ...
- // | }
- //
- // And to import just the leaf symbol to a local variable:
- //
- // | var B = dojo.require("A.B");
- // | ...
- //
- // returns:
- // the required namespace object
- function doRequire(mid, omitModuleCheck){
- var module = getModule(slashName(mid), require.module);
- if(syncExecStack.length && syncExecStack[0].finish){
- // switched to async loading in the middle of evaluating a legacy module; stop
- // applying dojo.require so the remaining dojo.requires are applied in order
- syncExecStack[0].finish.push(mid);
- return undefined;
- }
-
- // recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
- if(module.executed){
- return module.result;
- }
- omitModuleCheck && (module.result = nonmodule);
-
- // rcg...why here and in two lines??
- var currentMode = getLegacyMode();
-
- // recall, in sync mode to inject is to *eval* the module text
- // if the module is a legacy module, this is the same as executing
- // but if the module is an AMD module, this means defining, not executing
- injectModule(module);
- // the inject may have changed the mode
- currentMode = getLegacyMode();
-
- // in sync mode to dojo.require is to execute
- if(module.executed!==executed && module.injected===arrived){
- // the module was already here before injectModule was called probably finishing up a xdomain
- // load, but maybe a module given to the loader directly rather than having the loader retrieve it
-
- loaderVars.guardCheckComplete(function(){
- execModule(module);
- });
- }
- if(module.executed){
- return module.result;
- }
-
- if(currentMode==sync){
- // the only way to get here is in sync mode and dojo.required a module that
- // * was loaded async in the injectModule application a few lines up
- // * was an AMD module that had deps that are being loaded async and therefore couldn't execute
- if(module.cjs){
- // the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
- execQ.unshift(module);
- }else{
- // the module was a legacy module
- syncExecStack.length && (syncExecStack[0].finish= [mid]);
- }
- }else{
- // the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
- // the module value synchronously; make sure it gets executed though
- execQ.push(module);
- }
-
- return undefined;
- }
-
- var result = doRequire(moduleName, omitModuleCheck);
- if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
- lang.setObject(moduleName, result);
- }
- return result;
- };
-
- dojo.loadInit = function(f) {
- f();
- };
-
- dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
- // summary:
- // Maps a module name to a path
- // description:
- // An unregistered module is given the default path of ../[module],
- // relative to Dojo root. For example, module acme is mapped to
- // ../acme. If you want to use a different module name, use
- // dojo.registerModulePath.
- // example:
- // If your dojo.js is located at this location in the web root:
- // | /myapp/js/dojo/dojo/dojo.js
- // and your modules are located at:
- // | /myapp/js/foo/bar.js
- // | /myapp/js/foo/baz.js
- // | /myapp/js/foo/thud/xyzzy.js
- // Your application can tell Dojo to locate the "foo" namespace by calling:
- // | dojo.registerModulePath("foo", "../../foo");
- // At which point you can then use dojo.require() to load the
- // modules (assuming they provide() the same things which are
- // required). The full code might be:
- // |
- // |
-
- var paths = {};
- paths[moduleName.replace(/\./g, "/")] = prefix;
- require({paths:paths});
- };
-
- dojo.platformRequire = function(/*Object*/modMap){
- // summary:
- // require one or more modules based on which host environment
- // Dojo is currently operating in
- // description:
- // This method takes a "map" of arrays which one can use to
- // optionally load dojo modules. The map is indexed by the
- // possible dojo.name_ values, with two additional values:
- // "default" and "common". The items in the "default" array will
- // be loaded if none of the other items have been chosen based on
- // dojo.name_, set by your host environment. The items in the
- // "common" array will *always* be loaded, regardless of which
- // list is chosen.
- // example:
- // | dojo.platformRequire({
- // | browser: [
- // | "foo.sample", // simple module
- // | "foo.test",
- // | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
- // | ],
- // | default: [ "foo.sample._base" ],
- // | common: [ "important.module.common" ]
- // | });
-
- var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
- temp;
- while(result.length){
- if(lang.isArray(temp = result.shift())){
- dojo.require.apply(dojo, temp);
- }else{
- dojo.require(temp);
- }
- }
- };
-
- dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
- // summary:
- // If the condition is true then call `dojo.require()` for the specified
- // resource
- //
- // example:
- // | dojo.requireIf(dojo.isBrowser, "my.special.Module");
-
- if(condition){
- dojo.require(moduleName, omitModuleCheck);
- }
- };
-
- dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
- require(["../i18n"], function(i18n){
- i18n.getLocalization(moduleName, bundleName, locale);
- });
- };
-
- return {
- // summary:
- // This module defines the v1.x synchronous loader API.
-
- extractLegacyApiApplications:extractLegacyApiApplications,
- require:dojoRequirePlugin,
- loadInit:dojoLoadInitPlugin
- };
-});
diff --git a/lib/dojo/_base/query.js b/lib/dojo/_base/query.js
deleted file mode 100644
index 0223f10..0000000
--- a/lib/dojo/_base/query.js
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/query",["../query","./NodeList"],function(_1){
-return _1;
-});
diff --git a/lib/dojo/_base/query.js.uncompressed.js b/lib/dojo/_base/query.js.uncompressed.js
deleted file mode 100644
index d354bbc..0000000
--- a/lib/dojo/_base/query.js.uncompressed.js
+++ /dev/null
@@ -1,13 +0,0 @@
-define("dojo/_base/query", ["../query", "./NodeList"], function(query){
- // module:
- // dojo/_base/query
-
- /*=====
- return {
- // summary:
- // Deprecated. Use dojo/query instead.
- };
- =====*/
-
- return query;
-});
diff --git a/lib/dojo/_base/sniff.js b/lib/dojo/_base/sniff.js
deleted file mode 100644
index 8935408..0000000
--- a/lib/dojo/_base/sniff.js
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/sniff",["./kernel","./lang","../sniff"],function(_1,_2,_3){
-if(!1){
-return _3;
-}
-_1._name="browser";
-_2.mixin(_1,{isBrowser:true,isFF:_3("ff"),isIE:_3("ie"),isKhtml:_3("khtml"),isWebKit:_3("webkit"),isMozilla:_3("mozilla"),isMoz:_3("mozilla"),isOpera:_3("opera"),isSafari:_3("safari"),isChrome:_3("chrome"),isMac:_3("mac"),isIos:_3("ios"),isAndroid:_3("android"),isWii:_3("wii"),isQuirks:_3("quirks"),isAir:_3("air")});
-return _3;
-});
diff --git a/lib/dojo/_base/sniff.js.uncompressed.js b/lib/dojo/_base/sniff.js.uncompressed.js
deleted file mode 100644
index 780918d..0000000
--- a/lib/dojo/_base/sniff.js.uncompressed.js
+++ /dev/null
@@ -1,93 +0,0 @@
-define("dojo/_base/sniff", ["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
- // module:
- // dojo/_base/sniff
-
- /*=====
- return {
- // summary:
- // Deprecated. New code should use dojo/sniff.
- // This module populates the dojo browser version sniffing properties like dojo.isIE.
- };
- =====*/
-
- if(! 1 ){
- return has;
- }
-
- // no idea what this is for, or if it's used
- dojo._name = "browser";
-
- lang.mixin(dojo, {
- // isBrowser: Boolean
- // True if the client is a web-browser
- isBrowser: true,
-
- // isFF: Number|undefined
- // Version as a Number if client is FireFox. undefined otherwise. Corresponds to
- // major detected FireFox version (1.5, 2, 3, etc.)
- isFF: has("ff"),
-
- // isIE: Number|undefined
- // Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
- // major detected IE version (6, 7, 8, etc.)
- isIE: has("ie"),
-
- // isKhtml: Number|undefined
- // Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
- // detected version.
- isKhtml: has("khtml"),
-
- // isWebKit: Number|undefined
- // Version as a Number if client is a WebKit-derived browser (Konqueror,
- // Safari, Chrome, etc.). undefined otherwise.
- isWebKit: has("webkit"),
-
- // isMozilla: Number|undefined
- // Version as a Number if client is a Mozilla-based browser (Firefox,
- // SeaMonkey). undefined otherwise. Corresponds to major detected version.
- isMozilla: has("mozilla"),
- // isMoz: Number|undefined
- // Version as a Number if client is a Mozilla-based browser (Firefox,
- // SeaMonkey). undefined otherwise. Corresponds to major detected version.
- isMoz: has("mozilla"),
-
- // isOpera: Number|undefined
- // Version as a Number if client is Opera. undefined otherwise. Corresponds to
- // major detected version.
- isOpera: has("opera"),
-
- // isSafari: Number|undefined
- // Version as a Number if client is Safari or iPhone. undefined otherwise.
- isSafari: has("safari"),
-
- // isChrome: Number|undefined
- // Version as a Number if client is Chrome browser. undefined otherwise.
- isChrome: has("chrome"),
-
- // isMac: Boolean
- // True if the client runs on Mac
- isMac: has("mac"),
-
- // isIos: Number|undefined
- // Version as a Number if client is iPhone, iPod, or iPad. undefined otherwise.
- isIos: has("ios"),
-
- // isAndroid: Number|undefined
- // Version as a Number if client is android browser. undefined otherwise.
- isAndroid: has("android"),
-
- // isWii: Boolean
- // True if client is Wii
- isWii: has("wii"),
-
- // isQuirks: Boolean
- // Page is in quirks mode.
- isQuirks: has("quirks"),
-
- // isAir: Boolean
- // True if client is Adobe Air
- isAir: has("air")
- });
-
- return has;
-});
diff --git a/lib/dojo/_base/unload.js b/lib/dojo/_base/unload.js
deleted file mode 100644
index a770e4d..0000000
--- a/lib/dojo/_base/unload.js
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/unload",["./kernel","./lang","../on"],function(_1,_2,on){
-var _3=window;
-var _4={addOnWindowUnload:function(_5,_6){
-if(!_1.windowUnloaded){
-on(_3,"unload",(_1.windowUnloaded=function(){
-}));
-}
-on(_3,"unload",_2.hitch(_5,_6));
-},addOnUnload:function(_7,_8){
-on(_3,"beforeunload",_2.hitch(_7,_8));
-}};
-_1.addOnWindowUnload=_4.addOnWindowUnload;
-_1.addOnUnload=_4.addOnUnload;
-return _4;
-});
diff --git a/lib/dojo/_base/unload.js.uncompressed.js b/lib/dojo/_base/unload.js.uncompressed.js
deleted file mode 100644
index 115703b..0000000
--- a/lib/dojo/_base/unload.js.uncompressed.js
+++ /dev/null
@@ -1,95 +0,0 @@
-define("dojo/_base/unload", ["./kernel", "./lang", "../on"], function(dojo, lang, on){
-
-// module:
-// dojo/unload
-
-var win = window;
-
-var unload = {
- // summary:
- // This module contains the document and window unload detection API.
- // This module is deprecated. Use on(window, "unload", func)
- // and on(window, "beforeunload", func) instead.
-
- addOnWindowUnload: function(/*Object|Function?*/ obj, /*String|Function?*/ functionName){
- // summary:
- // Registers a function to be triggered when window.onunload fires.
- // Deprecated, use on(window, "unload", lang.hitch(obj, functionName)) instead.
- // description:
- // The first time that addOnWindowUnload is called Dojo
- // will register a page listener to trigger your unload
- // handler with. Note that registering these handlers may
- // destroy "fastback" page caching in browsers that support
- // it. Be careful trying to modify the DOM or access
- // JavaScript properties during this phase of page unloading:
- // they may not always be available. Consider
- // addOnUnload() if you need to modify the DOM or do
- // heavy JavaScript work since it fires at the equivalent of
- // the page's "onbeforeunload" event.
- // example:
- // | var afunc = function() {console.log("global function");};
- // | require(["dojo/_base/unload"], function(unload) {
- // | var foo = {bar: function(){ console.log("bar unloading...");},
- // | data: "mydata"};
- // | unload.addOnWindowUnload(afunc);
- // | unload.addOnWindowUnload(foo, "bar");
- // | unload.addOnWindowUnload(foo, function(){console.log("", this.data);});
- // | });
-
- if (!dojo.windowUnloaded){
- on(win, "unload", (dojo.windowUnloaded = function(){
- // summary:
- // signal fired by impending window destruction. You may use
- // dojo.addOnWindowUnload() to register a listener for this
- // event. NOTE: if you wish to dojo.connect() to this method
- // to perform page/application cleanup, be aware that this
- // event WILL NOT fire if no handler has been registered with
- // addOnWindowUnload(). This behavior started in Dojo 1.3.
- // Previous versions always triggered windowUnloaded(). See
- // addOnWindowUnload for more info.
- }));
- }
- on(win, "unload", lang.hitch(obj, functionName));
- },
-
- addOnUnload: function(/*Object?|Function?*/ obj, /*String|Function?*/ functionName){
- // summary:
- // Registers a function to be triggered when the page unloads.
- // Deprecated, use on(window, "beforeunload", lang.hitch(obj, functionName)) instead.
- // description:
- // The first time that addOnUnload is called Dojo will
- // register a page listener to trigger your unload handler
- // with.
- //
- // In a browser environment, the functions will be triggered
- // during the window.onbeforeunload event. Be careful of doing
- // too much work in an unload handler. onbeforeunload can be
- // triggered if a link to download a file is clicked, or if
- // the link is a javascript: link. In these cases, the
- // onbeforeunload event fires, but the document is not
- // actually destroyed. So be careful about doing destructive
- // operations in a dojo.addOnUnload callback.
- //
- // Further note that calling dojo.addOnUnload will prevent
- // browsers from using a "fast back" cache to make page
- // loading via back button instantaneous.
- // example:
- // | var afunc = function() {console.log("global function");};
- // | require(["dojo/_base/unload"], function(unload) {
- // | var foo = {bar: function(){ console.log("bar unloading...");},
- // | data: "mydata"};
- // | unload.addOnUnload(afunc);
- // | unload.addOnUnload(foo, "bar");
- // | unload.addOnUnload(foo, function(){console.log("", this.data);});
- // | });
-
- on(win, "beforeunload", lang.hitch(obj, functionName));
- }
-};
-
-dojo.addOnWindowUnload = unload.addOnWindowUnload;
-dojo.addOnUnload = unload.addOnUnload;
-
-return unload;
-
-});
diff --git a/lib/dojo/_base/url.js b/lib/dojo/_base/url.js
deleted file mode 100644
index 02ecd4c..0000000
--- a/lib/dojo/_base/url.js
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/url",["./kernel"],function(_1){
-var _2=new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),_3=new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),_4=function(){
-var n=null,_5=arguments,_6=[_5[0]];
-for(var i=1;i<_5.length;i++){
-if(!_5[i]){
-continue;
-}
-var _7=new _4(_5[i]+""),_8=new _4(_6[0]+"");
-if(_7.path==""&&!_7.scheme&&!_7.authority&&!_7.query){
-if(_7.fragment!=n){
-_8.fragment=_7.fragment;
-}
-_7=_8;
-}else{
-if(!_7.scheme){
-_7.scheme=_8.scheme;
-if(!_7.authority){
-_7.authority=_8.authority;
-if(_7.path.charAt(0)!="/"){
-var _9=_8.path.substring(0,_8.path.lastIndexOf("/")+1)+_7.path;
-var _a=_9.split("/");
-for(var j=0;j<_a.length;j++){
-if(_a[j]=="."){
-if(j==_a.length-1){
-_a[j]="";
-}else{
-_a.splice(j,1);
-j--;
-}
-}else{
-if(j>0&&!(j==1&&_a[0]=="")&&_a[j]==".."&&_a[j-1]!=".."){
-if(j==(_a.length-1)){
-_a.splice(j,1);
-_a[j-1]="";
-}else{
-_a.splice(j-1,2);
-j-=2;
-}
-}
-}
-}
-_7.path=_a.join("/");
-}
-}
-}
-}
-_6=[];
-if(_7.scheme){
-_6.push(_7.scheme,":");
-}
-if(_7.authority){
-_6.push("//",_7.authority);
-}
-_6.push(_7.path);
-if(_7.query){
-_6.push("?",_7.query);
-}
-if(_7.fragment){
-_6.push("#",_7.fragment);
-}
-}
-this.uri=_6.join("");
-var r=this.uri.match(_2);
-this.scheme=r[2]||(r[1]?"":n);
-this.authority=r[4]||(r[3]?"":n);
-this.path=r[5];
-this.query=r[7]||(r[6]?"":n);
-this.fragment=r[9]||(r[8]?"":n);
-if(this.authority!=n){
-r=this.authority.match(_3);
-this.user=r[3]||n;
-this.password=r[4]||n;
-this.host=r[6]||r[7];
-this.port=r[9]||n;
-}
-};
-_4.prototype.toString=function(){
-return this.uri;
-};
-return _1._Url=_4;
-});
diff --git a/lib/dojo/_base/url.js.uncompressed.js b/lib/dojo/_base/url.js.uncompressed.js
deleted file mode 100644
index c83e1a2..0000000
--- a/lib/dojo/_base/url.js.uncompressed.js
+++ /dev/null
@@ -1,109 +0,0 @@
-define("dojo/_base/url", ["./kernel"], function(dojo){
- // module:
- // dojo/url
-
- var
- ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),
- ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),
- _Url = function(){
- var n = null,
- _a = arguments,
- uri = [_a[0]];
- // resolve uri components relative to each other
- for(var i = 1; i<_a.length; i++){
- if(!_a[i]){ continue; }
-
- // Safari doesn't support this.constructor so we have to be explicit
- // FIXME: Tracked (and fixed) in Webkit bug 3537.
- // http://bugs.webkit.org/show_bug.cgi?id=3537
- var relobj = new _Url(_a[i]+""),
- uriobj = new _Url(uri[0]+"");
-
- if(
- relobj.path == "" &&
- !relobj.scheme &&
- !relobj.authority &&
- !relobj.query
- ){
- if(relobj.fragment != n){
- uriobj.fragment = relobj.fragment;
- }
- relobj = uriobj;
- }else if(!relobj.scheme){
- relobj.scheme = uriobj.scheme;
-
- if(!relobj.authority){
- relobj.authority = uriobj.authority;
-
- if(relobj.path.charAt(0) != "/"){
- var path = uriobj.path.substring(0,
- uriobj.path.lastIndexOf("/") + 1) + relobj.path;
-
- var segs = path.split("/");
- for(var j = 0; j < segs.length; j++){
- if(segs[j] == "."){
- // flatten "./" references
- if(j == segs.length - 1){
- segs[j] = "";
- }else{
- segs.splice(j, 1);
- j--;
- }
- }else if(j > 0 && !(j == 1 && segs[0] == "") &&
- segs[j] == ".." && segs[j-1] != ".."){
- // flatten "../" references
- if(j == (segs.length - 1)){
- segs.splice(j, 1);
- segs[j - 1] = "";
- }else{
- segs.splice(j - 1, 2);
- j -= 2;
- }
- }
- }
- relobj.path = segs.join("/");
- }
- }
- }
-
- uri = [];
- if(relobj.scheme){
- uri.push(relobj.scheme, ":");
- }
- if(relobj.authority){
- uri.push("//", relobj.authority);
- }
- uri.push(relobj.path);
- if(relobj.query){
- uri.push("?", relobj.query);
- }
- if(relobj.fragment){
- uri.push("#", relobj.fragment);
- }
- }
-
- this.uri = uri.join("");
-
- // break the uri into its main components
- var r = this.uri.match(ore);
-
- this.scheme = r[2] || (r[1] ? "" : n);
- this.authority = r[4] || (r[3] ? "" : n);
- this.path = r[5]; // can never be undefined
- this.query = r[7] || (r[6] ? "" : n);
- this.fragment = r[9] || (r[8] ? "" : n);
-
- if(this.authority != n){
- // server based naming authority
- r = this.authority.match(ire);
-
- this.user = r[3] || n;
- this.password = r[4] || n;
- this.host = r[6] || r[7]; // ipv6 || ipv4
- this.port = r[9] || n;
- }
- };
- _Url.prototype.toString = function(){ return this.uri; };
-
- return dojo._Url = _Url;
-});
diff --git a/lib/dojo/_base/window.js b/lib/dojo/_base/window.js
deleted file mode 100644
index 8a2636d..0000000
--- a/lib/dojo/_base/window.js
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/window",["./kernel","./lang","../sniff"],function(_1,_2,_3){
-var _4={global:_1.global,doc:this["document"]||null,body:function(_5){
-_5=_5||_1.doc;
-return _5.body||_5.getElementsByTagName("body")[0];
-},setContext:function(_6,_7){
-_1.global=_4.global=_6;
-_1.doc=_4.doc=_7;
-},withGlobal:function(_8,_9,_a,_b){
-var _c=_1.global;
-try{
-_1.global=_4.global=_8;
-return _4.withDoc.call(null,_8.document,_9,_a,_b);
-}
-finally{
-_1.global=_4.global=_c;
-}
-},withDoc:function(_d,_e,_f,_10){
-var _11=_4.doc,_12=_3("quirks"),_13=_3("ie"),_14,_15,_16;
-try{
-_1.doc=_4.doc=_d;
-_1.isQuirks=_3.add("quirks",_1.doc.compatMode=="BackCompat",true,true);
-if(_3("ie")){
-if((_16=_d.parentWindow)&&_16.navigator){
-_14=parseFloat(_16.navigator.appVersion.split("MSIE ")[1])||undefined;
-_15=_d.documentMode;
-if(_15&&_15!=5&&Math.floor(_14)!=_15){
-_14=_15;
-}
-_1.isIE=_3.add("ie",_14,true,true);
-}
-}
-if(_f&&typeof _e=="string"){
-_e=_f[_e];
-}
-return _e.apply(_f,_10||[]);
-}
-finally{
-_1.doc=_4.doc=_11;
-_1.isQuirks=_3.add("quirks",_12,true,true);
-_1.isIE=_3.add("ie",_13,true,true);
-}
-}};
-1&&_2.mixin(_1,_4);
-return _4;
-});
diff --git a/lib/dojo/_base/window.js.uncompressed.js b/lib/dojo/_base/window.js.uncompressed.js
deleted file mode 100644
index 3d23c3a..0000000
--- a/lib/dojo/_base/window.js.uncompressed.js
+++ /dev/null
@@ -1,134 +0,0 @@
-define("dojo/_base/window", ["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
-// module:
-// dojo/_base/window
-
-var ret = {
- // summary:
- // API to save/set/restore the global/document scope.
-
- global: dojo.global,
- /*=====
- global: {
- // summary:
- // Alias for the current window. 'global' can be modified
- // for temporary context shifting. See also withGlobal().
- // description:
- // Use this rather than referring to 'window' to ensure your code runs
- // correctly in managed contexts.
- },
- =====*/
-
- doc: this["document"] || null,
- /*=====
- doc: {
- // summary:
- // Alias for the current document. 'doc' can be modified
- // for temporary context shifting. See also withDoc().
- // description:
- // Use this rather than referring to 'window.document' to ensure your code runs
- // correctly in managed contexts.
- // example:
- // | n.appendChild(dojo.doc.createElement('div'));
- },
- =====*/
-
- body: function(/*Document?*/ doc){
- // summary:
- // Return the body element of the specified document or of dojo/_base/window::doc.
- // example:
- // | win.body().appendChild(dojo.doc.createElement('div'));
-
- // Note: document.body is not defined for a strict xhtml document
- // Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
- doc = doc || dojo.doc;
- return doc.body || doc.getElementsByTagName("body")[0]; // Node
- },
-
- setContext: function(/*Object*/ globalObject, /*DocumentElement*/ globalDocument){
- // summary:
- // changes the behavior of many core Dojo functions that deal with
- // namespace and DOM lookup, changing them to work in a new global
- // context (e.g., an iframe). The varibles dojo.global and dojo.doc
- // are modified as a result of calling this function and the result of
- // `dojo.body()` likewise differs.
- dojo.global = ret.global = globalObject;
- dojo.doc = ret.doc = globalDocument;
- },
-
- withGlobal: function( /*Object*/ globalObject,
- /*Function*/ callback,
- /*Object?*/ thisObject,
- /*Array?*/ cbArguments){
- // summary:
- // Invoke callback with globalObject as dojo.global and
- // globalObject.document as dojo.doc.
- // description:
- // Invoke callback with globalObject as dojo.global and
- // globalObject.document as dojo.doc. If provided, globalObject
- // will be executed in the context of object thisObject
- // When callback() returns or throws an error, the dojo.global
- // and dojo.doc will be restored to its previous state.
-
- var oldGlob = dojo.global;
- try{
- dojo.global = ret.global = globalObject;
- return ret.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
- }finally{
- dojo.global = ret.global = oldGlob;
- }
- },
-
- withDoc: function( /*DocumentElement*/ documentObject,
- /*Function*/ callback,
- /*Object?*/ thisObject,
- /*Array?*/ cbArguments){
- // summary:
- // Invoke callback with documentObject as dojo/_base/window::doc.
- // description:
- // Invoke callback with documentObject as dojo/_base/window::doc. If provided,
- // callback will be executed in the context of object thisObject
- // When callback() returns or throws an error, the dojo/_base/window::doc will
- // be restored to its previous state.
-
- var oldDoc = ret.doc,
- oldQ = has("quirks"),
- oldIE = has("ie"), isIE, mode, pwin;
-
- try{
- dojo.doc = ret.doc = documentObject;
- // update dojo.isQuirks and the value of the has feature "quirks".
- // remove setting dojo.isQuirks and dojo.isIE for 2.0
- dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only
-
- if(has("ie")){
- if((pwin = documentObject.parentWindow) && pwin.navigator){
- // re-run IE detection logic and update dojo.isIE / has("ie")
- // (the only time parentWindow/navigator wouldn't exist is if we were not
- // passed an actual legitimate document object)
- isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined;
- mode = documentObject.documentMode;
- if(mode && mode != 5 && Math.floor(isIE) != mode){
- isIE = mode;
- }
- dojo.isIE = has.add("ie", isIE, true, true);
- }
- }
-
- if(thisObject && typeof callback == "string"){
- callback = thisObject[callback];
- }
-
- return callback.apply(thisObject, cbArguments || []);
- }finally{
- dojo.doc = ret.doc = oldDoc;
- dojo.isQuirks = has.add("quirks", oldQ, true, true);
- dojo.isIE = has.add("ie", oldIE, true, true);
- }
- }
-};
-
- 1 && lang.mixin(dojo, ret);
-
-return ret;
-
-});
diff --git a/lib/dojo/_base/xhr.js b/lib/dojo/_base/xhr.js
deleted file mode 100644
index 774649a..0000000
--- a/lib/dojo/_base/xhr.js
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_base/xhr",["./kernel","./sniff","require","../io-query","../dom","../dom-form","./Deferred","./config","./json","./lang","./array","../on","../aspect","../request/watch","../request/xhr","../request/util"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b,on,_c,_d,_e,_f){
-_1._xhrObj=_e._create;
-var cfg=_1.config;
-_1.objectToQuery=_4.objectToQuery;
-_1.queryToObject=_4.queryToObject;
-_1.fieldToObject=_6.fieldToObject;
-_1.formToObject=_6.toObject;
-_1.formToQuery=_6.toQuery;
-_1.formToJson=_6.toJson;
-_1._blockAsync=false;
-var _10=_1._contentHandlers=_1.contentHandlers={"text":function(xhr){
-return xhr.responseText;
-},"json":function(xhr){
-return _9.fromJson(xhr.responseText||null);
-},"json-comment-filtered":function(xhr){
-if(!_8.useCommentedJson){
-console.warn("Consider using the standard mimetype:application/json."+" json-commenting can introduce security issues. To"+" decrease the chances of hijacking, use the standard the 'json' handler and"+" prefix your json with: {}&&\n"+"Use djConfig.useCommentedJson=true to turn off this message.");
-}
-var _11=xhr.responseText;
-var _12=_11.indexOf("/*");
-var _13=_11.lastIndexOf("*/");
-if(_12==-1||_13==-1){
-throw new Error("JSON was not comment filtered");
-}
-return _9.fromJson(_11.substring(_12+2,_13));
-},"javascript":function(xhr){
-return _1.eval(xhr.responseText);
-},"xml":function(xhr){
-var _14=xhr.responseXML;
-if(_14&&_2("dom-qsa2.1")&&!_14.querySelectorAll&&_2("dom-parser")){
-_14=new DOMParser().parseFromString(xhr.responseText,"application/xml");
-}
-if(_2("ie")){
-if((!_14||!_14.documentElement)){
-var ms=function(n){
-return "MSXML"+n+".DOMDocument";
-};
-var dp=["Microsoft.XMLDOM",ms(6),ms(4),ms(3),ms(2)];
-_b.some(dp,function(p){
-try{
-var dom=new ActiveXObject(p);
-dom.async=false;
-dom.loadXML(xhr.responseText);
-_14=dom;
-}
-catch(e){
-return false;
-}
-return true;
-});
-}
-}
-return _14;
-},"json-comment-optional":function(xhr){
-if(xhr.responseText&&/^[^{\[]*\/\*/.test(xhr.responseText)){
-return _10["json-comment-filtered"](xhr);
-}else{
-return _10["json"](xhr);
-}
-}};
-_1._ioSetArgs=function(_15,_16,_17,_18){
-var _19={args:_15,url:_15.url};
-var _1a=null;
-if(_15.form){
-var _1b=_5.byId(_15.form);
-var _1c=_1b.getAttributeNode("action");
-_19.url=_19.url||(_1c?_1c.value:null);
-_1a=_6.toObject(_1b);
-}
-var _1d=[{}];
-if(_1a){
-_1d.push(_1a);
-}
-if(_15.content){
-_1d.push(_15.content);
-}
-if(_15.preventCache){
-_1d.push({"dojo.preventCache":new Date().valueOf()});
-}
-_19.query=_4.objectToQuery(_a.mixin.apply(null,_1d));
-_19.handleAs=_15.handleAs||"text";
-var d=new _7(function(dfd){
-dfd.canceled=true;
-_16&&_16(dfd);
-var err=dfd.ioArgs.error;
-if(!err){
-err=new Error("request cancelled");
-err.dojoType="cancel";
-dfd.ioArgs.error=err;
-}
-return err;
-});
-d.addCallback(_17);
-var ld=_15.load;
-if(ld&&_a.isFunction(ld)){
-d.addCallback(function(_1e){
-return ld.call(_15,_1e,_19);
-});
-}
-var err=_15.error;
-if(err&&_a.isFunction(err)){
-d.addErrback(function(_1f){
-return err.call(_15,_1f,_19);
-});
-}
-var _20=_15.handle;
-if(_20&&_a.isFunction(_20)){
-d.addBoth(function(_21){
-return _20.call(_15,_21,_19);
-});
-}
-d.addErrback(function(_22){
-return _18(_22,d);
-});
-if(cfg.ioPublish&&_1.publish&&_19.args.ioPublish!==false){
-d.addCallbacks(function(res){
-_1.publish("/dojo/io/load",[d,res]);
-return res;
-},function(res){
-_1.publish("/dojo/io/error",[d,res]);
-return res;
-});
-d.addBoth(function(res){
-_1.publish("/dojo/io/done",[d,res]);
-return res;
-});
-}
-d.ioArgs=_19;
-return d;
-};
-var _23=function(dfd){
-var ret=_10[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
-return ret===undefined?null:ret;
-};
-var _24=function(_25,dfd){
-if(!dfd.ioArgs.args.failOk){
-console.error(_25);
-}
-return _25;
-};
-var _26=function(dfd){
-if(_27<=0){
-_27=0;
-if(cfg.ioPublish&&_1.publish&&(!dfd||dfd&&dfd.ioArgs.args.ioPublish!==false)){
-_1.publish("/dojo/io/stop");
-}
-}
-};
-var _27=0;
-_c.after(_d,"_onAction",function(){
-_27-=1;
-});
-_c.after(_d,"_onInFlight",_26);
-_1._ioCancelAll=_d.cancelAll;
-_1._ioNotifyStart=function(dfd){
-if(cfg.ioPublish&&_1.publish&&dfd.ioArgs.args.ioPublish!==false){
-if(!_27){
-_1.publish("/dojo/io/start");
-}
-_27+=1;
-_1.publish("/dojo/io/send",[dfd]);
-}
-};
-_1._ioWatch=function(dfd,_28,_29,_2a){
-var _2b=dfd.ioArgs.options=dfd.ioArgs.args;
-_a.mixin(dfd,{response:dfd.ioArgs,isValid:function(_2c){
-return _28(dfd);
-},isReady:function(_2d){
-return _29(dfd);
-},handleResponse:function(_2e){
-return _2a(dfd);
-}});
-_d(dfd);
-_26(dfd);
-};
-var _2f="application/x-www-form-urlencoded";
-_1._ioAddQueryToUrl=function(_30){
-if(_30.query.length){
-_30.url+=(_30.url.indexOf("?")==-1?"?":"&")+_30.query;
-_30.query=null;
-}
-};
-_1.xhr=function(_31,_32,_33){
-var _34;
-var dfd=_1._ioSetArgs(_32,function(dfd){
-_34&&_34.cancel();
-},_23,_24);
-var _35=dfd.ioArgs;
-if("postData" in _32){
-_35.query=_32.postData;
-}else{
-if("putData" in _32){
-_35.query=_32.putData;
-}else{
-if("rawBody" in _32){
-_35.query=_32.rawBody;
-}else{
-if((arguments.length>2&&!_33)||"POST|PUT".indexOf(_31.toUpperCase())===-1){
-_1._ioAddQueryToUrl(_35);
-}
-}
-}
-}
-var _36={method:_31,handleAs:"text",timeout:_32.timeout,withCredentials:_32.withCredentials,ioArgs:_35};
-if(typeof _32.headers!=="undefined"){
-_36.headers=_32.headers;
-}
-if(typeof _32.contentType!=="undefined"){
-if(!_36.headers){
-_36.headers={};
-}
-_36.headers["Content-Type"]=_32.contentType;
-}
-if(typeof _35.query!=="undefined"){
-_36.data=_35.query;
-}
-if(typeof _32.sync!=="undefined"){
-_36.sync=_32.sync;
-}
-_1._ioNotifyStart(dfd);
-try{
-_34=_e(_35.url,_36,true);
-}
-catch(e){
-dfd.cancel();
-return dfd;
-}
-dfd.ioArgs.xhr=_34.response.xhr;
-_34.then(function(){
-dfd.resolve(dfd);
-}).otherwise(function(_37){
-_35.error=_37;
-if(_37.response){
-_37.status=_37.response.status;
-_37.responseText=_37.response.text;
-_37.xhr=_37.response.xhr;
-}
-dfd.reject(_37);
-});
-return dfd;
-};
-_1.xhrGet=function(_38){
-return _1.xhr("GET",_38);
-};
-_1.rawXhrPost=_1.xhrPost=function(_39){
-return _1.xhr("POST",_39,true);
-};
-_1.rawXhrPut=_1.xhrPut=function(_3a){
-return _1.xhr("PUT",_3a,true);
-};
-_1.xhrDelete=function(_3b){
-return _1.xhr("DELETE",_3b);
-};
-_1._isDocumentOk=function(x){
-return _f.checkStatus(x.status);
-};
-_1._getText=function(url){
-var _3c;
-_1.xhrGet({url:url,sync:true,load:function(_3d){
-_3c=_3d;
-}});
-return _3c;
-};
-_a.mixin(_1.xhr,{_xhrObj:_1._xhrObj,fieldToObject:_6.fieldToObject,formToObject:_6.toObject,objectToQuery:_4.objectToQuery,formToQuery:_6.toQuery,formToJson:_6.toJson,queryToObject:_4.queryToObject,contentHandlers:_10,_ioSetArgs:_1._ioSetArgs,_ioCancelAll:_1._ioCancelAll,_ioNotifyStart:_1._ioNotifyStart,_ioWatch:_1._ioWatch,_ioAddQueryToUrl:_1._ioAddQueryToUrl,_isDocumentOk:_1._isDocumentOk,_getText:_1._getText,get:_1.xhrGet,post:_1.xhrPost,put:_1.xhrPut,del:_1.xhrDelete});
-return _1.xhr;
-});
diff --git a/lib/dojo/_base/xhr.js.uncompressed.js b/lib/dojo/_base/xhr.js.uncompressed.js
deleted file mode 100644
index 647a3ec..0000000
--- a/lib/dojo/_base/xhr.js.uncompressed.js
+++ /dev/null
@@ -1,718 +0,0 @@
-define("dojo/_base/xhr", [
- "./kernel",
- "./sniff",
- "require",
- "../io-query",
- /*===== "./declare", =====*/
- "../dom",
- "../dom-form",
- "./Deferred",
- "./config",
- "./json",
- "./lang",
- "./array",
- "../on",
- "../aspect",
- "../request/watch",
- "../request/xhr",
- "../request/util"
-], function(dojo, has, require, ioq, /*===== declare, =====*/ dom, domForm, Deferred, config, json, lang, array, on, aspect, watch, _xhr, util){
- // module:
- // dojo/_base/xhr
-
- /*=====
- dojo._xhrObj = function(){
- // summary:
- // does the work of portably generating a new XMLHTTPRequest object.
- };
- =====*/
- dojo._xhrObj = _xhr._create;
-
- var cfg = dojo.config;
-
- // mix in io-query and dom-form
- dojo.objectToQuery = ioq.objectToQuery;
- dojo.queryToObject = ioq.queryToObject;
- dojo.fieldToObject = domForm.fieldToObject;
- dojo.formToObject = domForm.toObject;
- dojo.formToQuery = domForm.toQuery;
- dojo.formToJson = domForm.toJson;
-
- // need to block async callbacks from snatching this thread as the result
- // of an async callback might call another sync XHR, this hangs khtml forever
- // must checked by watchInFlight()
-
- dojo._blockAsync = false;
-
- // MOW: remove dojo._contentHandlers alias in 2.0
- var handlers = dojo._contentHandlers = dojo.contentHandlers = {
- // summary:
- // A map of available XHR transport handle types. Name matches the
- // `handleAs` attribute passed to XHR calls.
- // description:
- // A map of available XHR transport handle types. Name matches the
- // `handleAs` attribute passed to XHR calls. Each contentHandler is
- // called, passing the xhr object for manipulation. The return value
- // from the contentHandler will be passed to the `load` or `handle`
- // functions defined in the original xhr call.
- // example:
- // Creating a custom content-handler:
- // | xhr.contentHandlers.makeCaps = function(xhr){
- // | return xhr.responseText.toUpperCase();
- // | }
- // | // and later:
- // | dojo.xhrGet({
- // | url:"foo.txt",
- // | handleAs:"makeCaps",
- // | load: function(data){ /* data is a toUpper version of foo.txt */ }
- // | });
-
- "text": function(xhr){
- // summary:
- // A contentHandler which simply returns the plaintext response data
- return xhr.responseText;
- },
- "json": function(xhr){
- // summary:
- // A contentHandler which returns a JavaScript object created from the response data
- return json.fromJson(xhr.responseText || null);
- },
- "json-comment-filtered": function(xhr){
- // summary:
- // A contentHandler which expects comment-filtered JSON.
- // description:
- // A contentHandler which expects comment-filtered JSON.
- // the json-comment-filtered option was implemented to prevent
- // "JavaScript Hijacking", but it is less secure than standard JSON. Use
- // standard JSON instead. JSON prefixing can be used to subvert hijacking.
- //
- // Will throw a notice suggesting to use application/json mimetype, as
- // json-commenting can introduce security issues. To decrease the chances of hijacking,
- // use the standard `json` contentHandler, and prefix your "JSON" with: {}&&
- //
- // use djConfig.useCommentedJson = true to turn off the notice
- if(!config.useCommentedJson){
- console.warn("Consider using the standard mimetype:application/json."
- + " json-commenting can introduce security issues. To"
- + " decrease the chances of hijacking, use the standard the 'json' handler and"
- + " prefix your json with: {}&&\n"
- + "Use djConfig.useCommentedJson=true to turn off this message.");
- }
-
- var value = xhr.responseText;
- var cStartIdx = value.indexOf("\/*");
- var cEndIdx = value.lastIndexOf("*\/");
- if(cStartIdx == -1 || cEndIdx == -1){
- throw new Error("JSON was not comment filtered");
- }
- return json.fromJson(value.substring(cStartIdx+2, cEndIdx));
- },
- "javascript": function(xhr){
- // summary:
- // A contentHandler which evaluates the response data, expecting it to be valid JavaScript
-
- // FIXME: try Moz and IE specific eval variants?
- return dojo.eval(xhr.responseText);
- },
- "xml": function(xhr){
- // summary:
- // A contentHandler returning an XML Document parsed from the response data
- var result = xhr.responseXML;
-
- if(result && has("dom-qsa2.1") && !result.querySelectorAll && has("dom-parser")){
- // http://bugs.dojotoolkit.org/ticket/15631
- // IE9 supports a CSS3 querySelectorAll implementation, but the DOM implementation
- // returned by IE9 xhr.responseXML does not. Manually create the XML DOM to gain
- // the fuller-featured implementation and avoid bugs caused by the inconsistency
- result = new DOMParser().parseFromString(xhr.responseText, "application/xml");
- }
-
- if(has("ie")){
- if((!result || !result.documentElement)){
- //WARNING: this branch used by the xml handling in dojo.io.iframe,
- //so be sure to test dojo.io.iframe if making changes below.
- var ms = function(n){ return "MSXML" + n + ".DOMDocument"; };
- var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)];
- array.some(dp, function(p){
- try{
- var dom = new ActiveXObject(p);
- dom.async = false;
- dom.loadXML(xhr.responseText);
- result = dom;
- }catch(e){ return false; }
- return true;
- });
- }
- }
- return result; // DOMDocument
- },
- "json-comment-optional": function(xhr){
- // summary:
- // A contentHandler which checks the presence of comment-filtered JSON and
- // alternates between the `json` and `json-comment-filtered` contentHandlers.
- if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){
- return handlers["json-comment-filtered"](xhr);
- }else{
- return handlers["json"](xhr);
- }
- }
- };
-
- /*=====
-
- // kwargs function parameter definitions. Assigning to dojo namespace rather than making them local variables
- // because they are used by dojo/io modules too
-
- dojo.__IoArgs = declare(null, {
- // url: String
- // URL to server endpoint.
- // content: Object?
- // Contains properties with string values. These
- // properties will be serialized as name1=value2 and
- // passed in the request.
- // timeout: Integer?
- // Milliseconds to wait for the response. If this time
- // passes, the then error callbacks are called.
- // form: DOMNode?
- // DOM node for a form. Used to extract the form values
- // and send to the server.
- // preventCache: Boolean?
- // Default is false. If true, then a
- // "dojo.preventCache" parameter is sent in the request
- // with a value that changes with each request
- // (timestamp). Useful only with GET-type requests.
- // handleAs: String?
- // Acceptable values depend on the type of IO
- // transport (see specific IO calls for more information).
- // rawBody: String?
- // Sets the raw body for an HTTP request. If this is used, then the content
- // property is ignored. This is mostly useful for HTTP methods that have
- // a body to their requests, like PUT or POST. This property can be used instead
- // of postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.
- // ioPublish: Boolean?
- // Set this explicitly to false to prevent publishing of topics related to
- // IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
- // will be published via dojo/topic.publish() for different phases of an IO operation.
- // See dojo/main.__IoPublish for a list of topics that are published.
-
- load: function(response, ioArgs){
- // summary:
- // This function will be
- // called on a successful HTTP response code.
- // ioArgs: dojo/main.__IoCallbackArgs
- // Provides additional information about the request.
- // response: Object
- // The response in the format as defined with handleAs.
- },
-
- error: function(response, ioArgs){
- // summary:
- // This function will
- // be called when the request fails due to a network or server error, the url
- // is invalid, etc. It will also be called if the load or handle callback throws an
- // exception, unless djConfig.debugAtAllCosts is true. This allows deployed applications
- // to continue to run even when a logic error happens in the callback, while making
- // it easier to troubleshoot while in debug mode.
- // ioArgs: dojo/main.__IoCallbackArgs
- // Provides additional information about the request.
- // response: Object
- // The response in the format as defined with handleAs.
- },
-
- handle: function(loadOrError, response, ioArgs){
- // summary:
- // This function will
- // be called at the end of every request, whether or not an error occurs.
- // loadOrError: String
- // Provides a string that tells you whether this function
- // was called because of success (load) or failure (error).
- // response: Object
- // The response in the format as defined with handleAs.
- // ioArgs: dojo/main.__IoCallbackArgs
- // Provides additional information about the request.
- }
- });
-
- dojo.__IoCallbackArgs = declare(null, {
- // args: Object
- // the original object argument to the IO call.
- // xhr: XMLHttpRequest
- // For XMLHttpRequest calls only, the
- // XMLHttpRequest object that was used for the
- // request.
- // url: String
- // The final URL used for the call. Many times it
- // will be different than the original args.url
- // value.
- // query: String
- // For non-GET requests, the
- // name1=value1&name2=value2 parameters sent up in
- // the request.
- // handleAs: String
- // The final indicator on how the response will be
- // handled.
- // id: String
- // For dojo/io/script calls only, the internal
- // script ID used for the request.
- // canDelete: Boolean
- // For dojo/io/script calls only, indicates
- // whether the script tag that represents the
- // request can be deleted after callbacks have
- // been called. Used internally to know when
- // cleanup can happen on JSONP-type requests.
- // json: Object
- // For dojo/io/script calls only: holds the JSON
- // response for JSONP-type requests. Used
- // internally to hold on to the JSON responses.
- // You should not need to access it directly --
- // the same object should be passed to the success
- // callbacks directly.
- });
-
- dojo.__IoPublish = declare(null, {
- // summary:
- // This is a list of IO topics that can be published
- // if djConfig.ioPublish is set to true. IO topics can be
- // published for any Input/Output, network operation. So,
- // dojo.xhr, dojo.io.script and dojo.io.iframe can all
- // trigger these topics to be published.
- // start: String
- // "/dojo/io/start" is sent when there are no outstanding IO
- // requests, and a new IO request is started. No arguments
- // are passed with this topic.
- // send: String
- // "/dojo/io/send" is sent whenever a new IO request is started.
- // It passes the dojo.Deferred for the request with the topic.
- // load: String
- // "/dojo/io/load" is sent whenever an IO request has loaded
- // successfully. It passes the response and the dojo.Deferred
- // for the request with the topic.
- // error: String
- // "/dojo/io/error" is sent whenever an IO request has errored.
- // It passes the error and the dojo.Deferred
- // for the request with the topic.
- // done: String
- // "/dojo/io/done" is sent whenever an IO request has completed,
- // either by loading or by erroring. It passes the error and
- // the dojo.Deferred for the request with the topic.
- // stop: String
- // "/dojo/io/stop" is sent when all outstanding IO requests have
- // finished. No arguments are passed with this topic.
- });
- =====*/
-
-
- dojo._ioSetArgs = function(/*dojo/main.__IoArgs*/args,
- /*Function*/canceller,
- /*Function*/okHandler,
- /*Function*/errHandler){
- // summary:
- // sets up the Deferred and ioArgs property on the Deferred so it
- // can be used in an io call.
- // args:
- // The args object passed into the public io call. Recognized properties on
- // the args object are:
- // canceller:
- // The canceller function used for the Deferred object. The function
- // will receive one argument, the Deferred object that is related to the
- // canceller.
- // okHandler:
- // The first OK callback to be registered with Deferred. It has the opportunity
- // to transform the OK response. It will receive one argument -- the Deferred
- // object returned from this function.
- // errHandler:
- // The first error callback to be registered with Deferred. It has the opportunity
- // to do cleanup on an error. It will receive two arguments: error (the
- // Error object) and dfd, the Deferred object returned from this function.
-
- var ioArgs = {args: args, url: args.url};
-
- //Get values from form if requested.
- var formObject = null;
- if(args.form){
- var form = dom.byId(args.form);
- //IE requires going through getAttributeNode instead of just getAttribute in some form cases,
- //so use it for all. See #2844
- var actnNode = form.getAttributeNode("action");
- ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
- formObject = domForm.toObject(form);
- }
-
- // set up the query params
- var miArgs = [{}];
-
- if(formObject){
- // potentially over-ride url-provided params w/ form values
- miArgs.push(formObject);
- }
- if(args.content){
- // stuff in content over-rides what's set by form
- miArgs.push(args.content);
- }
- if(args.preventCache){
- miArgs.push({"dojo.preventCache": new Date().valueOf()});
- }
- ioArgs.query = ioq.objectToQuery(lang.mixin.apply(null, miArgs));
-
- // .. and the real work of getting the deferred in order, etc.
- ioArgs.handleAs = args.handleAs || "text";
- var d = new Deferred(function(dfd){
- dfd.canceled = true;
- canceller && canceller(dfd);
-
- var err = dfd.ioArgs.error;
- if(!err){
- err = new Error("request cancelled");
- err.dojoType="cancel";
- dfd.ioArgs.error = err;
- }
- return err;
- });
- d.addCallback(okHandler);
-
- //Support specifying load, error and handle callback functions from the args.
- //For those callbacks, the "this" object will be the args object.
- //The callbacks will get the deferred result value as the
- //first argument and the ioArgs object as the second argument.
- var ld = args.load;
- if(ld && lang.isFunction(ld)){
- d.addCallback(function(value){
- return ld.call(args, value, ioArgs);
- });
- }
- var err = args.error;
- if(err && lang.isFunction(err)){
- d.addErrback(function(value){
- return err.call(args, value, ioArgs);
- });
- }
- var handle = args.handle;
- if(handle && lang.isFunction(handle)){
- d.addBoth(function(value){
- return handle.call(args, value, ioArgs);
- });
- }
-
- // Attach error handler last (not including topic publishing)
- // to catch any errors that may have been generated from load
- // or handle functions.
- d.addErrback(function(error){
- return errHandler(error, d);
- });
-
- //Plug in topic publishing, if dojo.publish is loaded.
- if(cfg.ioPublish && dojo.publish && ioArgs.args.ioPublish !== false){
- d.addCallbacks(
- function(res){
- dojo.publish("/dojo/io/load", [d, res]);
- return res;
- },
- function(res){
- dojo.publish("/dojo/io/error", [d, res]);
- return res;
- }
- );
- d.addBoth(function(res){
- dojo.publish("/dojo/io/done", [d, res]);
- return res;
- });
- }
-
- d.ioArgs = ioArgs;
-
- // FIXME: need to wire up the xhr object's abort method to something
- // analogous in the Deferred
- return d;
- };
-
- var _deferredOk = function(/*Deferred*/dfd){
- // summary:
- // okHandler function for dojo._ioSetArgs call.
-
- var ret = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
- return ret === undefined ? null : ret;
- };
- var _deferError = function(/*Error*/error, /*Deferred*/dfd){
- // summary:
- // errHandler function for dojo._ioSetArgs call.
-
- if(!dfd.ioArgs.args.failOk){
- console.error(error);
- }
- return error;
- };
-
- //Use a separate count for knowing if we are starting/stopping io calls.
- var _checkPubCount = function(dfd){
- if(_pubCount <= 0){
- _pubCount = 0;
- if(cfg.ioPublish && dojo.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){
- dojo.publish("/dojo/io/stop");
- }
- }
- };
-
- var _pubCount = 0;
- aspect.after(watch, "_onAction", function(){
- _pubCount -= 1;
- });
- aspect.after(watch, "_onInFlight", _checkPubCount);
-
- dojo._ioCancelAll = watch.cancelAll;
- /*=====
- dojo._ioCancelAll = function(){
- // summary:
- // Cancels all pending IO requests, regardless of IO type
- // (xhr, script, iframe).
- };
- =====*/
-
- dojo._ioNotifyStart = function(/*Deferred*/dfd){
- // summary:
- // If dojo.publish is available, publish topics
- // about the start of a request queue and/or the
- // the beginning of request.
- //
- // Used by IO transports. An IO transport should
- // call this method before making the network connection.
- if(cfg.ioPublish && dojo.publish && dfd.ioArgs.args.ioPublish !== false){
- if(!_pubCount){
- dojo.publish("/dojo/io/start");
- }
- _pubCount += 1;
- dojo.publish("/dojo/io/send", [dfd]);
- }
- };
-
- dojo._ioWatch = function(dfd, validCheck, ioCheck, resHandle){
- // summary:
- // Watches the io request represented by dfd to see if it completes.
- // dfd: Deferred
- // The Deferred object to watch.
- // validCheck: Function
- // Function used to check if the IO request is still valid. Gets the dfd
- // object as its only argument.
- // ioCheck: Function
- // Function used to check if basic IO call worked. Gets the dfd
- // object as its only argument.
- // resHandle: Function
- // Function used to process response. Gets the dfd
- // object as its only argument.
-
- var args = dfd.ioArgs.options = dfd.ioArgs.args;
- lang.mixin(dfd, {
- response: dfd.ioArgs,
- isValid: function(response){
- return validCheck(dfd);
- },
- isReady: function(response){
- return ioCheck(dfd);
- },
- handleResponse: function(response){
- return resHandle(dfd);
- }
- });
- watch(dfd);
-
- _checkPubCount(dfd);
- };
-
- var _defaultContentType = "application/x-www-form-urlencoded";
-
- dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){
- // summary:
- // Adds query params discovered by the io deferred construction to the URL.
- // Only use this for operations which are fundamentally GET-type operations.
- if(ioArgs.query.length){
- ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
- ioArgs.query = null;
- }
- };
-
- /*=====
- dojo.__XhrArgs = declare(dojo.__IoArgs, {
- // summary:
- // In addition to the properties listed for the dojo._IoArgs type,
- // the following properties are allowed for dojo.xhr* methods.
- // handleAs: String?
- // Acceptable values are: text (default), json, json-comment-optional,
- // json-comment-filtered, javascript, xml. See `dojo/_base/xhr.contentHandlers`
- // sync: Boolean?
- // false is default. Indicates whether the request should
- // be a synchronous (blocking) request.
- // headers: Object?
- // Additional HTTP headers to send in the request.
- // failOk: Boolean?
- // false is default. Indicates whether a request should be
- // allowed to fail (and therefore no console error message in
- // the event of a failure)
- // contentType: String|Boolean
- // "application/x-www-form-urlencoded" is default. Set to false to
- // prevent a Content-Type header from being sent, or to a string
- // to send a different Content-Type.
- });
- =====*/
-
- dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
- // summary:
- // Deprecated. Use dojo/request instead.
- // description:
- // Sends an HTTP request with the given method.
- // See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
- // for those HTTP methods. There are also methods for "raw" PUT and POST methods
- // via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
- // method:
- // HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase.
- // hasBody:
- // If the request has an HTTP body, then pass true for hasBody.
-
- var rDfd;
- //Make the Deferred object for this xhr request.
- var dfd = dojo._ioSetArgs(args, function(dfd){
- rDfd && rDfd.cancel();
- }, _deferredOk, _deferError);
- var ioArgs = dfd.ioArgs;
-
- //Allow for specifying the HTTP body completely.
- if("postData" in args){
- ioArgs.query = args.postData;
- }else if("putData" in args){
- ioArgs.query = args.putData;
- }else if("rawBody" in args){
- ioArgs.query = args.rawBody;
- }else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) === -1){
- //Check for hasBody being passed. If no hasBody,
- //then only append query string if not a POST or PUT request.
- dojo._ioAddQueryToUrl(ioArgs);
- }
-
- var options = {
- method: method,
- handleAs: "text",
- timeout: args.timeout,
- withCredentials: args.withCredentials,
- ioArgs: ioArgs
- };
-
- if(typeof args.headers !== 'undefined'){
- options.headers = args.headers;
- }
- if(typeof args.contentType !== 'undefined'){
- if(!options.headers){
- options.headers = {};
- }
- options.headers['Content-Type'] = args.contentType;
- }
- if(typeof ioArgs.query !== 'undefined'){
- options.data = ioArgs.query;
- }
- if(typeof args.sync !== 'undefined'){
- options.sync = args.sync;
- }
-
- dojo._ioNotifyStart(dfd);
- try{
- rDfd = _xhr(ioArgs.url, options, true);
- }catch(e){
- // If XHR creation fails, dojo/request/xhr throws
- // When this happens, cancel the deferred
- dfd.cancel();
- return dfd;
- }
-
- // sync ioArgs
- dfd.ioArgs.xhr = rDfd.response.xhr;
-
- rDfd.then(function(){
- dfd.resolve(dfd);
- }).otherwise(function(error){
- ioArgs.error = error;
- if(error.response){
- error.status = error.response.status;
- error.responseText = error.response.text;
- error.xhr = error.response.xhr;
- }
- dfd.reject(error);
- });
- return dfd; // dojo/_base/Deferred
- };
-
- dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
- // summary:
- // Sends an HTTP GET request to the server.
- return dojo.xhr("GET", args); // dojo/_base/Deferred
- };
-
- dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
- // summary:
- // Sends an HTTP POST request to the server. In addition to the properties
- // listed for the dojo.__XhrArgs type, the following property is allowed:
- // postData:
- // String. Send raw data in the body of the POST request.
- return dojo.xhr("POST", args, true); // dojo/_base/Deferred
- };
-
- dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
- // summary:
- // Sends an HTTP PUT request to the server. In addition to the properties
- // listed for the dojo.__XhrArgs type, the following property is allowed:
- // putData:
- // String. Send raw data in the body of the PUT request.
- return dojo.xhr("PUT", args, true); // dojo/_base/Deferred
- };
-
- dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
- // summary:
- // Sends an HTTP DELETE request to the server.
- return dojo.xhr("DELETE", args); // dojo/_base/Deferred
- };
-
- /*
- dojo.wrapForm = function(formNode){
- // summary:
- // A replacement for FormBind, but not implemented yet.
-
- // FIXME: need to think harder about what extensions to this we might
- // want. What should we allow folks to do w/ this? What events to
- // set/send?
- throw new Error("dojo.wrapForm not yet implemented");
- }
- */
-
- dojo._isDocumentOk = function(x){
- return util.checkStatus(x.status);
- };
-
- dojo._getText = function(url){
- var result;
- dojo.xhrGet({url:url, sync:true, load:function(text){
- result = text;
- }});
- return result;
- };
-
- // Add aliases for static functions to dojo.xhr since dojo.xhr is what's returned from this module
- lang.mixin(dojo.xhr, {
- _xhrObj: dojo._xhrObj,
- fieldToObject: domForm.fieldToObject,
- formToObject: domForm.toObject,
- objectToQuery: ioq.objectToQuery,
- formToQuery: domForm.toQuery,
- formToJson: domForm.toJson,
- queryToObject: ioq.queryToObject,
- contentHandlers: handlers,
- _ioSetArgs: dojo._ioSetArgs,
- _ioCancelAll: dojo._ioCancelAll,
- _ioNotifyStart: dojo._ioNotifyStart,
- _ioWatch: dojo._ioWatch,
- _ioAddQueryToUrl: dojo._ioAddQueryToUrl,
- _isDocumentOk: dojo._isDocumentOk,
- _getText: dojo._getText,
- get: dojo.xhrGet,
- post: dojo.xhrPost,
- put: dojo.xhrPut,
- del: dojo.xhrDelete // because "delete" is a reserved word
- });
-
- return dojo.xhr;
-});
diff --git a/lib/dojo/_firebug/LICENSE b/lib/dojo/_firebug/LICENSE
deleted file mode 100644
index 8c777a2..0000000
--- a/lib/dojo/_firebug/LICENSE
+++ /dev/null
@@ -1,37 +0,0 @@
-License Disclaimer:
-
-All contents of this directory are Copyright (c) the Dojo Foundation, with the
-following exceptions:
--------------------------------------------------------------------------------
-
-firebug.html, firebug.js, errIcon.png, infoIcon.png, warningIcon.png:
- * Copyright (c) 2006-2007, Joe Hewitt, All rights reserved.
- Distributed under the terms of the BSD License (see below)
-
--------------------------------------------------------------------------------
-
-Copyright (c) 2006-2007, Joe Hewitt
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
- * Neither the name of the Dojo Foundation nor the names of its contributors
- may be used to endorse or promote products derived from this software
- without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/dojo/_firebug/errorIcon.png b/lib/dojo/_firebug/errorIcon.png
deleted file mode 100644
index 2d75261..0000000
Binary files a/lib/dojo/_firebug/errorIcon.png and /dev/null differ
diff --git a/lib/dojo/_firebug/firebug.css b/lib/dojo/_firebug/firebug.css
deleted file mode 100644
index 3b6f4f9..0000000
--- a/lib/dojo/_firebug/firebug.css
+++ /dev/null
@@ -1,208 +0,0 @@
-.firebug {
- margin: 0;
- background:#fff;
- font-family: Lucida Grande, Tahoma, sans-serif;
- font-size: 11px;
- overflow: hidden;
- border: 1px solid black;
- position: relative;
-}
-.firebug a {
- text-decoration: none;
-}
-.firebug a:hover {
- text-decoration: underline;
-}
-.firebug a:visited{
- color:#0000FF;
-}
-.firebug #firebugToolbar {
- height: 18px;
- line-height:18px;
- border-top: 1px solid ThreeDHighlight;
- border-bottom: 1px solid ThreeDShadow;
- padding: 2px 6px;
-
- background:#f0f0f0;
-}
-.firebug #firebugLog, .firebug #objectLog {
- overflow: auto;
- position: absolute;
- left: 0;
- width: 100%;
-}
-#objectLog{
- overflow:scroll;
- height:258px;
-}
-.firebug #firebugCommandLine {
- position: absolute;
- bottom: 0;
- left: 0;
- width: 100%;
- height: 18px;
- border: none;
- border-top: 1px solid ThreeDShadow;
-}
-.firebug .logRow {
- position: relative;
- border-bottom: 1px solid #D7D7D7;
- padding: 2px 4px 1px 6px;
- background-color: #FFFFFF;
-}
-.firebug .logRow-command {
- font-family: Monaco, monospace;
- color: blue;
-}
-.firebug .objectBox-null {
- padding: 0 2px;
- border: 1px solid #666666;
- background-color: #888888;
- color: #FFFFFF;
-}
-.firebug .objectBox-string {
- font-family: Monaco, monospace;
- color: red;
- white-space: pre;
-}
-.firebug .objectBox-number {
- color: #000088;
-}
-.firebug .objectBox-function {
- font-family: Monaco, monospace;
- color: DarkGreen;
-}
-.firebug .objectBox-object {
- color: DarkGreen;
- font-weight: bold;
-}
-.firebug .logRow-info,
-.firebug .logRow-error,
-.firebug .logRow-warning
- {
- background: #00FFFF no-repeat 2px 2px;
- padding-left: 20px;
- padding-bottom: 3px;
-}
-.firebug .logRow-info {
- background: #FFF url(infoIcon.png) no-repeat 2px 2px;
- padding-left: 20px;
- padding-bottom: 3px;
-}
-.firebug .logRow-warning {
-
- background: #00FFFF url(warningIcon.png) no-repeat 2px 2px;
- padding-left: 20px;
- padding-bottom: 3px;
-}
-.firebug .logRow-error {
- background: LightYellow url(errorIcon.png) no-repeat 2px 2px;
- padding-left: 20px;
- padding-bottom: 3px;
-}
-.firebug .errorMessage {
- vertical-align: top;
- color: #FF0000;
-}
-.firebug .objectBox-sourceLink {
- position: absolute;
- right: 4px;
- top: 2px;
- padding-left: 8px;
- font-family: Lucida Grande, sans-serif;
- font-weight: bold;
- color: #0000FF;
-}
-.firebug .logRow-group {
- background: #EEEEEE;
- border-bottom: none;
-}
-.firebug .logGroup {
- background: #EEEEEE;
-}
-.firebug .logGroupBox {
- margin-left: 24px;
- border-top: 1px solid #D7D7D7;
- border-left: 1px solid #D7D7D7;
-}
-.firebug .selectorTag,
-.firebug .selectorId,
-.firebug .selectorClass {
- font-family: Monaco, monospace;
- font-weight: normal;
-}
-.firebug .selectorTag {
- color: #0000FF;
-}
-.firebug .selectorId {
- color: DarkBlue;
-}
-.firebug .selectorClass {
- color: red;
-}
-.firebug .objectBox-element {
- font-family: Monaco, monospace;
- color: #000088;
-}
-.firebug .nodeChildren {
- margin-left: 16px;
-}
-.firebug .nodeTag {
- color: blue;
-}
-.firebug .nodeValue {
- color: #FF0000;
- font-weight: normal;
-}
-.firebug .nodeText,
-.firebug .nodeComment {
- margin: 0 2px;
- vertical-align: top;
-}
-.firebug .nodeText {
- color: #333333;
-}
-.firebug .nodeComment {
- color: DarkGreen;
-}
-.firebug .propertyNameCell {
- vertical-align: top;
-}
-.firebug .propertyName {
- font-weight: bold;
-}
-#firebugToolbar ul.tabs{
- margin:0 !important;
- padding:0;
-}
-#firebugToolbar ul.tabs li{
- list-style:none;
- background:transparent url(tab_lft_norm.png) no-repeat left;
- line-height:18px;
- float:left;
- margin-left:5px;
-}
-#firebugToolbar ul.tabs li.right{
- float:right;
- margin-right:5px;
- margin-left:0;
-}
-#firebugToolbar ul.tabs li.gap{
- margin-left:20px;
-}
-#firebugToolbar .tabs a{
- text-decoration:none;
- background:transparent url(tab_rgt_norm.png) no-repeat right;
- line-height:18px;
- padding:3px 9px 4px 0px;
- margin-left:9px;
- color:#333333;
-}
-#firebugToolbar .tabs li:hover{
- background:transparent url(tab_lft_over.png) no-repeat left;
-}
-#firebugToolbar .tabs a:hover{
- text-decoration:none;
- background:transparent url(tab_rgt_over.png) no-repeat right;
- color:#FFFFFF;
-}
diff --git a/lib/dojo/_firebug/firebug.js b/lib/dojo/_firebug/firebug.js
deleted file mode 100644
index adbb692..0000000
--- a/lib/dojo/_firebug/firebug.js
+++ /dev/null
@@ -1,898 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/_firebug/firebug",["../_base/kernel","require","../_base/html","../sniff","../_base/array","../_base/lang","../_base/event","../_base/unload"],function(_1,_2,_3,_4){
-var _5=(/Trident/.test(window.navigator.userAgent));
-if(_5){
-var _6=["log","info","debug","warn","error"];
-for(var i=0;i<_6.length;i++){
-var m=_6[i];
-if(!console[m]||console[m]._fake){
-continue;
-}
-var n="_"+_6[i];
-console[n]=console[m];
-console[m]=(function(){
-var _7=n;
-return function(){
-console[_7](Array.prototype.join.call(arguments," "));
-};
-})();
-}
-try{
-console.clear();
-}
-catch(e){
-}
-}
-if(_4("ff")||_4("chrome")||_4("safari")||_5||window.firebug||(typeof console!="undefined"&&console.firebug)||_1.config.useCustomLogger||_4("air")){
-return;
-}
-try{
-if(window!=window.parent){
-if(window.parent["console"]){
-window.console=window.parent.console;
-}
-return;
-}
-}
-catch(e){
-}
-var _8=document;
-var _9=window;
-var _a=0;
-var _b=null;
-var _c=null;
-var _d=null;
-var _e=null;
-var _f=null;
-var _10=null;
-var _11=false;
-var _12=[];
-var _13=[];
-var _14={};
-var _15={};
-var _16=null;
-var _17;
-var _18;
-var _19=false;
-var _1a=null;
-var _1b=document.createElement("div");
-var _1c;
-var _1d;
-window.console={_connects:[],log:function(){
-_1e(arguments,"");
-},debug:function(){
-_1e(arguments,"debug");
-},info:function(){
-_1e(arguments,"info");
-},warn:function(){
-_1e(arguments,"warning");
-},error:function(){
-_1e(arguments,"error");
-},assert:function(_1f,_20){
-if(!_1f){
-var _21=[];
-for(var i=1;i");
-str=str.replace(/\t/g," ");
-_23([str],"dir");
-},dirxml:function(_24){
-var _25=[];
-_26(_24,_25);
-_23(_25,"dirxml");
-},group:function(){
-_23(arguments,"group",_27);
-},groupEnd:function(){
-_23(arguments,"",_28);
-},time:function(_29){
-_14[_29]=new Date().getTime();
-},timeEnd:function(_2a){
-if(_2a in _14){
-var _2b=(new Date()).getTime()-_14[_2a];
-_1e([_2a+":",_2b+"ms"]);
-delete _14[_2a];
-}
-},count:function(_2c){
-if(!_15[_2c]){
-_15[_2c]=0;
-}
-_15[_2c]++;
-_1e([_2c+": "+_15[_2c]]);
-},trace:function(_2d){
-var _2e=_2d||3;
-var f=console.trace.caller;
-for(var i=0;i<_2e;i++){
-var _2f=f.toString();
-var _30=[];
-for(var a=0;a=0&&s.href){
-var h=s.href.replace(/(&|%5C?)forceReload=\d+/,"");
-s.href=h+(h.indexOf("?")>=0?"&":"?")+"forceReload="+new Date().valueOf();
-}
-}
-}};
-function _31(_35){
-_11=_35||!_11;
-if(_b){
-_b.style.display=_11?"block":"none";
-}
-};
-function _36(){
-_31(true);
-if(_f){
-_f.focus();
-}
-};
-function _37(x,y,w,h){
-var win=window.open("","_firebug","status=0,menubar=0,resizable=1,top="+y+",left="+x+",width="+w+",height="+h+",scrollbars=1,addressbar=0");
-if(!win){
-var msg="Firebug Lite could not open a pop-up window, most likely because of a blocker.\n"+"Either enable pop-ups for this domain, or change the djConfig to popup=false.";
-alert(msg);
-}
-_38(win);
-var _39=win.document;
-var _3a="Firebug Lite\n"+"\n"+""+"";
-_39.write(_3a);
-_39.close();
-return win;
-};
-function _38(wn){
-var d=new Date();
-d.setTime(d.getTime()+(60*24*60*60*1000));
-d=d.toUTCString();
-var dc=wn.document,_3b;
-if(wn.innerWidth){
-_3b=function(){
-return {w:wn.innerWidth,h:wn.innerHeight};
-};
-}else{
-if(dc.documentElement&&dc.documentElement.clientWidth){
-_3b=function(){
-return {w:dc.documentElement.clientWidth,h:dc.documentElement.clientHeight};
-};
-}else{
-if(dc.body){
-_3b=function(){
-return {w:dc.body.clientWidth,h:dc.body.clientHeight};
-};
-}
-}
-}
-window.onFirebugResize=function(){
-_49(_3b().h);
-clearInterval(wn._firebugWin_resize);
-wn._firebugWin_resize=setTimeout(function(){
-var x=wn.screenLeft,y=wn.screenTop,w=wn.outerWidth||wn.document.body.offsetWidth,h=wn.outerHeight||wn.document.body.offsetHeight;
-document.cookie="_firebugPosition="+[x,y,w,h].join(",")+"; expires="+d+"; path=/";
-},5000);
-};
-};
-function _3c(){
-if(_b){
-return;
-}
-_31(true);
-if(_1.config.popup){
-var _3d="100%";
-var _3e=document.cookie.match(/(?:^|; )_firebugPosition=([^;]*)/);
-var p=_3e?_3e[1].split(","):[2,2,320,480];
-_9=_37(p[0],p[1],p[2],p[3]);
-_8=_9.document;
-_1.config.debugContainerId="fb";
-_9.console=window.console;
-_9.dojo=window.dojo;
-}else{
-_8=document;
-_3d=(_1.config.debugHeight||300)+"px";
-}
-var _3f=_8.createElement("link");
-_3f.href=_2.toUrl("./firebug.css");
-_3f.rel="stylesheet";
-_3f.type="text/css";
-var _40=_8.getElementsByTagName("head");
-if(_40){
-_40=_40[0];
-}
-if(!_40){
-_40=_8.getElementsByTagName("html")[0];
-}
-if(_4("ie")){
-window.setTimeout(function(){
-_40.appendChild(_3f);
-},0);
-}else{
-_40.appendChild(_3f);
-}
-if(_1.config.debugContainerId){
-_b=_8.getElementById(_1.config.debugContainerId);
-}
-if(!_b){
-_b=_8.createElement("div");
-_8.body.appendChild(_b);
-}
-_b.className+=" firebug";
-_b.id="firebug";
-_b.style.height=_3d;
-_b.style.display=(_11?"block":"none");
-var _41=function(_42,_43,_44,_45){
-return "
"+_41("Clear","Remove All Console Logs","clear","")+_41("ReCSS","Refresh CSS without reloading page","recss","")+_41("Console","Show Console Logs","openConsole","gap")+_41("DOM","Show DOM Inspector","openDomInspector","")+_41("Object","Show Object Inspector","openObjectInspector","")+((_1.config.popup)?"":_41("Close","Close the console","close","gap"))+"\t
"+"
"+""+""+"
Click on an object in the Log display
"+"
Hover over HTML elements in the main page. Click to hold selection.
'
- ];
-
- logRow(html, "error");
- }
-
-
- //After converting to div instead of iframe, now getting two keydowns right away in IE 6.
- //Make sure there is a little bit of delay.
- var onKeyDownTime = new Date().getTime();
-
- function onKeyDown(event){
- var timestamp = (new Date()).getTime();
- if(timestamp > onKeyDownTime + 200){
- event = dojo.fixEvent(event);
- var keys = dojo.keys;
- var ekc = event.keyCode;
- onKeyDownTime = timestamp;
- if(ekc == keys.F12){
- toggleConsole();
- }else if(
- (ekc == keys.NUMPAD_ENTER || ekc == 76) &&
- event.shiftKey &&
- (event.metaKey || event.ctrlKey)
- ){
- focusCommandLine();
- }else{
- return;
- }
- cancelEvent(event);
- }
- }
-
- function onCommandLineKeyDown(e){
- var dk = dojo.keys;
- if(e.keyCode == 13 && commandLine.value){
- addToHistory(commandLine.value);
- evalCommandLine();
- }else if(e.keyCode == 27){
- commandLine.value = "";
- }else if(e.keyCode == dk.UP_ARROW || e.charCode == dk.UP_ARROW){
- navigateHistory("older");
- }else if(e.keyCode == dk.DOWN_ARROW || e.charCode == dk.DOWN_ARROW){
- navigateHistory("newer");
- }else if(e.keyCode == dk.HOME || e.charCode == dk.HOME){
- historyPosition = 1;
- navigateHistory("older");
- }else if(e.keyCode == dk.END || e.charCode == dk.END){
- historyPosition = 999999;
- navigateHistory("newer");
- }
- }
-
- var historyPosition = -1;
- var historyCommandLine = null;
-
- function addToHistory(value){
- var history = cookie("firebug_history");
- history = (history) ? dojo.fromJson(history) : [];
- var pos = dojo.indexOf(history, value);
- if (pos != -1){
- history.splice(pos, 1);
- }
- history.push(value);
- cookie("firebug_history", dojo.toJson(history), 30);
- while(history.length && !cookie("firebug_history")){
- history.shift();
- cookie("firebug_history", dojo.toJson(history), 30);
- }
- historyCommandLine = null;
- historyPosition = -1;
- }
-
- function navigateHistory(direction){
- var history = cookie("firebug_history");
- history = (history) ? dojo.fromJson(history) : [];
- if(!history.length){
- return;
- }
-
- if(historyCommandLine === null){
- historyCommandLine = commandLine.value;
- }
-
- if(historyPosition == -1){
- historyPosition = history.length;
- }
-
- if(direction == "older"){
- --historyPosition;
- if(historyPosition < 0){
- historyPosition = 0;
- }
- }else if(direction == "newer"){
- ++historyPosition;
- if(historyPosition > history.length){
- historyPosition = history.length;
- }
- }
-
- if(historyPosition == history.length){
- commandLine.value = historyCommandLine;
- historyCommandLine = null;
- }else{
- commandLine.value = history[historyPosition];
- }
- }
-
- function cookie(name, value){
- var c = document.cookie;
- if(arguments.length == 1){
- var matches = c.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
- return matches ? decodeURIComponent(matches[1]) : undefined; // String or undefined
- }else{
- var d = new Date();
- d.setMonth(d.getMonth()+1);
- document.cookie = name + "=" + encodeURIComponent(value) + ((d.toUtcString) ? "; expires=" + d.toUTCString() : "");
- }
- }
-
- function isArray(it){
- return it && it instanceof Array || typeof it == "array";
- }
-
- //***************************************************************************************************
- // Print Object Helpers
- function objectLength(o){
- var cnt = 0;
- for(var nm in o){
- cnt++;
- }
- return cnt;
- }
-
- function printObject(o, i, txt, used){
- // Recursively trace object, indenting to represent depth for display in object inspector
- var ind = " \t";
- txt = txt || "";
- i = i || ind;
- used = used || [];
- var opnCls;
-
- if(o && o.nodeType == 1){
- var html = [];
- appendNode(o, html);
- return html.join("");
- }
-
- var br=",\n", cnt = 0, length = objectLength(o);
-
- if(o instanceof Date){
- return i + o.toString() + br;
- }
- looking:
- for(var nm in o){
- cnt++;
- if(cnt==length){br = "\n";}
- if(o[nm] === window || o[nm] === document){
- // do nothing
- }else if(o[nm] === null){
- txt += i+nm + " : NULL" + br;
- }else if(o[nm] && o[nm].nodeType){
- if(o[nm].nodeType == 1){
- //txt += i+nm + " : < "+o[nm].tagName+" id=\""+ o[nm].id+"\" />" + br;
- }else if(o[nm].nodeType == 3){
- txt += i+nm + " : [ TextNode "+o[nm].data + " ]" + br;
- }
-
- }else if(typeof o[nm] == "object" && (o[nm] instanceof String || o[nm] instanceof Number || o[nm] instanceof Boolean)){
- txt += i+nm + " : " + o[nm] + "," + br;
-
- }else if(o[nm] instanceof Date){
- txt += i+nm + " : " + o[nm].toString() + br;
-
- }else if(typeof(o[nm]) == "object" && o[nm]){
- for(var j = 0, seen; seen = used[j]; j++){
- if(o[nm] === seen){
- txt += i+nm + " : RECURSION" + br;
- continue looking;
- }
- }
- used.push(o[nm]);
-
- opnCls = (isArray(o[nm]))?["[","]"]:["{","}"];
- txt += i+nm +" : " + opnCls[0] + "\n";//non-standard break, (no comma)
- txt += printObject(o[nm], i+ind, "", used);
- txt += i + opnCls[1] + br;
-
- }else if(typeof o[nm] == "undefined"){
- txt += i+nm + " : undefined" + br;
- }else if(nm == "toString" && typeof o[nm] == "function"){
- var toString = o[nm]();
- if(typeof toString == "string" && toString.match(/function ?(.*?)\(/)){
- toString = escapeHTML(getObjectAbbr(o[nm]));
- }
- txt += i+nm +" : " + toString + br;
- }else{
- txt += i+nm +" : "+ escapeHTML(getObjectAbbr(o[nm])) + br;
- }
- }
- return txt;
- }
-
- function getObjectAbbr(obj){
- // Gets an abbreviation of an object for display in log
- // X items in object, including id
- // X items in an array
- // TODO: Firebug Sr. actually goes by char count
- var isError = (obj instanceof Error);
- if(obj.nodeType == 1){
- return escapeHTML('< '+obj.tagName.toLowerCase()+' id=\"'+ obj.id+ '\" />');
- }
- if(obj.nodeType == 3){
- return escapeHTML('[TextNode: "'+obj.nodeValue+'"]');
- }
- var nm = (obj && (obj.id || obj.name || obj.ObjectID || obj.widgetId));
- if(!isError && nm){ return "{"+nm+"}"; }
-
- var obCnt = 2;
- var arCnt = 4;
- var cnt = 0;
-
- if(isError){
- nm = "[ Error: "+(obj.message || obj.description || obj)+" ]";
- }else if(isArray(obj)){
- nm = "[" + obj.slice(0,arCnt).join(",");
- if(obj.length > arCnt){
- nm += " ... ("+obj.length+" items)";
- }
- nm += "]";
- }else if(typeof obj == "function"){
- nm = obj + "";
- var reg = /function\s*([^\(]*)(\([^\)]*\))[^\{]*\{/;
- var m = reg.exec(nm);
- if(m){
- if(!m[1]){
- m[1] = "function";
- }
- nm = m[1] + m[2];
- }else{
- nm = "function()";
- }
- }else if(typeof obj != "object" || typeof obj == "string"){
- nm = obj + "";
- }else{
- nm = "{";
- for(var i in obj){
- cnt++;
- if(cnt > obCnt){ break; }
- nm += i+":"+escapeHTML(obj[i])+" ";
- }
- nm+="}";
- }
-
- return nm;
- }
-
- //*************************************************************************************
-
- //window.onerror = onError;
-
- addEvent(document, has("ie") || has("safari") ? "keydown" : "keypress", onKeyDown);
-
- if( (document.documentElement.getAttribute("debug") == "true")||
- (dojo.config.isDebug)
- ){
- toggleConsole(true);
- }
-
- dojo.addOnWindowUnload(function(){
- // Erase the globals and event handlers I created, to prevent spurious leak warnings
- removeEvent(document, has("ie") || has("safari") ? "keydown" : "keypress", onKeyDown);
- window.onFirebugResize = null;
- window.console = null;
- });
-
-});
diff --git a/lib/dojo/_firebug/infoIcon.png b/lib/dojo/_firebug/infoIcon.png
deleted file mode 100644
index da1e533..0000000
Binary files a/lib/dojo/_firebug/infoIcon.png and /dev/null differ
diff --git a/lib/dojo/_firebug/tab_lft_norm.png b/lib/dojo/_firebug/tab_lft_norm.png
deleted file mode 100644
index f0479a2..0000000
Binary files a/lib/dojo/_firebug/tab_lft_norm.png and /dev/null differ
diff --git a/lib/dojo/_firebug/tab_lft_over.png b/lib/dojo/_firebug/tab_lft_over.png
deleted file mode 100644
index 2f36cca..0000000
Binary files a/lib/dojo/_firebug/tab_lft_over.png and /dev/null differ
diff --git a/lib/dojo/_firebug/tab_rgt_norm.png b/lib/dojo/_firebug/tab_rgt_norm.png
deleted file mode 100644
index 464af3e..0000000
Binary files a/lib/dojo/_firebug/tab_rgt_norm.png and /dev/null differ
diff --git a/lib/dojo/_firebug/tab_rgt_over.png b/lib/dojo/_firebug/tab_rgt_over.png
deleted file mode 100644
index 2bc2cd0..0000000
Binary files a/lib/dojo/_firebug/tab_rgt_over.png and /dev/null differ
diff --git a/lib/dojo/_firebug/warningIcon.png b/lib/dojo/_firebug/warningIcon.png
deleted file mode 100644
index de51084..0000000
Binary files a/lib/dojo/_firebug/warningIcon.png and /dev/null differ
diff --git a/lib/dojo/aspect.js b/lib/dojo/aspect.js
deleted file mode 100644
index 031cb85..0000000
--- a/lib/dojo/aspect.js
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/aspect",[],function(){
-"use strict";
-var _1,_2=0;
-function _3(_4,_5,_6,_7){
-var _8=_4[_5];
-var _9=_5=="around";
-var _a;
-if(_9){
-var _b=_6(function(){
-return _8.advice(this,arguments);
-});
-_a={remove:function(){
-if(_b){
-_b=_4=_6=null;
-}
-},advice:function(_c,_d){
-return _b?_b.apply(_c,_d):_8.advice(_c,_d);
-}};
-}else{
-_a={remove:function(){
-if(_a.advice){
-var _e=_a.previous;
-var _f=_a.next;
-if(!_f&&!_e){
-delete _4[_5];
-}else{
-if(_e){
-_e.next=_f;
-}else{
-_4[_5]=_f;
-}
-if(_f){
-_f.previous=_e;
-}
-}
-_4=_6=_a.advice=null;
-}
-},id:_2++,advice:_6,receiveArguments:_7};
-}
-if(_8&&!_9){
-if(_5=="after"){
-while(_8.next&&(_8=_8.next)){
-}
-_8.next=_a;
-_a.previous=_8;
-}else{
-if(_5=="before"){
-_4[_5]=_a;
-_a.next=_8;
-_8.previous=_a;
-}
-}
-}else{
-_4[_5]=_a;
-}
-return _a;
-};
-function _10(_11){
-return function(_12,_13,_14,_15){
-var _16=_12[_13],_17;
-if(!_16||_16.target!=_12){
-_12[_13]=_17=function(){
-var _18=_2;
-var _19=arguments;
-var _1a=_17.before;
-while(_1a){
-_19=_1a.advice.apply(this,_19)||_19;
-_1a=_1a.next;
-}
-if(_17.around){
-var _1b=_17.around.advice(this,_19);
-}
-var _1c=_17.after;
-while(_1c&&_1c.id<_18){
-if(_1c.receiveArguments){
-var _1d=_1c.advice.apply(this,_19);
-_1b=_1d===_1?_1b:_1d;
-}else{
-_1b=_1c.advice.call(this,_1b,_19);
-}
-_1c=_1c.next;
-}
-return _1b;
-};
-if(_16){
-_17.around={advice:function(_1e,_1f){
-return _16.apply(_1e,_1f);
-}};
-}
-_17.target=_12;
-}
-var _20=_3((_17||_16),_11,_14,_15);
-_14=null;
-return _20;
-};
-};
-var _21=_10("after");
-var _22=_10("before");
-var _23=_10("around");
-return {before:_22,around:_23,after:_21};
-});
diff --git a/lib/dojo/aspect.js.uncompressed.js b/lib/dojo/aspect.js.uncompressed.js
deleted file mode 100644
index 157a1bb..0000000
--- a/lib/dojo/aspect.js.uncompressed.js
+++ /dev/null
@@ -1,223 +0,0 @@
-define("dojo/aspect", [], function(){
-
- // module:
- // dojo/aspect
-
- "use strict";
- var undefined, nextId = 0;
- function advise(dispatcher, type, advice, receiveArguments){
- var previous = dispatcher[type];
- var around = type == "around";
- var signal;
- if(around){
- var advised = advice(function(){
- return previous.advice(this, arguments);
- });
- signal = {
- remove: function(){
- if(advised){
- advised = dispatcher = advice = null;
- }
- },
- advice: function(target, args){
- return advised ?
- advised.apply(target, args) : // called the advised function
- previous.advice(target, args); // cancelled, skip to next one
- }
- };
- }else{
- // create the remove handler
- signal = {
- remove: function(){
- if(signal.advice){
- var previous = signal.previous;
- var next = signal.next;
- if(!next && !previous){
- delete dispatcher[type];
- }else{
- if(previous){
- previous.next = next;
- }else{
- dispatcher[type] = next;
- }
- if(next){
- next.previous = previous;
- }
- }
-
- // remove the advice to signal that this signal has been removed
- dispatcher = advice = signal.advice = null;
- }
- },
- id: nextId++,
- advice: advice,
- receiveArguments: receiveArguments
- };
- }
- if(previous && !around){
- if(type == "after"){
- // add the listener to the end of the list
- // note that we had to change this loop a little bit to workaround a bizarre IE10 JIT bug
- while(previous.next && (previous = previous.next)){}
- previous.next = signal;
- signal.previous = previous;
- }else if(type == "before"){
- // add to beginning
- dispatcher[type] = signal;
- signal.next = previous;
- previous.previous = signal;
- }
- }else{
- // around or first one just replaces
- dispatcher[type] = signal;
- }
- return signal;
- }
- function aspect(type){
- return function(target, methodName, advice, receiveArguments){
- var existing = target[methodName], dispatcher;
- if(!existing || existing.target != target){
- // no dispatcher in place
- target[methodName] = dispatcher = function(){
- var executionId = nextId;
- // before advice
- var args = arguments;
- var before = dispatcher.before;
- while(before){
- args = before.advice.apply(this, args) || args;
- before = before.next;
- }
- // around advice
- if(dispatcher.around){
- var results = dispatcher.around.advice(this, args);
- }
- // after advice
- var after = dispatcher.after;
- while(after && after.id < executionId){
- if(after.receiveArguments){
- var newResults = after.advice.apply(this, args);
- // change the return value only if a new value was returned
- results = newResults === undefined ? results : newResults;
- }else{
- results = after.advice.call(this, results, args);
- }
- after = after.next;
- }
- return results;
- };
- if(existing){
- dispatcher.around = {advice: function(target, args){
- return existing.apply(target, args);
- }};
- }
- dispatcher.target = target;
- }
- var results = advise((dispatcher || existing), type, advice, receiveArguments);
- advice = null;
- return results;
- };
- }
-
- // TODOC: after/before/around return object
-
- var after = aspect("after");
- /*=====
- after = function(target, methodName, advice, receiveArguments){
- // summary:
- // The "after" export of the aspect module is a function that can be used to attach
- // "after" advice to a method. This function will be executed after the original method
- // is executed. By default the function will be called with a single argument, the return
- // value of the original method, or the the return value of the last executed advice (if a previous one exists).
- // The fourth (optional) argument can be set to true to so the function receives the original
- // arguments (from when the original method was called) rather than the return value.
- // If there are multiple "after" advisors, they are executed in the order they were registered.
- // target: Object
- // This is the target object
- // methodName: String
- // This is the name of the method to attach to.
- // advice: Function
- // This is function to be called after the original method
- // receiveArguments: Boolean?
- // If this is set to true, the advice function receives the original arguments (from when the original mehtod
- // was called) rather than the return value of the original/previous method.
- // returns:
- // A signal object that can be used to cancel the advice. If remove() is called on this signal object, it will
- // stop the advice function from being executed.
- };
- =====*/
-
- var before = aspect("before");
- /*=====
- before = function(target, methodName, advice){
- // summary:
- // The "before" export of the aspect module is a function that can be used to attach
- // "before" advice to a method. This function will be executed before the original method
- // is executed. This function will be called with the arguments used to call the method.
- // This function may optionally return an array as the new arguments to use to call
- // the original method (or the previous, next-to-execute before advice, if one exists).
- // If the before method doesn't return anything (returns undefined) the original arguments
- // will be preserved.
- // If there are multiple "before" advisors, they are executed in the reverse order they were registered.
- // target: Object
- // This is the target object
- // methodName: String
- // This is the name of the method to attach to.
- // advice: Function
- // This is function to be called before the original method
- };
- =====*/
-
- var around = aspect("around");
- /*=====
- around = function(target, methodName, advice){
- // summary:
- // The "around" export of the aspect module is a function that can be used to attach
- // "around" advice to a method. The advisor function is immediately executed when
- // the around() is called, is passed a single argument that is a function that can be
- // called to continue execution of the original method (or the next around advisor).
- // The advisor function should return a function, and this function will be called whenever
- // the method is called. It will be called with the arguments used to call the method.
- // Whatever this function returns will be returned as the result of the method call (unless after advise changes it).
- // example:
- // If there are multiple "around" advisors, the most recent one is executed first,
- // which can then delegate to the next one and so on. For example:
- // | around(obj, "foo", function(originalFoo){
- // | return function(){
- // | var start = new Date().getTime();
- // | var results = originalFoo.apply(this, arguments); // call the original
- // | var end = new Date().getTime();
- // | console.log("foo execution took " + (end - start) + " ms");
- // | return results;
- // | };
- // | });
- // target: Object
- // This is the target object
- // methodName: String
- // This is the name of the method to attach to.
- // advice: Function
- // This is function to be called around the original method
- };
- =====*/
-
- return {
- // summary:
- // provides aspect oriented programming functionality, allowing for
- // one to add before, around, or after advice on existing methods.
- // example:
- // | define(["dojo/aspect"], function(aspect){
- // | var signal = aspect.after(targetObject, "methodName", function(someArgument){
- // | this will be called when targetObject.methodName() is called, after the original function is called
- // | });
- //
- // example:
- // The returned signal object can be used to cancel the advice.
- // | signal.remove(); // this will stop the advice from being executed anymore
- // | aspect.before(targetObject, "methodName", function(someArgument){
- // | // this will be called when targetObject.methodName() is called, before the original function is called
- // | });
-
- before: before,
- around: around,
- after: after
- };
-});
diff --git a/lib/dojo/back.js b/lib/dojo/back.js
deleted file mode 100644
index 1e3c4a8..0000000
--- a/lib/dojo/back.js
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
- Available via Academic Free License >= 2.1 OR the modified BSD license.
- see: http://dojotoolkit.org/license for details
-*/
-
-//>>built
-define("dojo/back",["./_base/config","./_base/lang","./sniff","./dom","./dom-construct","./_base/window","require"],function(_1,_2,_3,_4,_5,_6,_7){
-var _8={};
-1&&_2.setObject("dojo.back",_8);
-var _9=_8.getHash=function(){
-var h=window.location.hash;
-if(h.charAt(0)=="#"){
-h=h.substring(1);
-}
-return _3("mozilla")?h:decodeURIComponent(h);
-},_a=_8.setHash=function(h){
-if(!h){
-h="";
-}
-window.location.hash=encodeURIComponent(h);
-_b=history.length;
-};
-var _c=(typeof (window)!=="undefined")?window.location.href:"";
-var _d=(typeof (window)!=="undefined")?_9():"";
-var _e=null;
-var _f=null;
-var _10=null;
-var _11=null;
-var _12=[];
-var _13=[];
-var _14=false;
-var _15=false;
-var _b;
-function _16(){
-var _17=_13.pop();
-if(!_17){
-return;
-}
-var _18=_13[_13.length-1];
-if(!_18&&_13.length==0){
-_18=_e;
-}
-if(_18){
-if(_18.kwArgs["back"]){
-_18.kwArgs["back"]();
-}else{
-if(_18.kwArgs["backButton"]){
-_18.kwArgs["backButton"]();
-}else{
-if(_18.kwArgs["handle"]){
-_18.kwArgs.handle("back");
-}
-}
-}
-}
-_12.push(_17);
-};
-_8.goBack=_16;
-function _19(){
-var _1a=_12.pop();
-if(!_1a){
-return;
-}
-if(_1a.kwArgs["forward"]){
-_1a.kwArgs.forward();
-}else{
-if(_1a.kwArgs["forwardButton"]){
-_1a.kwArgs.forwardButton();
-}else{
-if(_1a.kwArgs["handle"]){
-_1a.kwArgs.handle("forward");
-}
-}
-}
-_13.push(_1a);
-};
-_8.goForward=_19;
-function _1b(url,_1c,_1d){
-return {"url":url,"kwArgs":_1c,"urlHash":_1d};
-};
-function _1e(url){
-var _1f=url.split("?");
-if(_1f.length<2){
-return null;
-}else{
-return _1f[1];
-}
-};
-function _20(){
-var url=(_1["dojoIframeHistoryUrl"]||_7.toUrl("./resources/iframe_history.html"))+"?"+(new Date()).getTime();
-_14=true;
-if(_11){
-_3("webkit")?_11.location=url:window.frames[_11.name].location=url;
-}else{
-}
-return url;
-};
-function _21(){
-if(!_15){
-var hsl=_13.length;
-var _22=_9();
-if((_22===_d||window.location.href==_c)&&(hsl==1)){
-_16();
-return;
-}
-if(_12.length>0){
-if(_12[_12.length-1].urlHash===_22){
-_19();
-return;
-}
-}
-if((hsl>=2)&&(_13[hsl-2])){
-if(_13[hsl-2].urlHash===_22){
-_16();
-}
-}
-}
-};
-_8.init=function(){
-if(_4.byId("dj_history")){
-return;
-}
-var src=_1["dojoIframeHistoryUrl"]||_7.toUrl("./resources/iframe_history.html");
-if(_1.afterOnLoad){
-console.error("dojo/back::init() must be called before the DOM has loaded. "+"Include dojo/back in a build layer.");
-}else{
-document.write("");
-}
-};
-_8.setInitialState=function(_23){
-_e=_1b(_c,_23,_d);
-};
-_8.addToHistory=function(_24){
-_12=[];
-var _25=null;
-var url=null;
-if(!_11){
-if(_1["useXDomain"]&&!_1["dojoIframeHistoryUrl"]){
-console.warn("dojo/back: When using cross-domain Dojo builds,"+" please save iframe_history.html to your domain and set djConfig.dojoIframeHistoryUrl"+" to the path on your domain to iframe_history.html");
-}
-_11=window.frames["dj_history"];
-}
-if(!_10){
-_10=_5.create("a",{style:{display:"none"}},_6.body());
-}
-if(_24["changeUrl"]){
-_25=""+((_24["changeUrl"]!==true)?_24["changeUrl"]:(new Date()).getTime());
-if(_13.length==0&&_e.urlHash==_25){
-_e=_1b(url,_24,_25);
-return;
-}else{
-if(_13.length>0&&_13[_13.length-1].urlHash==_25){
-_13[_13.length-1]=_1b(url,_24,_25);
-return;
-}
-}
-_15=true;
-setTimeout(function(){
-_a(_25);
-_15=false;
-},1);
-_10.href=_25;
-if(_3("ie")){
-url=_20();
-var _26=_24["back"]||_24["backButton"]||_24["handle"];
-var tcb=function(_27){
-if(_9()!=""){
-setTimeout(function(){
-_a(_25);
-},1);
-}
-_26.apply(this,[_27]);
-};
-if(_24["back"]){
-_24.back=tcb;
-}else{
-if(_24["backButton"]){
-_24.backButton=tcb;
-}else{
-if(_24["handle"]){
-_24.handle=tcb;
-}
-}
-}
-var _28=_24["forward"]||_24["forwardButton"]||_24["handle"];
-var tfw=function(_29){
-if(_9()!=""){
-_a(_25);
-}
-if(_28){
-_28.apply(this,[_29]);
-}
-};
-if(_24["forward"]){
-_24.forward=tfw;
-}else{
-if(_24["forwardButton"]){
-_24.forwardButton=tfw;
-}else{
-if(_24["handle"]){
-_24.handle=tfw;
-}
-}
-}
-}else{
-if(!_3("ie")){
-if(!_f){
-_f=setInterval(_21,200);
-}
-}
-}
-}else{
-url=_20();
-}
-_13.push(_1b(url,_24,_25));
-};
-_8._iframeLoaded=function(evt,_2a){
-var _2b=_1e(_2a.href);
-if(_2b==null){
-if(_13.length==1){
-_16();
-}
-return;
-}
-if(_14){
-_14=false;
-return;
-}
-if(_13.length>=2&&_2b==_1e(_13[_13.length-2].url)){
-_16();
-}else{
-if(_12.length>0&&_2b==_1e(_12[_12.length-1].url)){
-_19();
-}
-}
-};
-return _8;
-});
diff --git a/lib/dojo/back.js.uncompressed.js b/lib/dojo/back.js.uncompressed.js
deleted file mode 100644
index f19052b..0000000
--- a/lib/dojo/back.js.uncompressed.js
+++ /dev/null
@@ -1,397 +0,0 @@
-define("dojo/back", ["./_base/config", "./_base/lang", "./sniff", "./dom", "./dom-construct", "./_base/window", "require"],
- function(config, lang, has, dom, domConstruct, baseWindow, require){
- // module:
- // dojo/back
-
- var back = {
- // summary:
- // Browser history management resources
- };
- 1 && lang.setObject("dojo.back", back);
-
- // everyone deals with encoding the hash slightly differently
-
- var getHash = back.getHash = function(){
- var h = window.location.hash;
- if(h.charAt(0) == "#"){ h = h.substring(1); }
- return has("mozilla") ? h : decodeURIComponent(h);
- },
-
- setHash = back.setHash = function(h){
- if(!h){ h = ""; }
- window.location.hash = encodeURIComponent(h);
- historyCounter = history.length;
- };
-
- var initialHref = (typeof(window) !== "undefined") ? window.location.href : "";
- var initialHash = (typeof(window) !== "undefined") ? getHash() : "";
- var initialState = null;
-
- var locationTimer = null;
- var bookmarkAnchor = null;
- var historyIframe = null;
- var forwardStack = [];
- var historyStack = [];
- var moveForward = false;
- var changingUrl = false;
- var historyCounter;
-
- function handleBackButton(){
- // summary:
- // private method. Do not call this directly.
-
- //The "current" page is always at the top of the history stack.
- var current = historyStack.pop();
- if(!current){ return; }
- var last = historyStack[historyStack.length-1];
- if(!last && historyStack.length == 0){
- last = initialState;
- }
- if(last){
- if(last.kwArgs["back"]){
- last.kwArgs["back"]();
- }else if(last.kwArgs["backButton"]){
- last.kwArgs["backButton"]();
- }else if(last.kwArgs["handle"]){
- last.kwArgs.handle("back");
- }
- }
- forwardStack.push(current);
- }
-
- back.goBack = handleBackButton;
-
- function handleForwardButton(){
- // summary:
- // private method. Do not call this directly.
- var last = forwardStack.pop();
- if(!last){ return; }
- if(last.kwArgs["forward"]){
- last.kwArgs.forward();
- }else if(last.kwArgs["forwardButton"]){
- last.kwArgs.forwardButton();
- }else if(last.kwArgs["handle"]){
- last.kwArgs.handle("forward");
- }
- historyStack.push(last);
- }
-
- back.goForward = handleForwardButton;
-
- function createState(url, args, hash){
- // summary:
- // private method. Do not call this directly.
- return {"url": url, "kwArgs": args, "urlHash": hash}; //Object
- }
-
- function getUrlQuery(url){
- // summary:
- // private method. Do not call this directly.
- var segments = url.split("?");
- if(segments.length < 2){
- return null; //null
- }
- else{
- return segments[1]; //String
- }
- }
-
- function loadIframeHistory(){
- // summary:
- // private method. Do not call this directly.
- var url = (config["dojoIframeHistoryUrl"] || require.toUrl("./resources/iframe_history.html")) + "?" + (new Date()).getTime();
- moveForward = true;
- if(historyIframe){
- has("webkit") ? historyIframe.location = url : window.frames[historyIframe.name].location = url;
- }else{
- //console.warn("dojo/back: Not initialised. You need to call back.init() from a
- //
- return new NodeList(); // dojo/NodeList
- };
- =====*/
-
- // the query that is returned from this module is slightly different than dojo.query,
- // because dojo.query has to maintain backwards compatibility with returning a
- // true array which has performance problems. The query returned from the module
- // does not use true arrays, but rather inherits from Array, making it much faster to
- // instantiate.
- dojo.query = queryForEngine(defaultEngine, function(array){
- // call it without the new operator to invoke the back-compat behavior that returns a true array
- return NodeList(array); // dojo/NodeList
- });
-
- query.load = function(id, parentRequire, loaded){
- // summary:
- // can be used as AMD plugin to conditionally load new query engine
- // example:
- // | require(["dojo/query!custom"], function(qsa){
- // | // loaded selector/custom.js as engine
- // | qsa("#foobar").forEach(...);
- // | });
- loader.load(id, parentRequire, function(engine){
- loaded(queryForEngine(engine, NodeList));
- });
- };
-
- dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
- return new NodeList(query.filter(nodes, selector, root));
- };
- dojo.NodeList = query.NodeList = NodeList;
- return query;
-});
-
-},
-'dojo/has':function(){
-define(["require", "module"], function(require, module){
- // module:
- // dojo/has
- // summary:
- // Defines the has.js API and several feature tests used by dojo.
- // description:
- // This module defines the has API as described by the project has.js with the following additional features:
- //
- // - the has test cache is exposed at has.cache.
- // - the method has.add includes a forth parameter that controls whether or not existing tests are replaced
- // - the loader's has cache may be optionally copied into this module's has cahce.
- //
- // This module adopted from https://github.com/phiggins42/has.js; thanks has.js team!
-
- // try to pull the has implementation from the loader; both the dojo loader and bdLoad provide one
- // if using a foreign loader, then the has cache may be initialized via the config object for this module
- // WARNING: if a foreign loader defines require.has to be something other than the has.js API, then this implementation fail
- var has = require.has || function(){};
- if(! 1 ){
- var
- isBrowser =
- // the most fundamental decision: are we in the browser?
- typeof window != "undefined" &&
- typeof location != "undefined" &&
- typeof document != "undefined" &&
- window.location == location && window.document == document,
-
- // has API variables
- global = this,
- doc = isBrowser && document,
- element = doc && doc.createElement("DiV"),
- cache = (module.config && module.config()) || {};
-
- has = function(name){
- // summary:
- // Return the current value of the named feature.
- //
- // name: String|Integer
- // The name (if a string) or identifier (if an integer) of the feature to test.
- //
- // description:
- // Returns the value of the feature named by name. The feature must have been
- // previously added to the cache by has.add.
-
- return typeof cache[name] == "function" ? (cache[name] = cache[name](global, doc, element)) : cache[name]; // Boolean
- };
-
- has.cache = cache;
-
- has.add = function(name, test, now, force){
- // summary:
- // Register a new feature test for some named feature.
- // name: String|Integer
- // The name (if a string) or identifier (if an integer) of the feature to test.
- // test: Function
- // A test function to register. If a function, queued for testing until actually
- // needed. The test function should return a boolean indicating
- // the presence of a feature or bug.
- // now: Boolean?
- // Optional. Omit if `test` is not a function. Provides a way to immediately
- // run the test and cache the result.
- // force: Boolean?
- // Optional. If the test already exists and force is truthy, then the existing
- // test will be replaced; otherwise, add does not replace an existing test (that
- // is, by default, the first test advice wins).
- // example:
- // A redundant test, testFn with immediate execution:
- // | has.add("javascript", function(){ return true; }, true);
- //
- // example:
- // Again with the redundantness. You can do this in your tests, but we should
- // not be doing this in any internal has.js tests
- // | has.add("javascript", true);
- //
- // example:
- // Three things are passed to the testFunction. `global`, `document`, and a generic element
- // from which to work your test should the need arise.
- // | has.add("bug-byid", function(g, d, el){
- // | // g == global, typically window, yadda yadda
- // | // d == document object
- // | // el == the generic element. a `has` element.
- // | return false; // fake test, byid-when-form-has-name-matching-an-id is slightly longer
- // | });
-
- (typeof cache[name]=="undefined" || force) && (cache[name]= test);
- return now && has(name);
- };
-
- // since we're operating under a loader that doesn't provide a has API, we must explicitly initialize
- // has as it would have otherwise been initialized by the dojo loader; use has.add to the builder
- // can optimize these away iff desired
- 1 || has.add("host-browser", isBrowser);
- 0 && has.add("host-node", (typeof process == "object" && process.versions && process.versions.node && process.versions.v8));
- 0 && has.add("host-rhino", (typeof load == "function" && (typeof Packages == "function" || typeof Packages == "object")));
- 1 || has.add("dom", isBrowser);
- 1 || has.add("dojo-dom-ready-api", 1);
- 1 || has.add("dojo-sniff", 1);
- }
-
- if( 1 ){
- // Common application level tests
- has.add("dom-addeventlistener", !!document.addEventListener);
-
- // Do the device and browser have touch capability?
- has.add("touch", "ontouchstart" in document
- || ("onpointerdown" in document && navigator.maxTouchPoints > 0)
- || window.navigator.msMaxTouchPoints);
-
- // Touch events support
- has.add("touch-events", "ontouchstart" in document);
-
- // Pointer Events support
- has.add("pointer-events", "onpointerdown" in document);
- has.add("MSPointer", "msMaxTouchPoints" in navigator); //IE10 (+IE11 preview)
-
- // I don't know if any of these tests are really correct, just a rough guess
- has.add("device-width", screen.availWidth || innerWidth);
-
- // Tests for DOMNode.attributes[] behavior:
- // - dom-attributes-explicit - attributes[] only lists explicitly user specified attributes
- // - dom-attributes-specified-flag (IE8) - need to check attr.specified flag to skip attributes user didn't specify
- // - Otherwise, in IE6-7. attributes[] will list hundreds of values, so need to do outerHTML to get attrs instead.
- var form = document.createElement("form");
- has.add("dom-attributes-explicit", form.attributes.length == 0); // W3C
- has.add("dom-attributes-specified-flag", form.attributes.length > 0 && form.attributes.length < 40); // IE8
- }
-
- has.clearElement = function(element){
- // summary:
- // Deletes the contents of the element passed to test functions.
- element.innerHTML= "";
- return element;
- };
-
- has.normalize = function(id, toAbsMid){
- // summary:
- // Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
- //
- // toAbsMid: Function
- // Resolves a relative module id into an absolute module id
- var
- tokens = id.match(/[\?:]|[^:\?]*/g), i = 0,
- get = function(skip){
- var term = tokens[i++];
- if(term == ":"){
- // empty string module name, resolves to 0
- return 0;
- }else{
- // postfixed with a ? means it is a feature to branch on, the term is the name of the feature
- if(tokens[i++] == "?"){
- if(!skip && has(term)){
- // matched the feature, get the first value from the options
- return get();
- }else{
- // did not match, get the second value, passing over the first
- get(true);
- return get(skip);
- }
- }
- // a module
- return term || 0;
- }
- };
- id = get();
- return id && toAbsMid(id);
- };
-
- has.load = function(id, parentRequire, loaded){
- // summary:
- // Conditional loading of AMD modules based on a has feature test value.
- // id: String
- // Gives the resolved module id to load.
- // parentRequire: Function
- // The loader require function with respect to the module that contained the plugin resource in it's
- // dependency list.
- // loaded: Function
- // Callback to loader that consumes result of plugin demand.
-
- if(id){
- parentRequire([id], loaded);
- }else{
- loaded();
- }
- };
-
- return has;
-});
-
-},
-'dojo/_base/loader':function(){
-define(["./kernel", "../has", "require", "module", "../json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
- // module:
- // dojo/_base/loader
-
- // This module defines the v1.x synchronous loader API.
-
- // signal the loader in sync mode...
- //>>pure-amd
-
- if (! 1 ){
- console.error("cannot load the Dojo v1.x loader with a foreign loader");
- return 0;
- }
-
- 1 || has.add("dojo-fast-sync-require", 1);
-
-
- var makeErrorToken = function(id){
- return {src:thisModule.id, id:id};
- },
-
- slashName = function(name){
- return name.replace(/\./g, "/");
- },
-
- buildDetectRe = /\/\/>>built/,
-
- dojoRequireCallbacks = [],
- dojoRequireModuleStack = [],
-
- dojoRequirePlugin = function(mid, require, loaded){
- dojoRequireCallbacks.push(loaded);
- array.forEach(mid.split(","), function(mid){
- var module = getModule(mid, require.module);
- dojoRequireModuleStack.push(module);
- injectModule(module);
- });
- checkDojoRequirePlugin();
- },
-
- checkDojoRequirePlugin = ( 1 ?
- // This version of checkDojoRequirePlugin makes the observation that all dojoRequireCallbacks can be released
- // when all *non-dojo/require!, dojo/loadInit!* modules are either executed, not requested, or arrived. This is
- // the case since there are no more modules the loader is waiting for, therefore, dojo/require! must have
- // everything it needs on board.
- //
- // The potential weakness of this algorithm is that dojo/require will not execute callbacks until *all* dependency
- // trees are ready. It is possible that some trees may be ready earlier than others, and this extra wait is non-optimal.
- // Still, for big projects, this seems better than the original algorithm below that proved slow in some cases.
- // Note, however, the original algorithm had the potential to execute partial trees, but that potential was never enabled.
- // There are also other optimization available with the original algorithm that have not been explored.
- function(){
- var module, mid;
- for(mid in modules){
- module = modules[mid];
- if(module.noReqPluginCheck===undefined){
- // tag the module as either a loadInit or require plugin or not for future reference
- module.noReqPluginCheck = /loadInit\!/.test(mid) || /require\!/.test(mid) ? 1 : 0;
- }
- if(!module.executed && !module.noReqPluginCheck && module.injected==requested){
- return;
- }
- }
-
- guardCheckComplete(function(){
- var oldCallbacks = dojoRequireCallbacks;
- dojoRequireCallbacks = [];
- array.forEach(oldCallbacks, function(cb){cb(1);});
- });
- } : (function(){
- // Note: this is the original checkDojoRequirePlugin that is much slower than the algorithm above. However, we know it
- // works, so we leave it here in case the algorithm above fails in some corner case.
- //
- // checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require! dependency
- // to see if they have arrived. The loader does not release *any* of these modules to be instantiated
- // until *all* of these modules are on board, thereby preventing the evaluation of a module with dojo.require's
- // that reference modules that are not available.
- //
- // The algorithm works by traversing the dependency graphs (remember, there can be cycles so they are not trees)
- // of each module in the dojoRequireModuleStack array (which contains the list of modules demanded by dojo/require!).
- // The moment a single module is discovered that is missing, the algorithm gives up and indicates that not all
- // modules are on board. dojo/loadInit! and dojo/require! are ignored because there dependencies are inserted
- // directly in dojoRequireModuleStack. For example, if "your/module" module depends on "dojo/require!my/module", then
- // *both* "dojo/require!my/module" and "my/module" will be in dojoRequireModuleStack. Obviously, if "my/module"
- // is on board, then "dojo/require!my/module" is also satisfied, so the algorithm doesn't check for "dojo/require!my/module".
- //
- // Note: inserting a dojo/require! dependency in the dojoRequireModuleStack achieves nothing
- // with the current algorithm; however, having such modules present makes it possible to optimize the algorithm
- //
- // Note: prior versions of this algorithm had an optimization that signaled loaded on dojo/require! dependencies
- // individually (rather than waiting for them all to be resolved). The implementation proved problematic with cycles
- // and plugins. However, it is possible to reattach that strategy in the future.
-
- // a set from module-id to {undefined | 1 | 0}, where...
- // undefined => the module has not been inspected
- // 0 => the module or at least one of its dependencies has not arrived
- // 1 => the module is a loadInit! or require! plugin resource, or is currently being traversed (therefore, assume
- // OK until proven otherwise), or has been completely traversed and all dependencies have arrived
-
- var touched,
- traverse = function(m){
- touched[m.mid] = 1;
- for(var t, module, deps = m.deps || [], i= 0; i a built module, always AMD
- // extractResult==0 => no sync API
- return 0;
- }
-
- // manufacture a synthetic module id that can never be a real mdule id (just like require does)
- id = module.mid + "-*loadInit";
-
- // construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
- // the dojo/loadInit plugin assumes the first name in names is "dojo"
-
- for(var p in getModule("dojo", module).result.scopeMap){
- names.push(p);
- namesAsStrings.push('"' + p + '"');
- }
-
- // rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
- // don't have to map dojo/init since that will occur when the dependency is resolved
- return "// xdomain rewrite of " + module.mid + "\n" +
- "define('" + id + "',{\n" +
- "\tnames:" + json.stringify(names) + ",\n" +
- "\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
- "});\n\n" +
- "define(" + json.stringify(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
- },
-
- loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
-
- sync =
- loaderVars.sync,
-
- requested =
- loaderVars.requested,
-
- arrived =
- loaderVars.arrived,
-
- nonmodule =
- loaderVars.nonmodule,
-
- executing =
- loaderVars.executing,
-
- executed =
- loaderVars.executed,
-
- syncExecStack =
- loaderVars.syncExecStack,
-
- modules =
- loaderVars.modules,
-
- execQ =
- loaderVars.execQ,
-
- getModule =
- loaderVars.getModule,
-
- injectModule =
- loaderVars.injectModule,
-
- setArrived =
- loaderVars.setArrived,
-
- signal =
- loaderVars.signal,
-
- finishExec =
- loaderVars.finishExec,
-
- execModule =
- loaderVars.execModule,
-
- getLegacyMode =
- loaderVars.getLegacyMode,
-
- guardCheckComplete =
- loaderVars.guardCheckComplete;
-
- // there is exactly one dojoRequirePlugin among possibly-many dojo/_base/loader's (owing to mapping)
- dojoRequirePlugin = loaderVars.dojoRequirePlugin;
-
- dojo.provide = function(mid){
- var executingModule = syncExecStack[0],
- module = lang.mixin(getModule(slashName(mid), require.module), {
- executed:executing,
- result:lang.getObject(mid, true)
- });
- setArrived(module);
- if(executingModule){
- (executingModule.provides || (executingModule.provides = [])).push(function(){
- module.result = lang.getObject(mid);
- delete module.provides;
- module.executed!==executed && finishExec(module);
- });
- }// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
- return module.result;
- };
-
- has.add("config-publishRequireResult", 1, 0, 0);
-
- dojo.require = function(moduleName, omitModuleCheck) {
- // summary:
- // loads a Javascript module from the appropriate URI
- //
- // moduleName: String
- // module name to load, using periods for separators,
- // e.g. "dojo.date.locale". Module paths are de-referenced by dojo's
- // internal mapping of locations to names and are disambiguated by
- // longest prefix. See `dojo.registerModulePath()` for details on
- // registering new modules.
- //
- // omitModuleCheck: Boolean?
- // if `true`, omitModuleCheck skips the step of ensuring that the
- // loaded file actually defines the symbol it is referenced by.
- // For example if it called as `dojo.require("a.b.c")` and the
- // file located at `a/b/c.js` does not define an object `a.b.c`,
- // and exception will be throws whereas no exception is raised
- // when called as `dojo.require("a.b.c", true)`
- //
- // description:
- // Modules are loaded via dojo.require by using one of two loaders: the normal loader
- // and the xdomain loader. The xdomain loader is used when dojo was built with a
- // custom build that specified loader=xdomain and the module lives on a modulePath
- // that is a whole URL, with protocol and a domain. The versions of Dojo that are on
- // the Google and AOL CDNs use the xdomain loader.
- //
- // If the module is loaded via the xdomain loader, it is an asynchronous load, since
- // the module is added via a dynamically created script tag. This
- // means that dojo.require() can return before the module has loaded. However, this
- // should only happen in the case where you do dojo.require calls in the top-level
- // HTML page, or if you purposely avoid the loader checking for dojo.require
- // dependencies in your module by using a syntax like dojo["require"] to load the module.
- //
- // Sometimes it is useful to not have the loader detect the dojo.require calls in the
- // module so that you can dynamically load the modules as a result of an action on the
- // page, instead of right at module load time.
- //
- // Also, for script blocks in an HTML page, the loader does not pre-process them, so
- // it does not know to download the modules before the dojo.require calls occur.
- //
- // So, in those two cases, when you want on-the-fly module loading or for script blocks
- // in the HTML page, special care must be taken if the dojo.required code is loaded
- // asynchronously. To make sure you can execute code that depends on the dojo.required
- // modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
- // callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
- // executing.
- //
- // This type of syntax works with both xdomain and normal loaders, so it is good
- // practice to always use this idiom for on-the-fly code loading and in HTML script
- // blocks. If at some point you change loaders and where the code is loaded from,
- // it will all still work.
- //
- // More on how dojo.require
- // `dojo.require("A.B")` first checks to see if symbol A.B is
- // defined. If it is, it is simply returned (nothing to do).
- //
- // If it is not defined, it will look for `A/B.js` in the script root
- // directory.
- //
- // `dojo.require` throws an exception if it cannot find a file
- // to load, or if the symbol `A.B` is not defined after loading.
- //
- // It returns the object `A.B`, but note the caveats above about on-the-fly loading and
- // HTML script blocks when the xdomain loader is loading a module.
- //
- // `dojo.require()` does nothing about importing symbols into
- // the current namespace. It is presumed that the caller will
- // take care of that.
- //
- // example:
- // To use dojo.require in conjunction with dojo.ready:
- //
- // | dojo.require("foo");
- // | dojo.require("bar");
- // | dojo.addOnLoad(function(){
- // | //you can now safely do something with foo and bar
- // | });
- //
- // example:
- // For example, to import all symbols into a local block, you might write:
- //
- // | with (dojo.require("A.B")) {
- // | ...
- // | }
- //
- // And to import just the leaf symbol to a local variable:
- //
- // | var B = dojo.require("A.B");
- // | ...
- //
- // returns:
- // the required namespace object
- function doRequire(mid, omitModuleCheck){
- var module = getModule(slashName(mid), require.module);
- if(syncExecStack.length && syncExecStack[0].finish){
- // switched to async loading in the middle of evaluating a legacy module; stop
- // applying dojo.require so the remaining dojo.requires are applied in order
- syncExecStack[0].finish.push(mid);
- return undefined;
- }
-
- // recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
- if(module.executed){
- return module.result;
- }
- omitModuleCheck && (module.result = nonmodule);
-
- // rcg...why here and in two lines??
- var currentMode = getLegacyMode();
-
- // recall, in sync mode to inject is to *eval* the module text
- // if the module is a legacy module, this is the same as executing
- // but if the module is an AMD module, this means defining, not executing
- injectModule(module);
- // the inject may have changed the mode
- currentMode = getLegacyMode();
-
- // in sync mode to dojo.require is to execute
- if(module.executed!==executed && module.injected===arrived){
- // the module was already here before injectModule was called probably finishing up a xdomain
- // load, but maybe a module given to the loader directly rather than having the loader retrieve it
-
- loaderVars.guardCheckComplete(function(){
- execModule(module);
- });
- }
- if(module.executed){
- return module.result;
- }
-
- if(currentMode==sync){
- // the only way to get here is in sync mode and dojo.required a module that
- // * was loaded async in the injectModule application a few lines up
- // * was an AMD module that had deps that are being loaded async and therefore couldn't execute
- if(module.cjs){
- // the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
- execQ.unshift(module);
- }else{
- // the module was a legacy module
- syncExecStack.length && (syncExecStack[0].finish= [mid]);
- }
- }else{
- // the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
- // the module value synchronously; make sure it gets executed though
- execQ.push(module);
- }
-
- return undefined;
- }
-
- var result = doRequire(moduleName, omitModuleCheck);
- if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
- lang.setObject(moduleName, result);
- }
- return result;
- };
-
- dojo.loadInit = function(f) {
- f();
- };
-
- dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
- // summary:
- // Maps a module name to a path
- // description:
- // An unregistered module is given the default path of ../[module],
- // relative to Dojo root. For example, module acme is mapped to
- // ../acme. If you want to use a different module name, use
- // dojo.registerModulePath.
- // example:
- // If your dojo.js is located at this location in the web root:
- // | /myapp/js/dojo/dojo/dojo.js
- // and your modules are located at:
- // | /myapp/js/foo/bar.js
- // | /myapp/js/foo/baz.js
- // | /myapp/js/foo/thud/xyzzy.js
- // Your application can tell Dojo to locate the "foo" namespace by calling:
- // | dojo.registerModulePath("foo", "../../foo");
- // At which point you can then use dojo.require() to load the
- // modules (assuming they provide() the same things which are
- // required). The full code might be:
- // |
- // |
-
- var paths = {};
- paths[moduleName.replace(/\./g, "/")] = prefix;
- require({paths:paths});
- };
-
- dojo.platformRequire = function(/*Object*/modMap){
- // summary:
- // require one or more modules based on which host environment
- // Dojo is currently operating in
- // description:
- // This method takes a "map" of arrays which one can use to
- // optionally load dojo modules. The map is indexed by the
- // possible dojo.name_ values, with two additional values:
- // "default" and "common". The items in the "default" array will
- // be loaded if none of the other items have been chosen based on
- // dojo.name_, set by your host environment. The items in the
- // "common" array will *always* be loaded, regardless of which
- // list is chosen.
- // example:
- // | dojo.platformRequire({
- // | browser: [
- // | "foo.sample", // simple module
- // | "foo.test",
- // | ["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
- // | ],
- // | default: [ "foo.sample._base" ],
- // | common: [ "important.module.common" ]
- // | });
-
- var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
- temp;
- while(result.length){
- if(lang.isArray(temp = result.shift())){
- dojo.require.apply(dojo, temp);
- }else{
- dojo.require(temp);
- }
- }
- };
-
- dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
- // summary:
- // If the condition is true then call `dojo.require()` for the specified
- // resource
- //
- // example:
- // | dojo.requireIf(dojo.isBrowser, "my.special.Module");
-
- if(condition){
- dojo.require(moduleName, omitModuleCheck);
- }
- };
-
- dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
- require(["../i18n"], function(i18n){
- i18n.getLocalization(moduleName, bundleName, locale);
- });
- };
-
- return {
- // summary:
- // This module defines the v1.x synchronous loader API.
-
- extractLegacyApiApplications:extractLegacyApiApplications,
- require:dojoRequirePlugin,
- loadInit:dojoLoadInitPlugin
- };
-});
-
-},
-'dojo/json':function(){
-define(["./has"], function(has){
- "use strict";
- var hasJSON = typeof JSON != "undefined";
- has.add("json-parse", hasJSON); // all the parsers work fine
- // Firefox 3.5/Gecko 1.9 fails to use replacer in stringify properly https://bugzilla.mozilla.org/show_bug.cgi?id=509184
- has.add("json-stringify", hasJSON && JSON.stringify({a:0}, function(k,v){return v||1;}) == '{"a":1}');
-
- /*=====
- return {
- // summary:
- // Functions to parse and serialize JSON
-
- parse: function(str, strict){
- // summary:
- // Parses a [JSON](http://json.org) string to return a JavaScript object.
- // description:
- // This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
- // Throws for invalid JSON strings. This delegates to eval() if native JSON
- // support is not available. By default this will evaluate any valid JS expression.
- // With the strict parameter set to true, the parser will ensure that only
- // valid JSON strings are parsed (otherwise throwing an error). Without the strict
- // parameter, the content passed to this method must come
- // from a trusted source.
- // str:
- // a string literal of a JSON item, for instance:
- // `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
- // strict:
- // When set to true, this will ensure that only valid, secure JSON is ever parsed.
- // Make sure this is set to true for untrusted content. Note that on browsers/engines
- // without native JSON support, setting this to true will run slower.
- },
- stringify: function(value, replacer, spacer){
- // summary:
- // Returns a [JSON](http://json.org) serialization of an object.
- // description:
- // Returns a [JSON](http://json.org) serialization of an object.
- // This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
- // Note that this doesn't check for infinite recursion, so don't do that!
- // value:
- // A value to be serialized.
- // replacer:
- // A replacer function that is called for each value and can return a replacement
- // spacer:
- // A spacer string to be used for pretty printing of JSON
- // example:
- // simple serialization of a trivial object
- // | define(["dojo/json"], function(JSON){
- // | var jsonStr = JSON.stringify({ howdy: "stranger!", isStrange: true });
- // | doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
- }
- };
- =====*/
-
- if(has("json-stringify")){
- return JSON;
- }else{
- var escapeString = function(/*String*/str){
- // summary:
- // Adds escape sequences for non-visual characters, double quote and
- // backslash and surrounds with double quotes to form a valid string
- // literal.
- return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
- replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
- replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
- };
- return {
- parse: has("json-parse") ? JSON.parse : function(str, strict){
- if(strict && !/^([\s\[\{]*(?:"(?:\\.|[^"])*"|-?\d[\d\.]*(?:[Ee][+-]?\d+)?|null|true|false|)[\s\]\}]*(?:,|:|$))+$/.test(str)){
- throw new SyntaxError("Invalid characters in JSON");
- }
- return eval('(' + str + ')');
- },
- stringify: function(value, replacer, spacer){
- var undef;
- if(typeof replacer == "string"){
- spacer = replacer;
- replacer = null;
- }
- function stringify(it, indent, key){
- if(replacer){
- it = replacer(key, it);
- }
- var val, objtype = typeof it;
- if(objtype == "number"){
- return isFinite(it) ? it + "" : "null";
- }
- if(objtype == "boolean"){
- return it + "";
- }
- if(it === null){
- return "null";
- }
- if(typeof it == "string"){
- return escapeString(it);
- }
- if(objtype == "function" || objtype == "undefined"){
- return undef; // undefined
- }
- // short-circuit for objects that support "json" serialization
- // if they return "self" then just pass-through...
- if(typeof it.toJSON == "function"){
- return stringify(it.toJSON(key), indent, key);
- }
- if(it instanceof Date){
- return '"{FullYear}-{Month+}-{Date}T{Hours}:{Minutes}:{Seconds}Z"'.replace(/\{(\w+)(\+)?\}/g, function(t, prop, plus){
- var num = it["getUTC" + prop]() + (plus ? 1 : 0);
- return num < 10 ? "0" + num : num;
- });
- }
- if(it.valueOf() !== it){
- // primitive wrapper, try again unwrapped:
- return stringify(it.valueOf(), indent, key);
- }
- var nextIndent= spacer ? (indent + spacer) : "";
- /* we used to test for DOM nodes and throw, but FF serializes them as {}, so cross-browser consistency is probably not efficiently attainable */
-
- var sep = spacer ? " " : "";
- var newLine = spacer ? "\n" : "";
-
- // array
- if(it instanceof Array){
- var itl = it.length, res = [];
- for(key = 0; key < itl; key++){
- var obj = it[key];
- val = stringify(obj, nextIndent, key);
- if(typeof val != "string"){
- val = "null";
- }
- res.push(newLine + nextIndent + val);
- }
- return "[" + res.join(",") + newLine + indent + "]";
- }
- // generic object code path
- var output = [];
- for(key in it){
- var keyStr;
- if(it.hasOwnProperty(key)){
- if(typeof key == "number"){
- keyStr = '"' + key + '"';
- }else if(typeof key == "string"){
- keyStr = escapeString(key);
- }else{
- // skip non-string or number keys
- continue;
- }
- val = stringify(it[key], nextIndent, key);
- if(typeof val != "string"){
- // skip non-serializable values
- continue;
- }
- // At this point, the most non-IE browsers don't get in this branch
- // (they have native JSON), so push is definitely the way to
- output.push(newLine + nextIndent + keyStr + ":" + sep + val);
- }
- }
- return "{" + output.join(",") + newLine + indent + "}"; // String
- }
- return stringify(value, "", "");
- }
- };
- }
-});
-
-},
-'dojo/_base/declare':function(){
-define(["./kernel", "../has", "./lang"], function(dojo, has, lang){
- // module:
- // dojo/_base/declare
-
- var mix = lang.mixin, op = Object.prototype, opts = op.toString,
- xtor = new Function, counter = 0, cname = "constructor";
-
- function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
-
- // C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
- function c3mro(bases, className){
- var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
- l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
-
- // build a list of bases naming them if needed
- for(; i < l; ++i){
- base = bases[i];
- if(!base){
- err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
- }else if(opts.call(base) != "[object Function]"){
- err("mixin #" + i + " is not a callable constructor.", className);
- }
- lin = base._meta ? base._meta.bases : [base];
- top = 0;
- // add bases to the name map
- for(j = lin.length - 1; j >= 0; --j){
- proto = lin[j].prototype;
- if(!proto.hasOwnProperty("declaredClass")){
- proto.declaredClass = "uniqName_" + (counter++);
- }
- name = proto.declaredClass;
- if(!nameMap.hasOwnProperty(name)){
- nameMap[name] = {count: 0, refs: [], cls: lin[j]};
- ++clsCount;
- }
- rec = nameMap[name];
- if(top && top !== rec){
- rec.refs.push(top);
- ++top.count;
- }
- top = rec;
- }
- ++top.count;
- roots[0].refs.push(top);
- }
-
- // remove classes without external references recursively
- while(roots.length){
- top = roots.pop();
- result.push(top.cls);
- --clsCount;
- // optimization: follow a single-linked chain
- while(refs = top.refs, refs.length == 1){
- top = refs[0];
- if(!top || --top.count){
- // branch or end of chain => do not end to roots
- top = 0;
- break;
- }
- result.push(top.cls);
- --clsCount;
- }
- if(top){
- // branch
- for(i = 0, l = refs.length; i < l; ++i){
- top = refs[i];
- if(!--top.count){
- roots.push(top);
- }
- }
- }
- }
- if(clsCount){
- err("can't build consistent linearization", className);
- }
-
- // calculate the superclass offset
- base = bases[0];
- result[0] = base ?
- base._meta && base === result[result.length - base._meta.bases.length] ?
- base._meta.bases.length : 1 : 0;
-
- return result;
- }
-
- function inherited(args, a, f){
- var name, chains, bases, caller, meta, base, proto, opf, pos,
- cache = this._inherited = this._inherited || {};
-
- // crack arguments
- if(typeof args == "string"){
- name = args;
- args = a;
- a = f;
- }
- f = 0;
-
- caller = args.callee;
- name = name || caller.nom;
- if(!name){
- err("can't deduce a name to call inherited()", this.declaredClass);
- }
-
- meta = this.constructor._meta;
- bases = meta.bases;
-
- pos = cache.p;
- if(name != cname){
- // method
- if(cache.c !== caller){
- // cache bust
- pos = 0;
- base = bases[0];
- meta = base._meta;
- if(meta.hidden[name] !== caller){
- // error detection
- chains = meta.chains;
- if(chains && typeof chains[name] == "string"){
- err("calling chained method with inherited: " + name, this.declaredClass);
- }
- // find caller
- do{
- meta = base._meta;
- proto = base.prototype;
- if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
- break;
- }
- }while(base = bases[++pos]); // intentional assignment
- pos = base ? pos : -1;
- }
- }
- // find next
- base = bases[++pos];
- if(base){
- proto = base.prototype;
- if(base._meta && proto.hasOwnProperty(name)){
- f = proto[name];
- }else{
- opf = op[name];
- do{
- proto = base.prototype;
- f = proto[name];
- if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
- break;
- }
- }while(base = bases[++pos]); // intentional assignment
- }
- }
- f = base && f || op[name];
- }else{
- // constructor
- if(cache.c !== caller){
- // cache bust
- pos = 0;
- meta = bases[0]._meta;
- if(meta && meta.ctor !== caller){
- // error detection
- chains = meta.chains;
- if(!chains || chains.constructor !== "manual"){
- err("calling chained constructor with inherited", this.declaredClass);
- }
- // find caller
- while(base = bases[++pos]){ // intentional assignment
- meta = base._meta;
- if(meta && meta.ctor === caller){
- break;
- }
- }
- pos = base ? pos : -1;
- }
- }
- // find next
- while(base = bases[++pos]){ // intentional assignment
- meta = base._meta;
- f = meta ? meta.ctor : base;
- if(f){
- break;
- }
- }
- f = base && f;
- }
-
- // cache the found super method
- cache.c = f;
- cache.p = pos;
-
- // now we have the result
- if(f){
- return a === true ? f : f.apply(this, a || args);
- }
- // intentionally no return if a super method was not found
- }
-
- function getInherited(name, args){
- if(typeof name == "string"){
- return this.__inherited(name, args, true);
- }
- return this.__inherited(name, true);
- }
-
- function inherited__debug(args, a1, a2){
- var f = this.getInherited(args, a1);
- if(f){ return f.apply(this, a2 || a1 || args); }
- // intentionally no return if a super method was not found
- }
-
- var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited;
-
- // emulation of "instanceof"
- function isInstanceOf(cls){
- var bases = this.constructor._meta.bases;
- for(var i = 0, l = bases.length; i < l; ++i){
- if(bases[i] === cls){
- return true;
- }
- }
- return this instanceof cls;
- }
-
- function mixOwn(target, source){
- // add props adding metadata for incoming functions skipping a constructor
- for(var name in source){
- if(name != cname && source.hasOwnProperty(name)){
- target[name] = source[name];
- }
- }
- if(has("bug-for-in-skips-shadowed")){
- for(var extraNames= lang._extraNames, i= extraNames.length; i;){
- name = extraNames[--i];
- if(name != cname && source.hasOwnProperty(name)){
- target[name] = source[name];
- }
- }
- }
- }
-
- // implementation of safe mixin function
- function safeMixin(target, source){
- // summary:
- // Mix in properties skipping a constructor and decorating functions
- // like it is done by declare().
- // target: Object
- // Target object to accept new properties.
- // source: Object
- // Source object for new properties.
- // description:
- // This function is used to mix in properties like lang.mixin does,
- // but it skips a constructor property and decorates functions like
- // declare() does.
- //
- // It is meant to be used with classes and objects produced with
- // declare. Functions mixed in with dojo.safeMixin can use
- // this.inherited() like normal methods.
- //
- // This function is used to implement extend() method of a constructor
- // produced with declare().
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){
- // | console.log("A.m1");
- // | },
- // | m2: function(){
- // | console.log("A.m2");
- // | }
- // | });
- // | var B = declare(A, {
- // | m1: function(){
- // | this.inherited(arguments);
- // | console.log("B.m1");
- // | }
- // | });
- // | B.extend({
- // | m2: function(){
- // | this.inherited(arguments);
- // | console.log("B.m2");
- // | }
- // | });
- // | var x = new B();
- // | dojo.safeMixin(x, {
- // | m1: function(){
- // | this.inherited(arguments);
- // | console.log("X.m1");
- // | },
- // | m2: function(){
- // | this.inherited(arguments);
- // | console.log("X.m2");
- // | }
- // | });
- // | x.m2();
- // | // prints:
- // | // A.m1
- // | // B.m1
- // | // X.m1
-
- var name, t;
- // add props adding metadata for incoming functions skipping a constructor
- for(name in source){
- t = source[name];
- if((t !== op[name] || !(name in op)) && name != cname){
- if(opts.call(t) == "[object Function]"){
- // non-trivial function method => attach its name
- t.nom = name;
- }
- target[name] = t;
- }
- }
- if(has("bug-for-in-skips-shadowed")){
- for(var extraNames= lang._extraNames, i= extraNames.length; i;){
- name = extraNames[--i];
- t = source[name];
- if((t !== op[name] || !(name in op)) && name != cname){
- if(opts.call(t) == "[object Function]"){
- // non-trivial function method => attach its name
- t.nom = name;
- }
- target[name] = t;
- }
- }
- }
- return target;
- }
-
- function extend(source){
- declare.safeMixin(this.prototype, source);
- return this;
- }
-
- function createSubclass(mixins, props){
- // crack parameters
- if(!(mixins instanceof Array || typeof mixins == 'function')){
- props = mixins;
- mixins = undefined;
- }
-
- props = props || {};
- mixins = mixins || [];
-
- return declare([this].concat(mixins), props);
- }
-
- // chained constructor compatible with the legacy declare()
- function chainedConstructor(bases, ctorSpecial){
- return function(){
- var a = arguments, args = a, a0 = a[0], f, i, m,
- l = bases.length, preArgs;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) call two types of the preamble
- if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
- // full blown ritual
- preArgs = new Array(bases.length);
- // prepare parameters
- preArgs[0] = a;
- for(i = 0;;){
- // process the preamble of the 1st argument
- a0 = a[0];
- if(a0){
- f = a0.preamble;
- if(f){
- a = f.apply(this, a) || a;
- }
- }
- // process the preamble of this class
- f = bases[i].prototype;
- f = f.hasOwnProperty("preamble") && f.preamble;
- if(f){
- a = f.apply(this, a) || a;
- }
- // one peculiarity of the preamble:
- // it is called if it is not needed,
- // e.g., there is no constructor to call
- // let's watch for the last constructor
- // (see ticket #9795)
- if(++i == l){
- break;
- }
- preArgs[i] = a;
- }
- }
- // 2) call all non-trivial constructors using prepared arguments
- for(i = l - 1; i >= 0; --i){
- f = bases[i];
- m = f._meta;
- f = m ? m.ctor : f;
- if(f){
- f.apply(this, preArgs ? preArgs[i] : a);
- }
- }
- // 3) continue the original ritual: call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, args);
- }
- };
- }
-
-
- // chained constructor compatible with the legacy declare()
- function singleConstructor(ctor, ctorSpecial){
- return function(){
- var a = arguments, t = a, a0 = a[0], f;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) call two types of the preamble
- if(ctorSpecial){
- // full blown ritual
- if(a0){
- // process the preamble of the 1st argument
- f = a0.preamble;
- if(f){
- t = f.apply(this, t) || t;
- }
- }
- f = this.preamble;
- if(f){
- // process the preamble of this class
- f.apply(this, t);
- // one peculiarity of the preamble:
- // it is called even if it is not needed,
- // e.g., there is no constructor to call
- // let's watch for the last constructor
- // (see ticket #9795)
- }
- }
- // 2) call a constructor
- if(ctor){
- ctor.apply(this, a);
- }
- // 3) continue the original ritual: call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, a);
- }
- };
- }
-
- // plain vanilla constructor (can use inherited() to call its base constructor)
- function simpleConstructor(bases){
- return function(){
- var a = arguments, i = 0, f, m;
-
- if(!(this instanceof a.callee)){
- // not called via new, so force it
- return applyNew(a);
- }
-
- //this._inherited = {};
- // perform the shaman's rituals of the original declare()
- // 1) do not call the preamble
- // 2) call the top constructor (it can use this.inherited())
- for(; f = bases[i]; ++i){ // intentional assignment
- m = f._meta;
- f = m ? m.ctor : f;
- if(f){
- f.apply(this, a);
- break;
- }
- }
- // 3) call the postscript
- f = this.postscript;
- if(f){
- f.apply(this, a);
- }
- };
- }
-
- function chain(name, bases, reversed){
- return function(){
- var b, m, f, i = 0, step = 1;
- if(reversed){
- i = bases.length - 1;
- step = -1;
- }
- for(; b = bases[i]; i += step){ // intentional assignment
- m = b._meta;
- f = (m ? m.hidden : b.prototype)[name];
- if(f){
- f.apply(this, arguments);
- }
- }
- };
- }
-
- // forceNew(ctor)
- // return a new object that inherits from ctor.prototype but
- // without actually running ctor on the object.
- function forceNew(ctor){
- // create object with correct prototype using a do-nothing
- // constructor
- xtor.prototype = ctor.prototype;
- var t = new xtor;
- xtor.prototype = null; // clean up
- return t;
- }
-
- // applyNew(args)
- // just like 'new ctor()' except that the constructor and its arguments come
- // from args, which must be an array or an arguments object
- function applyNew(args){
- // create an object with ctor's prototype but without
- // calling ctor on it.
- var ctor = args.callee, t = forceNew(ctor);
- // execute the real constructor on the new object
- ctor.apply(t, args);
- return t;
- }
-
- function declare(className, superclass, props){
- // summary:
- // Create a feature-rich constructor from compact notation.
- // className: String?
- // The optional name of the constructor (loosely, a "class")
- // stored in the "declaredClass" property in the created prototype.
- // It will be used as a global name for a created constructor.
- // superclass: Function|Function[]
- // May be null, a Function, or an Array of Functions. This argument
- // specifies a list of bases (the left-most one is the most deepest
- // base).
- // props: Object
- // An object whose properties are copied to the created prototype.
- // Add an instance-initialization function by making it a property
- // named "constructor".
- // returns: dojo/_base/declare.__DeclareCreatedObject
- // New constructor function.
- // description:
- // Create a constructor using a compact notation for inheritance and
- // prototype extension.
- //
- // Mixin ancestors provide a type of multiple inheritance.
- // Prototypes of mixin ancestors are copied to the new class:
- // changes to mixin prototypes will not affect classes to which
- // they have been mixed in.
- //
- // Ancestors can be compound classes created by this version of
- // declare(). In complex cases all base classes are going to be
- // linearized according to C3 MRO algorithm
- // (see http://www.python.org/download/releases/2.3/mro/ for more
- // details).
- //
- // "className" is cached in "declaredClass" property of the new class,
- // if it was supplied. The immediate super class will be cached in
- // "superclass" property of the new class.
- //
- // Methods in "props" will be copied and modified: "nom" property
- // (the declared name of the method) will be added to all copied
- // functions to help identify them for the internal machinery. Be
- // very careful, while reusing methods: if you use the same
- // function under different names, it can produce errors in some
- // cases.
- //
- // It is possible to use constructors created "manually" (without
- // declare()) as bases. They will be called as usual during the
- // creation of an instance, their methods will be chained, and even
- // called by "this.inherited()".
- //
- // Special property "-chains-" governs how to chain methods. It is
- // a dictionary, which uses method names as keys, and hint strings
- // as values. If a hint string is "after", this method will be
- // called after methods of its base classes. If a hint string is
- // "before", this method will be called before methods of its base
- // classes.
- //
- // If "constructor" is not mentioned in "-chains-" property, it will
- // be chained using the legacy mode: using "after" chaining,
- // calling preamble() method before each constructor, if available,
- // and calling postscript() after all constructors were executed.
- // If the hint is "after", it is chained as a regular method, but
- // postscript() will be called after the chain of constructors.
- // "constructor" cannot be chained "before", but it allows
- // a special hint string: "manual", which means that constructors
- // are not going to be chained in any way, and programmer will call
- // them manually using this.inherited(). In the latter case
- // postscript() will be called after the construction.
- //
- // All chaining hints are "inherited" from base classes and
- // potentially can be overridden. Be very careful when overriding
- // hints! Make sure that all chained methods can work in a proposed
- // manner of chaining.
- //
- // Once a method was chained, it is impossible to unchain it. The
- // only exception is "constructor". You don't need to define a
- // method in order to supply a chaining hint.
- //
- // If a method is chained, it cannot use this.inherited() because
- // all other methods in the hierarchy will be called automatically.
- //
- // Usually constructors and initializers of any kind are chained
- // using "after" and destructors of any kind are chained as
- // "before". Note that chaining assumes that chained methods do not
- // return any value: any returned value will be discarded.
- //
- // example:
- // | declare("my.classes.bar", my.classes.foo, {
- // | // properties to be added to the class prototype
- // | someValue: 2,
- // | // initialization function
- // | constructor: function(){
- // | this.myComplicatedObject = new ReallyComplicatedObject();
- // | },
- // | // other functions
- // | someMethod: function(){
- // | doStuff();
- // | }
- // | });
- //
- // example:
- // | var MyBase = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyClass1 = declare(MyBase, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyClass2 = declare(MyBase, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var MyDiamond = declare([MyClass1, MyClass2], {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- //
- // example:
- // | var F = function(){ console.log("raw constructor"); };
- // | F.prototype.method = function(){
- // | console.log("raw method");
- // | };
- // | var A = declare(F, {
- // | constructor: function(){
- // | console.log("A.constructor");
- // | },
- // | method: function(){
- // | console.log("before calling F.method...");
- // | this.inherited(arguments);
- // | console.log("...back in A");
- // | }
- // | });
- // | new A().method();
- // | // will print:
- // | // raw constructor
- // | // A.constructor
- // | // before calling F.method...
- // | // raw method
- // | // ...back in A
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | destroy: "before"
- // | }
- // | });
- // | var B = declare(A, {
- // | constructor: function(){
- // | console.log("B.constructor");
- // | },
- // | destroy: function(){
- // | console.log("B.destroy");
- // | }
- // | });
- // | var C = declare(B, {
- // | constructor: function(){
- // | console.log("C.constructor");
- // | },
- // | destroy: function(){
- // | console.log("C.destroy");
- // | }
- // | });
- // | new C().destroy();
- // | // prints:
- // | // B.constructor
- // | // C.constructor
- // | // C.destroy
- // | // B.destroy
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | constructor: "manual"
- // | }
- // | });
- // | var B = declare(A, {
- // | constructor: function(){
- // | // ...
- // | // call the base constructor with new parameters
- // | this.inherited(arguments, [1, 2, 3]);
- // | // ...
- // | }
- // | });
- //
- // example:
- // | var A = declare(null, {
- // | "-chains-": {
- // | m1: "before"
- // | },
- // | m1: function(){
- // | console.log("A.m1");
- // | },
- // | m2: function(){
- // | console.log("A.m2");
- // | }
- // | });
- // | var B = declare(A, {
- // | "-chains-": {
- // | m2: "after"
- // | },
- // | m1: function(){
- // | console.log("B.m1");
- // | },
- // | m2: function(){
- // | console.log("B.m2");
- // | }
- // | });
- // | var x = new B();
- // | x.m1();
- // | // prints:
- // | // B.m1
- // | // A.m1
- // | x.m2();
- // | // prints:
- // | // A.m2
- // | // B.m2
-
- // crack parameters
- if(typeof className != "string"){
- props = superclass;
- superclass = className;
- className = "";
- }
- props = props || {};
-
- var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
-
- // build a prototype
- if(opts.call(superclass) == "[object Array]"){
- // C3 MRO
- bases = c3mro(superclass, className);
- t = bases[0];
- mixins = bases.length - t;
- superclass = bases[mixins];
- }else{
- bases = [0];
- if(superclass){
- if(opts.call(superclass) == "[object Function]"){
- t = superclass._meta;
- bases = bases.concat(t ? t.bases : superclass);
- }else{
- err("base class is not a callable constructor.", className);
- }
- }else if(superclass !== null){
- err("unknown base class. Did you use dojo.require to pull it in?", className);
- }
- }
- if(superclass){
- for(i = mixins - 1;; --i){
- proto = forceNew(superclass);
- if(!i){
- // stop if nothing to add (the last base)
- break;
- }
- // mix in properties
- t = bases[i];
- (t._meta ? mixOwn : mix)(proto, t.prototype);
- // chain in new constructor
- ctor = new Function;
- ctor.superclass = superclass;
- ctor.prototype = proto;
- superclass = proto.constructor = ctor;
- }
- }else{
- proto = {};
- }
- // add all properties
- declare.safeMixin(proto, props);
- // add constructor
- t = props.constructor;
- if(t !== op.constructor){
- t.nom = cname;
- proto.constructor = t;
- }
-
- // collect chains and flags
- for(i = mixins - 1; i; --i){ // intentional assignment
- t = bases[i]._meta;
- if(t && t.chains){
- chains = mix(chains || {}, t.chains);
- }
- }
- if(proto["-chains-"]){
- chains = mix(chains || {}, proto["-chains-"]);
- }
-
- // build ctor
- t = !chains || !chains.hasOwnProperty(cname);
- bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
- (bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
-
- // add meta information to the constructor
- ctor._meta = {bases: bases, hidden: props, chains: chains,
- parents: parents, ctor: props.constructor};
- ctor.superclass = superclass && superclass.prototype;
- ctor.extend = extend;
- ctor.createSubclass = createSubclass;
- ctor.prototype = proto;
- proto.constructor = ctor;
-
- // add "standard" methods to the prototype
- proto.getInherited = getInherited;
- proto.isInstanceOf = isInstanceOf;
- proto.inherited = inheritedImpl;
- proto.__inherited = inherited;
-
- // add name if specified
- if(className){
- proto.declaredClass = className;
- lang.setObject(className, ctor);
- }
-
- // build chains and add them to the prototype
- if(chains){
- for(name in chains){
- if(proto[name] && typeof chains[name] == "string" && name != cname){
- t = proto[name] = chain(name, bases, chains[name] === "after");
- t.nom = name;
- }
- }
- }
- // chained methods do not return values
- // no need to chain "invisible" functions
-
- return ctor; // Function
- }
-
- /*=====
- declare.__DeclareCreatedObject = {
- // summary:
- // dojo/_base/declare() returns a constructor `C`. `new C()` returns an Object with the following
- // methods, in addition to the methods and properties specified via the arguments passed to declare().
-
- inherited: function(name, args, newArgs){
- // summary:
- // Calls a super method.
- // name: String?
- // The optional method name. Should be the same as the caller's
- // name. Usually "name" is specified in complex dynamic cases, when
- // the calling method was dynamically added, undecorated by
- // declare(), and it cannot be determined.
- // args: Arguments
- // The caller supply this argument, which should be the original
- // "arguments".
- // newArgs: Object?
- // If "true", the found function will be returned without
- // executing it.
- // If Array, it will be used to call a super method. Otherwise
- // "args" will be used.
- // returns:
- // Whatever is returned by a super method, or a super method itself,
- // if "true" was specified as newArgs.
- // description:
- // This method is used inside method of classes produced with
- // declare() to call a super method (next in the chain). It is
- // used for manually controlled chaining. Consider using the regular
- // chaining, because it is faster. Use "this.inherited()" only in
- // complex cases.
- //
- // This method cannot me called from automatically chained
- // constructors including the case of a special (legacy)
- // constructor chaining. It cannot be called from chained methods.
- //
- // If "this.inherited()" cannot find the next-in-chain method, it
- // does nothing and returns "undefined". The last method in chain
- // can be a default method implemented in Object, which will be
- // called last.
- //
- // If "name" is specified, it is assumed that the method that
- // received "args" is the parent method for this call. It is looked
- // up in the chain list and if it is found the next-in-chain method
- // is called. If it is not found, the first-in-chain method is
- // called.
- //
- // If "name" is not specified, it will be derived from the calling
- // method (using a methoid property "nom").
- //
- // example:
- // | var B = declare(A, {
- // | method1: function(a, b, c){
- // | this.inherited(arguments);
- // | },
- // | method2: function(a, b){
- // | return this.inherited(arguments, [a + b]);
- // | }
- // | });
- // | // next method is not in the chain list because it is added
- // | // manually after the class was created.
- // | B.prototype.method3 = function(){
- // | console.log("This is a dynamically-added method.");
- // | this.inherited("method3", arguments);
- // | };
- // example:
- // | var B = declare(A, {
- // | method: function(a, b){
- // | var super = this.inherited(arguments, true);
- // | // ...
- // | if(!super){
- // | console.log("there is no super method");
- // | return 0;
- // | }
- // | return super.apply(this, arguments);
- // | }
- // | });
- return {}; // Object
- },
-
- getInherited: function(name, args){
- // summary:
- // Returns a super method.
- // name: String?
- // The optional method name. Should be the same as the caller's
- // name. Usually "name" is specified in complex dynamic cases, when
- // the calling method was dynamically added, undecorated by
- // declare(), and it cannot be determined.
- // args: Arguments
- // The caller supply this argument, which should be the original
- // "arguments".
- // returns:
- // Returns a super method (Function) or "undefined".
- // description:
- // This method is a convenience method for "this.inherited()".
- // It uses the same algorithm but instead of executing a super
- // method, it returns it, or "undefined" if not found.
- //
- // example:
- // | var B = declare(A, {
- // | method: function(a, b){
- // | var super = this.getInherited(arguments);
- // | // ...
- // | if(!super){
- // | console.log("there is no super method");
- // | return 0;
- // | }
- // | return super.apply(this, arguments);
- // | }
- // | });
- return {}; // Object
- },
-
- isInstanceOf: function(cls){
- // summary:
- // Checks the inheritance chain to see if it is inherited from this
- // class.
- // cls: Function
- // Class constructor.
- // returns:
- // "true", if this object is inherited from this class, "false"
- // otherwise.
- // description:
- // This method is used with instances of classes produced with
- // declare() to determine of they support a certain interface or
- // not. It models "instanceof" operator.
- //
- // example:
- // | var A = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var B = declare(null, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var C = declare([A, B], {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // | var D = declare(A, {
- // | // constructor, properties, and methods go here
- // | // ...
- // | });
- // |
- // | var a = new A(), b = new B(), c = new C(), d = new D();
- // |
- // | console.log(a.isInstanceOf(A)); // true
- // | console.log(b.isInstanceOf(A)); // false
- // | console.log(c.isInstanceOf(A)); // true
- // | console.log(d.isInstanceOf(A)); // true
- // |
- // | console.log(a.isInstanceOf(B)); // false
- // | console.log(b.isInstanceOf(B)); // true
- // | console.log(c.isInstanceOf(B)); // true
- // | console.log(d.isInstanceOf(B)); // false
- // |
- // | console.log(a.isInstanceOf(C)); // false
- // | console.log(b.isInstanceOf(C)); // false
- // | console.log(c.isInstanceOf(C)); // true
- // | console.log(d.isInstanceOf(C)); // false
- // |
- // | console.log(a.isInstanceOf(D)); // false
- // | console.log(b.isInstanceOf(D)); // false
- // | console.log(c.isInstanceOf(D)); // false
- // | console.log(d.isInstanceOf(D)); // true
- return {}; // Object
- },
-
- extend: function(source){
- // summary:
- // Adds all properties and methods of source to constructor's
- // prototype, making them available to all instances created with
- // constructor. This method is specific to constructors created with
- // declare().
- // source: Object
- // Source object which properties are going to be copied to the
- // constructor's prototype.
- // description:
- // Adds source properties to the constructor's prototype. It can
- // override existing properties.
- //
- // This method is similar to dojo.extend function, but it is specific
- // to constructors produced by declare(). It is implemented
- // using dojo.safeMixin, and it skips a constructor property,
- // and properly decorates copied functions.
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){},
- // | s1: "Popokatepetl"
- // | });
- // | A.extend({
- // | m1: function(){},
- // | m2: function(){},
- // | f1: true,
- // | d1: 42
- // | });
- },
-
- createSubclass: function(mixins, props){
- // summary:
- // Create a subclass of the declared class from a list of base classes.
- // mixins: Function[]
- // Specifies a list of bases (the left-most one is the most deepest
- // base).
- // props: Object?
- // An optional object whose properties are copied to the created prototype.
- // returns: dojo/_base/declare.__DeclareCreatedObject
- // New constructor function.
- // description:
- // Create a constructor using a compact notation for inheritance and
- // prototype extension.
- //
- // Mixin ancestors provide a type of multiple inheritance.
- // Prototypes of mixin ancestors are copied to the new class:
- // changes to mixin prototypes will not affect classes to which
- // they have been mixed in.
- //
- // example:
- // | var A = declare(null, {
- // | m1: function(){},
- // | s1: "bar"
- // | });
- // | var B = declare(null, {
- // | m2: function(){},
- // | s2: "foo"
- // | });
- // | var C = declare(null, {
- // | });
- // | var D1 = A.createSubclass([B, C], {
- // | m1: function(){},
- // | d1: 42
- // | });
- // | var d1 = new D1();
- // |
- // | // this is equivalent to:
- // | var D2 = declare([A, B, C], {
- // | m1: function(){},
- // | d1: 42
- // | });
- // | var d2 = new D2();
- }
- };
- =====*/
-
- // For back-compat, remove for 2.0
- dojo.safeMixin = declare.safeMixin = safeMixin;
- dojo.declare = declare;
-
- return declare;
-});
-
-},
-'dojo/dom':function(){
-define(["./sniff", "./_base/window"],
- function(has, win){
- // module:
- // dojo/dom
-
- // FIXME: need to add unit tests for all the semi-public methods
-
- if(has("ie") <= 7){
- try{
- document.execCommand("BackgroundImageCache", false, true);
- }catch(e){
- // sane browsers don't have cache "issues"
- }
- }
-
- // =============================
- // DOM Functions
- // =============================
-
- // the result object
- var dom = {
- // summary:
- // This module defines the core dojo DOM API.
- };
-
- if(has("ie")){
- dom.byId = function(id, doc){
- if(typeof id != "string"){
- return id;
- }
- var _d = doc || win.doc, te = id && _d.getElementById(id);
- // attributes.id.value is better than just id in case the
- // user has a name=id inside a form
- if(te && (te.attributes.id.value == id || te.id == id)){
- return te;
- }else{
- var eles = _d.all[id];
- if(!eles || eles.nodeName){
- eles = [eles];
- }
- // if more than 1, choose first with the correct id
- var i = 0;
- while((te = eles[i++])){
- if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
- return te;
- }
- }
- }
- };
- }else{
- dom.byId = function(id, doc){
- // inline'd type check.
- // be sure to return null per documentation, to match IE branch.
- return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
- };
- }
- /*=====
- dom.byId = function(id, doc){
- // summary:
- // Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined)
- // if not found. If `id` is a DomNode, this function is a no-op.
- //
- // id: String|DOMNode
- // A string to match an HTML id attribute or a reference to a DOM Node
- //
- // doc: Document?
- // Document to work in. Defaults to the current value of
- // dojo/_base/window.doc. Can be used to retrieve
- // node references from other documents.
- //
- // example:
- // Look up a node by ID:
- // | require(["dojo/dom"], function(dom){
- // | var n = dom.byId("foo");
- // | });
- //
- // example:
- // Check if a node exists, and use it.
- // | require(["dojo/dom"], function(dom){
- // | var n = dom.byId("bar");
- // | if(n){ doStuff() ... }
- // | });
- //
- // example:
- // Allow string or DomNode references to be passed to a custom function:
- // | require(["dojo/dom"], function(dom){
- // | var foo = function(nodeOrId){
- // | nodeOrId = dom.byId(nodeOrId);
- // | // ... more stuff
- // | }
- // | });
- };
- =====*/
-
- dom.isDescendant = function(/*DOMNode|String*/ node, /*DOMNode|String*/ ancestor){
- // summary:
- // Returns true if node is a descendant of ancestor
- // node: DOMNode|String
- // string id or node reference to test
- // ancestor: DOMNode|String
- // string id or node reference of potential parent to test against
- //
- // example:
- // Test is node id="bar" is a descendant of node id="foo"
- // | require(["dojo/dom"], function(dom){
- // | if(dom.isDescendant("bar", "foo")){ ... }
- // | });
-
- try{
- node = dom.byId(node);
- ancestor = dom.byId(ancestor);
- while(node){
- if(node == ancestor){
- return true; // Boolean
- }
- node = node.parentNode;
- }
- }catch(e){ /* squelch, return false */ }
- return false; // Boolean
- };
-
-
- // TODO: do we need setSelectable in the base?
-
- // Add feature test for user-select CSS property
- // (currently known to work in all but IE < 10 and Opera)
- // TODO: The user-select CSS property as of May 2014 is no longer part of
- // any CSS specification. In IE, -ms-user-select does not do the same thing
- // as the unselectable attribute on elements; namely, dijit Editor buttons
- // do not properly prevent the content of the editable content frame from
- // unblurring. As a result, the -ms- prefixed version is omitted here.
- has.add("css-user-select", function(global, doc, element){
- // Avoid exception when dom.js is loaded in non-browser environments
- if(!element){ return false; }
-
- var style = element.style;
- var prefixes = ["Khtml", "O", "Moz", "Webkit"],
- i = prefixes.length,
- name = "userSelect",
- prefix;
-
- // Iterate prefixes from most to least likely
- do{
- if(typeof style[name] !== "undefined"){
- // Supported; return property name
- return name;
- }
- }while(i-- && (name = prefixes[i] + "UserSelect"));
-
- // Not supported if we didn't return before now
- return false;
- });
-
- /*=====
- dom.setSelectable = function(node, selectable){
- // summary:
- // Enable or disable selection on a node
- // node: DOMNode|String
- // id or reference to node
- // selectable: Boolean
- // state to put the node in. false indicates unselectable, true
- // allows selection.
- // example:
- // Make the node id="bar" unselectable
- // | require(["dojo/dom"], function(dom){
- // | dom.setSelectable("bar");
- // | });
- // example:
- // Make the node id="bar" selectable
- // | require(["dojo/dom"], function(dom){
- // | dom.setSelectable("bar", true);
- // | });
- };
- =====*/
-
- var cssUserSelect = has("css-user-select");
- dom.setSelectable = cssUserSelect ? function(node, selectable){
- // css-user-select returns a (possibly vendor-prefixed) CSS property name
- dom.byId(node).style[cssUserSelect] = selectable ? "" : "none";
- } : function(node, selectable){
- node = dom.byId(node);
-
- // (IE < 10 / Opera) Fall back to setting/removing the
- // unselectable attribute on the element and all its children
- var nodes = node.getElementsByTagName("*"),
- i = nodes.length;
-
- if(selectable){
- node.removeAttribute("unselectable");
- while(i--){
- nodes[i].removeAttribute("unselectable");
- }
- }else{
- node.setAttribute("unselectable", "on");
- while(i--){
- nodes[i].setAttribute("unselectable", "on");
- }
- }
- };
-
- return dom;
-});
-
-},
-'dojo/_base/browser':function(){
-if(require.has){
- require.has.add("config-selectorEngine", "acme");
-}
-define([
- "../ready",
- "./kernel",
- "./connect", // until we decide if connect is going back into non-browser environments
- "./unload",
- "./window",
- "./event",
- "./html",
- "./NodeList",
- "../query",
- "./xhr",
- "./fx"], function(dojo){
-
- // module:
- // dojo/_base/browser
-
- /*=====
- return {
- // summary:
- // This module causes the browser-only base modules to be loaded.
- };
- =====*/
-
- return dojo;
-});
-
-},
-'dojo/selector/acme':function(){
-define([
- "../dom", "../sniff", "../_base/array", "../_base/lang", "../_base/window"
-], function(dom, has, array, lang, win){
-
- // module:
- // dojo/selector/acme
-
-/*
- acme architectural overview:
-
- acme is a relatively full-featured CSS3 query library. It is
- designed to take any valid CSS3 selector and return the nodes matching
- the selector. To do this quickly, it processes queries in several
- steps, applying caching where profitable.
-
- The steps (roughly in reverse order of the way they appear in the code):
- 1.) check to see if we already have a "query dispatcher"
- - if so, use that with the given parameterization. Skip to step 4.
- 2.) attempt to determine which branch to dispatch the query to:
- - JS (optimized DOM iteration)
- - native (FF3.1+, Safari 3.1+, IE 8+)
- 3.) tokenize and convert to executable "query dispatcher"
- - this is where the lion's share of the complexity in the
- system lies. In the DOM version, the query dispatcher is
- assembled as a chain of "yes/no" test functions pertaining to
- a section of a simple query statement (".blah:nth-child(odd)"
- but not "div div", which is 2 simple statements). Individual
- statement dispatchers are cached (to prevent re-definition)
- as are entire dispatch chains (to make re-execution of the
- same query fast)
- 4.) the resulting query dispatcher is called in the passed scope
- (by default the top-level document)
- - for DOM queries, this results in a recursive, top-down
- evaluation of nodes based on each simple query section
- - for native implementations, this may mean working around spec
- bugs. So be it.
- 5.) matched nodes are pruned to ensure they are unique (if necessary)
-*/
-
-
- ////////////////////////////////////////////////////////////////////////
- // Toolkit aliases
- ////////////////////////////////////////////////////////////////////////
-
- // if you are extracting acme for use in your own system, you will
- // need to provide these methods and properties. No other porting should be
- // necessary, save for configuring the system to use a class other than
- // dojo/NodeList as the return instance instantiator
- var trim = lang.trim;
- var each = array.forEach;
-
- var getDoc = function(){ return win.doc; };
- // NOTE(alex): the spec is idiotic. CSS queries should ALWAYS be case-sensitive, but nooooooo
- var cssCaseBug = (getDoc().compatMode) == "BackCompat";
-
- ////////////////////////////////////////////////////////////////////////
- // Global utilities
- ////////////////////////////////////////////////////////////////////////
-
-
- var specials = ">~+";
-
- // global thunk to determine whether we should treat the current query as
- // case sensitive or not. This switch is flipped by the query evaluator
- // based on the document passed as the context to search.
- var caseSensitive = false;
-
- // how high?
- var yesman = function(){ return true; };
-
- ////////////////////////////////////////////////////////////////////////
- // Tokenizer
- ////////////////////////////////////////////////////////////////////////
-
- var getQueryParts = function(query){
- // summary:
- // state machine for query tokenization
- // description:
- // instead of using a brittle and slow regex-based CSS parser,
- // acme implements an AST-style query representation. This
- // representation is only generated once per query. For example,
- // the same query run multiple times or under different root nodes
- // does not re-parse the selector expression but instead uses the
- // cached data structure. The state machine implemented here
- // terminates on the last " " (space) character and returns an
- // ordered array of query component structures (or "parts"). Each
- // part represents an operator or a simple CSS filtering
- // expression. The structure for parts is documented in the code
- // below.
-
-
- // NOTE:
- // this code is designed to run fast and compress well. Sacrifices
- // to readability and maintainability have been made. Your best
- // bet when hacking the tokenizer is to put The Donnas on *really*
- // loud (may we recommend their "Spend The Night" release?) and
- // just assume you're gonna make mistakes. Keep the unit tests
- // open and run them frequently. Knowing is half the battle ;-)
- if(specials.indexOf(query.slice(-1)) >= 0){
- // if we end with a ">", "+", or "~", that means we're implicitly
- // searching all children, so make it explicit
- query += " * ";
- }else{
- // if you have not provided a terminator, one will be provided for
- // you...
- query += " ";
- }
-
- var ts = function(/*Integer*/ s, /*Integer*/ e){
- // trim and slice.
-
- // take an index to start a string slice from and an end position
- // and return a trimmed copy of that sub-string
- return trim(query.slice(s, e));
- };
-
- // the overall data graph of the full query, as represented by queryPart objects
- var queryParts = [];
-
-
- // state keeping vars
- var inBrackets = -1, inParens = -1, inMatchFor = -1,
- inPseudo = -1, inClass = -1, inId = -1, inTag = -1, currentQuoteChar,
- lc = "", cc = "", pStart;
-
- // iteration vars
- var x = 0, // index in the query
- ql = query.length,
- currentPart = null, // data structure representing the entire clause
- _cp = null; // the current pseudo or attr matcher
-
- // several temporary variables are assigned to this structure during a
- // potential sub-expression match:
- // attr:
- // a string representing the current full attribute match in a
- // bracket expression
- // type:
- // if there's an operator in a bracket expression, this is
- // used to keep track of it
- // value:
- // the internals of parenthetical expression for a pseudo. for
- // :nth-child(2n+1), value might be "2n+1"
-
- var endTag = function(){
- // called when the tokenizer hits the end of a particular tag name.
- // Re-sets state variables for tag matching and sets up the matcher
- // to handle the next type of token (tag or operator).
- if(inTag >= 0){
- var tv = (inTag == x) ? null : ts(inTag, x); // .toLowerCase();
- currentPart[ (specials.indexOf(tv) < 0) ? "tag" : "oper" ] = tv;
- inTag = -1;
- }
- };
-
- var endId = function(){
- // called when the tokenizer might be at the end of an ID portion of a match
- if(inId >= 0){
- currentPart.id = ts(inId, x).replace(/\\/g, "");
- inId = -1;
- }
- };
-
- var endClass = function(){
- // called when the tokenizer might be at the end of a class name
- // match. CSS allows for multiple classes, so we augment the
- // current item with another class in its list
- if(inClass >= 0){
- currentPart.classes.push(ts(inClass + 1, x).replace(/\\/g, ""));
- inClass = -1;
- }
- };
-
- var endAll = function(){
- // at the end of a simple fragment, so wall off the matches
- endId();
- endTag();
- endClass();
- };
-
- var endPart = function(){
- endAll();
- if(inPseudo >= 0){
- currentPart.pseudos.push({ name: ts(inPseudo + 1, x) });
- }
- // hint to the selector engine to tell it whether or not it
- // needs to do any iteration. Many simple selectors don't, and
- // we can avoid significant construction-time work by advising
- // the system to skip them
- currentPart.loops = (
- currentPart.pseudos.length ||
- currentPart.attrs.length ||
- currentPart.classes.length );
-
- currentPart.oquery = currentPart.query = ts(pStart, x); // save the full expression as a string
-
-
- // otag/tag are hints to suggest to the system whether or not
- // it's an operator or a tag. We save a copy of otag since the
- // tag name is cast to upper-case in regular HTML matches. The
- // system has a global switch to figure out if the current
- // expression needs to be case sensitive or not and it will use
- // otag or tag accordingly
- currentPart.otag = currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*");
-
- if(currentPart.tag){
- // if we're in a case-insensitive HTML doc, we likely want
- // the toUpperCase when matching on element.tagName. If we
- // do it here, we can skip the string op per node
- // comparison
- currentPart.tag = currentPart.tag.toUpperCase();
- }
-
- // add the part to the list
- if(queryParts.length && (queryParts[queryParts.length-1].oper)){
- // operators are always infix, so we remove them from the
- // list and attach them to the next match. The evaluator is
- // responsible for sorting out how to handle them.
- currentPart.infixOper = queryParts.pop();
- currentPart.query = currentPart.infixOper.query + " " + currentPart.query;
- /*
- console.debug( "swapping out the infix",
- currentPart.infixOper,
- "and attaching it to",
- currentPart);
- */
- }
- queryParts.push(currentPart);
-
- currentPart = null;
- };
-
- // iterate over the query, character by character, building up a
- // list of query part objects
- for(; lc=cc, cc=query.charAt(x), x < ql; x++){
- // cc: the current character in the match
- // lc: the last character (if any)
-
- // someone is trying to escape something, so don't try to match any
- // fragments. We assume we're inside a literal.
- if(lc == "\\"){ continue; }
- if(!currentPart){ // a part was just ended or none has yet been created
- // NOTE: I hate all this alloc, but it's shorter than writing tons of if's
- pStart = x;
- // rules describe full CSS sub-expressions, like:
- // #someId
- // .className:first-child
- // but not:
- // thinger > div.howdy[type=thinger]
- // the indidual components of the previous query would be
- // split into 3 parts that would be represented a structure like:
- // [
- // {
- // query: "thinger",
- // tag: "thinger",
- // },
- // {
- // query: "div.howdy[type=thinger]",
- // classes: ["howdy"],
- // infixOper: {
- // query: ">",
- // oper: ">",
- // }
- // },
- // ]
- currentPart = {
- query: null, // the full text of the part's rule
- pseudos: [], // CSS supports multiple pseud-class matches in a single rule
- attrs: [], // CSS supports multi-attribute match, so we need an array
- classes: [], // class matches may be additive, e.g.: .thinger.blah.howdy
- tag: null, // only one tag...
- oper: null, // ...or operator per component. Note that these wind up being exclusive.
- id: null, // the id component of a rule
- getTag: function(){
- return caseSensitive ? this.otag : this.tag;
- }
- };
-
- // if we don't have a part, we assume we're going to start at
- // the beginning of a match, which should be a tag name. This
- // might fault a little later on, but we detect that and this
- // iteration will still be fine.
- inTag = x;
- }
-
- // Skip processing all quoted characters.
- // If we are inside quoted text then currentQuoteChar stores the character that began the quote,
- // thus that character that will end it.
- if(currentQuoteChar){
- if(cc == currentQuoteChar){
- currentQuoteChar = null;
- }
- continue;
- }else if (cc == "'" || cc == '"'){
- currentQuoteChar = cc;
- continue;
- }
-
- if(inBrackets >= 0){
- // look for a the close first
- if(cc == "]"){ // if we're in a [...] clause and we end, do assignment
- if(!_cp.attr){
- // no attribute match was previously begun, so we
- // assume this is an attribute existence match in the
- // form of [someAttributeName]
- _cp.attr = ts(inBrackets+1, x);
- }else{
- // we had an attribute already, so we know that we're
- // matching some sort of value, as in [attrName=howdy]
- _cp.matchFor = ts((inMatchFor||inBrackets+1), x);
- }
- var cmf = _cp.matchFor;
- if(cmf){
- // try to strip quotes from the matchFor value. We want
- // [attrName=howdy] to match the same
- // as [attrName = 'howdy' ]
- if( (cmf.charAt(0) == '"') || (cmf.charAt(0) == "'") ){
- _cp.matchFor = cmf.slice(1, -1);
- }
- }
- // remove backslash escapes from an attribute match, since DOM
- // querying will get attribute values without backslashes
- if(_cp.matchFor){
- _cp.matchFor = _cp.matchFor.replace(/\\/g, "");
- }
-
- // end the attribute by adding it to the list of attributes.
- currentPart.attrs.push(_cp);
- _cp = null; // necessary?
- inBrackets = inMatchFor = -1;
- }else if(cc == "="){
- // if the last char was an operator prefix, make sure we
- // record it along with the "=" operator.
- var addToCc = ("|~^$*".indexOf(lc) >=0 ) ? lc : "";
- _cp.type = addToCc+cc;
- _cp.attr = ts(inBrackets+1, x-addToCc.length);
- inMatchFor = x+1;
- }
- // now look for other clause parts
- }else if(inParens >= 0){
- // if we're in a parenthetical expression, we need to figure
- // out if it's attached to a pseudo-selector rule like
- // :nth-child(1)
- if(cc == ")"){
- if(inPseudo >= 0){
- _cp.value = ts(inParens+1, x);
- }
- inPseudo = inParens = -1;
- }
- }else if(cc == "#"){
- // start of an ID match
- endAll();
- inId = x+1;
- }else if(cc == "."){
- // start of a class match
- endAll();
- inClass = x;
- }else if(cc == ":"){
- // start of a pseudo-selector match
- endAll();
- inPseudo = x;
- }else if(cc == "["){
- // start of an attribute match.
- endAll();
- inBrackets = x;
- // provide a new structure for the attribute match to fill-in
- _cp = {
- /*=====
- attr: null, type: null, matchFor: null
- =====*/
- };
- }else if(cc == "("){
- // we really only care if we've entered a parenthetical
- // expression if we're already inside a pseudo-selector match
- if(inPseudo >= 0){
- // provide a new structure for the pseudo match to fill-in
- _cp = {
- name: ts(inPseudo+1, x),
- value: null
- };
- currentPart.pseudos.push(_cp);
- }
- inParens = x;
- }else if(
- (cc == " ") &&
- // if it's a space char and the last char is too, consume the
- // current one without doing more work
- (lc != cc)
- ){
- endPart();
- }
- }
- return queryParts;
- };
-
-
- ////////////////////////////////////////////////////////////////////////
- // DOM query infrastructure
- ////////////////////////////////////////////////////////////////////////
-
- var agree = function(first, second){
- // the basic building block of the yes/no chaining system. agree(f1,
- // f2) generates a new function which returns the boolean results of
- // both of the passed functions to a single logical-anded result. If
- // either are not passed, the other is used exclusively.
- if(!first){ return second; }
- if(!second){ return first; }
-
- return function(){
- return first.apply(window, arguments) && second.apply(window, arguments);
- };
- };
-
- var getArr = function(i, arr){
- // helps us avoid array alloc when we don't need it
- var r = arr||[]; // FIXME: should this be 'new d._NodeListCtor()' ?
- if(i){ r.push(i); }
- return r;
- };
-
- var _isElement = function(n){ return (1 == n.nodeType); };
-
- // FIXME: need to coalesce _getAttr with defaultGetter
- var blank = "";
- var _getAttr = function(elem, attr){
- if(!elem){ return blank; }
- if(attr == "class"){
- return elem.className || blank;
- }
- if(attr == "for"){
- return elem.htmlFor || blank;
- }
- if(attr == "style"){
- return elem.style.cssText || blank;
- }
- return (caseSensitive ? elem.getAttribute(attr) : elem.getAttribute(attr, 2)) || blank;
- };
-
- var attrs = {
- "*=": function(attr, value){
- return function(elem){
- // E[foo*="bar"]
- // an E element whose "foo" attribute value contains
- // the substring "bar"
- return (_getAttr(elem, attr).indexOf(value)>=0);
- };
- },
- "^=": function(attr, value){
- // E[foo^="bar"]
- // an E element whose "foo" attribute value begins exactly
- // with the string "bar"
- return function(elem){
- return (_getAttr(elem, attr).indexOf(value)==0);
- };
- },
- "$=": function(attr, value){
- // E[foo$="bar"]
- // an E element whose "foo" attribute value ends exactly
- // with the string "bar"
- return function(elem){
- var ea = " "+_getAttr(elem, attr);
- var lastIndex = ea.lastIndexOf(value);
- return lastIndex > -1 && (lastIndex==(ea.length-value.length));
- };
- },
- "~=": function(attr, value){
- // E[foo~="bar"]
- // an E element whose "foo" attribute value is a list of
- // space-separated values, one of which is exactly equal
- // to "bar"
-
- // return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]";
- var tval = " "+value+" ";
- return function(elem){
- var ea = " "+_getAttr(elem, attr)+" ";
- return (ea.indexOf(tval)>=0);
- };
- },
- "|=": function(attr, value){
- // E[hreflang|="en"]
- // an E element whose "hreflang" attribute has a
- // hyphen-separated list of values beginning (from the
- // left) with "en"
- var valueDash = value+"-";
- return function(elem){
- var ea = _getAttr(elem, attr);
- return (
- (ea == value) ||
- (ea.indexOf(valueDash)==0)
- );
- };
- },
- "=": function(attr, value){
- return function(elem){
- return (_getAttr(elem, attr) == value);
- };
- }
- };
-
- // avoid testing for node type if we can. Defining this in the negative
- // here to avoid negation in the fast path.
- var _noNES = (typeof getDoc().firstChild.nextElementSibling == "undefined");
- var _ns = !_noNES ? "nextElementSibling" : "nextSibling";
- var _ps = !_noNES ? "previousElementSibling" : "previousSibling";
- var _simpleNodeTest = (_noNES ? _isElement : yesman);
-
- var _lookLeft = function(node){
- // look left
- while(node = node[_ps]){
- if(_simpleNodeTest(node)){ return false; }
- }
- return true;
- };
-
- var _lookRight = function(node){
- // look right
- while(node = node[_ns]){
- if(_simpleNodeTest(node)){ return false; }
- }
- return true;
- };
-
- var getNodeIndex = function(node){
- var root = node.parentNode;
- root = root.nodeType != 7 ? root : root.nextSibling; // PROCESSING_INSTRUCTION_NODE
- var i = 0,
- tret = root.children || root.childNodes,
- ci = (node["_i"]||node.getAttribute("_i")||-1),
- cl = (root["_l"]|| (typeof root.getAttribute !== "undefined" ? root.getAttribute("_l") : -1));
-
- if(!tret){ return -1; }
- var l = tret.length;
-
- // we calculate the parent length as a cheap way to invalidate the
- // cache. It's not 100% accurate, but it's much more honest than what
- // other libraries do
- if( cl == l && ci >= 0 && cl >= 0 ){
- // if it's legit, tag and release
- return ci;
- }
-
- // else re-key things
- if(has("ie") && typeof root.setAttribute !== "undefined"){
- root.setAttribute("_l", l);
- }else{
- root["_l"] = l;
- }
- ci = -1;
- for(var te = root["firstElementChild"]||root["firstChild"]; te; te = te[_ns]){
- if(_simpleNodeTest(te)){
- if(has("ie")){
- te.setAttribute("_i", ++i);
- }else{
- te["_i"] = ++i;
- }
- if(node === te){
- // NOTE:
- // shortcutting the return at this step in indexing works
- // very well for benchmarking but we avoid it here since
- // it leads to potential O(n^2) behavior in sequential
- // getNodexIndex operations on a previously un-indexed
- // parent. We may revisit this at a later time, but for
- // now we just want to get the right answer more often
- // than not.
- ci = i;
- }
- }
- }
- return ci;
- };
-
- var isEven = function(elem){
- return !((getNodeIndex(elem)) % 2);
- };
-
- var isOdd = function(elem){
- return ((getNodeIndex(elem)) % 2);
- };
-
- var pseudos = {
- "checked": function(name, condition){
- return function(elem){
- return !!("checked" in elem ? elem.checked : elem.selected);
- };
- },
- "disabled": function(name, condition){
- return function(elem){
- return elem.disabled;
- };
- },
- "enabled": function(name, condition){
- return function(elem){
- return !elem.disabled;
- };
- },
- "first-child": function(){ return _lookLeft; },
- "last-child": function(){ return _lookRight; },
- "only-child": function(name, condition){
- return function(node){
- return _lookLeft(node) && _lookRight(node);
- };
- },
- "empty": function(name, condition){
- return function(elem){
- // DomQuery and jQuery get this wrong, oddly enough.
- // The CSS 3 selectors spec is pretty explicit about it, too.
- var cn = elem.childNodes;
- var cnl = elem.childNodes.length;
- // if(!cnl){ return true; }
- for(var x=cnl-1; x >= 0; x--){
- var nt = cn[x].nodeType;
- if((nt === 1)||(nt == 3)){ return false; }
- }
- return true;
- };
- },
- "contains": function(name, condition){
- var cz = condition.charAt(0);
- if( cz == '"' || cz == "'" ){ //remove quote
- condition = condition.slice(1, -1);
- }
- return function(elem){
- return (elem.innerHTML.indexOf(condition) >= 0);
- };
- },
- "not": function(name, condition){
- var p = getQueryParts(condition)[0];
- var ignores = { el: 1 };
- if(p.tag != "*"){
- ignores.tag = 1;
- }
- if(!p.classes.length){
- ignores.classes = 1;
- }
- var ntf = getSimpleFilterFunc(p, ignores);
- return function(elem){
- return (!ntf(elem));
- };
- },
- "nth-child": function(name, condition){
- var pi = parseInt;
- // avoid re-defining function objects if we can
- if(condition == "odd"){
- return isOdd;
- }else if(condition == "even"){
- return isEven;
- }
- // FIXME: can we shorten this?
- if(condition.indexOf("n") != -1){
- var tparts = condition.split("n", 2);
- var pred = tparts[0] ? ((tparts[0] == '-') ? -1 : pi(tparts[0])) : 1;
- var idx = tparts[1] ? pi(tparts[1]) : 0;
- var lb = 0, ub = -1;
- if(pred > 0){
- if(idx < 0){
- idx = (idx % pred) && (pred + (idx % pred));
- }else if(idx>0){
- if(idx >= pred){
- lb = idx - idx % pred;
- }
- idx = idx % pred;
- }
- }else if(pred<0){
- pred *= -1;
- // idx has to be greater than 0 when pred is negative;
- // shall we throw an error here?
- if(idx > 0){
- ub = idx;
- idx = idx % pred;
- }
- }
- if(pred > 0){
- return function(elem){
- var i = getNodeIndex(elem);
- return (i>=lb) && (ub<0 || i<=ub) && ((i % pred) == idx);
- };
- }else{
- condition = idx;
- }
- }
- var ncount = pi(condition);
- return function(elem){
- return (getNodeIndex(elem) == ncount);
- };
- }
- };
-
- var defaultGetter = (has("ie") < 9 || has("ie") == 9 && has("quirks")) ? function(cond){
- var clc = cond.toLowerCase();
- if(clc == "class"){ cond = "className"; }
- return function(elem){
- return (caseSensitive ? elem.getAttribute(cond) : elem[cond]||elem[clc]);
- };
- } : function(cond){
- return function(elem){
- return (elem && elem.getAttribute && elem.hasAttribute(cond));
- };
- };
-
- var getSimpleFilterFunc = function(query, ignores){
- // generates a node tester function based on the passed query part. The
- // query part is one of the structures generated by the query parser
- // when it creates the query AST. The "ignores" object specifies which
- // (if any) tests to skip, allowing the system to avoid duplicating
- // work where it may have already been taken into account by other
- // factors such as how the nodes to test were fetched in the first
- // place
- if(!query){ return yesman; }
- ignores = ignores||{};
-
- var ff = null;
-
- if(!("el" in ignores)){
- ff = agree(ff, _isElement);
- }
-
- if(!("tag" in ignores)){
- if(query.tag != "*"){
- ff = agree(ff, function(elem){
- return (elem && ((caseSensitive ? elem.tagName : elem.tagName.toUpperCase()) == query.getTag()));
- });
- }
- }
-
- if(!("classes" in ignores)){
- each(query.classes, function(cname, idx, arr){
- // get the class name
- /*
- var isWildcard = cname.charAt(cname.length-1) == "*";
- if(isWildcard){
- cname = cname.substr(0, cname.length-1);
- }
- // I dislike the regex thing, even if memoized in a cache, but it's VERY short
- var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)");
- */
- var re = new RegExp("(?:^|\\s)" + cname + "(?:\\s|$)");
- ff = agree(ff, function(elem){
- return re.test(elem.className);
- });
- ff.count = idx;
- });
- }
-
- if(!("pseudos" in ignores)){
- each(query.pseudos, function(pseudo){
- var pn = pseudo.name;
- if(pseudos[pn]){
- ff = agree(ff, pseudos[pn](pn, pseudo.value));
- }
- });
- }
-
- if(!("attrs" in ignores)){
- each(query.attrs, function(attr){
- var matcher;
- var a = attr.attr;
- // type, attr, matchFor
- if(attr.type && attrs[attr.type]){
- matcher = attrs[attr.type](a, attr.matchFor);
- }else if(a.length){
- matcher = defaultGetter(a);
- }
- if(matcher){
- ff = agree(ff, matcher);
- }
- });
- }
-
- if(!("id" in ignores)){
- if(query.id){
- ff = agree(ff, function(elem){
- return (!!elem && (elem.id == query.id));
- });
- }
- }
-
- if(!ff){
- if(!("default" in ignores)){
- ff = yesman;
- }
- }
- return ff;
- };
-
- var _nextSibling = function(filterFunc){
- return function(node, ret, bag){
- while(node = node[_ns]){
- if(_noNES && (!_isElement(node))){ continue; }
- if(
- (!bag || _isUnique(node, bag)) &&
- filterFunc(node)
- ){
- ret.push(node);
- }
- break;
- }
- return ret;
- };
- };
-
- var _nextSiblings = function(filterFunc){
- return function(root, ret, bag){
- var te = root[_ns];
- while(te){
- if(_simpleNodeTest(te)){
- if(bag && !_isUnique(te, bag)){
- break;
- }
- if(filterFunc(te)){
- ret.push(te);
- }
- }
- te = te[_ns];
- }
- return ret;
- };
- };
-
- // get an array of child *elements*, skipping text and comment nodes
- var _childElements = function(filterFunc){
- filterFunc = filterFunc||yesman;
- return function(root, ret, bag){
- // get an array of child elements, skipping text and comment nodes
- var te, x = 0, tret = root.children || root.childNodes;
- while(te = tret[x++]){
- if(
- _simpleNodeTest(te) &&
- (!bag || _isUnique(te, bag)) &&
- (filterFunc(te, x))
- ){
- ret.push(te);
- }
- }
- return ret;
- };
- };
-
- // test to see if node is below root
- var _isDescendant = function(node, root){
- var pn = node.parentNode;
- while(pn){
- if(pn == root){
- break;
- }
- pn = pn.parentNode;
- }
- return !!pn;
- };
-
- var _getElementsFuncCache = {};
-
- var getElementsFunc = function(query){
- var retFunc = _getElementsFuncCache[query.query];
- // if we've got a cached dispatcher, just use that
- if(retFunc){ return retFunc; }
- // else, generate a new on
-
- // NOTE:
- // this function returns a function that searches for nodes and
- // filters them. The search may be specialized by infix operators
- // (">", "~", or "+") else it will default to searching all
- // descendants (the " " selector). Once a group of children is
- // found, a test function is applied to weed out the ones we
- // don't want. Many common cases can be fast-pathed. We spend a
- // lot of cycles to create a dispatcher that doesn't do more work
- // than necessary at any point since, unlike this function, the
- // dispatchers will be called every time. The logic of generating
- // efficient dispatchers looks like this in pseudo code:
- //
- // # if it's a purely descendant query (no ">", "+", or "~" modifiers)
- // if infixOperator == " ":
- // if only(id):
- // return def(root):
- // return d.byId(id, root);
- //
- // elif id:
- // return def(root):
- // return filter(d.byId(id, root));
- //
- // elif cssClass && getElementsByClassName:
- // return def(root):
- // return filter(root.getElementsByClassName(cssClass));
- //
- // elif only(tag):
- // return def(root):
- // return root.getElementsByTagName(tagName);
- //
- // else:
- // # search by tag name, then filter
- // return def(root):
- // return filter(root.getElementsByTagName(tagName||"*"));
- //
- // elif infixOperator == ">":
- // # search direct children
- // return def(root):
- // return filter(root.children);
- //
- // elif infixOperator == "+":
- // # search next sibling
- // return def(root):
- // return filter(root.nextElementSibling);
- //
- // elif infixOperator == "~":
- // # search rightward siblings
- // return def(root):
- // return filter(nextSiblings(root));
-
- var io = query.infixOper;
- var oper = (io ? io.oper : "");
- // the default filter func which tests for all conditions in the query
- // part. This is potentially inefficient, so some optimized paths may
- // re-define it to test fewer things.
- var filterFunc = getSimpleFilterFunc(query, { el: 1 });
- var qt = query.tag;
- var wildcardTag = ("*" == qt);
- var ecs = getDoc()["getElementsByClassName"];
-
- if(!oper){
- // if there's no infix operator, then it's a descendant query. ID
- // and "elements by class name" variants can be accelerated so we
- // call them out explicitly:
- if(query.id){
- // testing shows that the overhead of yesman() is acceptable
- // and can save us some bytes vs. re-defining the function
- // everywhere.
- filterFunc = (!query.loops && wildcardTag) ?
- yesman :
- getSimpleFilterFunc(query, { el: 1, id: 1 });
-
- retFunc = function(root, arr){
- var te = dom.byId(query.id, (root.ownerDocument||root));
- if(!te || !filterFunc(te)){ return; }
- if(9 == root.nodeType){ // if root's a doc, we just return directly
- return getArr(te, arr);
- }else{ // otherwise check ancestry
- if(_isDescendant(te, root)){
- return getArr(te, arr);
- }
- }
- };
- }else if(
- ecs &&
- // isAlien check. Workaround for Prototype.js being totally evil/dumb.
- /\{\s*\[native code\]\s*\}/.test(String(ecs)) &&
- query.classes.length &&
- !cssCaseBug
- ){
- // it's a class-based query and we've got a fast way to run it.
-
- // ignore class and ID filters since we will have handled both
- filterFunc = getSimpleFilterFunc(query, { el: 1, classes: 1, id: 1 });
- var classesString = query.classes.join(" ");
- retFunc = function(root, arr, bag){
- var ret = getArr(0, arr), te, x=0;
- var tret = root.getElementsByClassName(classesString);
- while((te = tret[x++])){
- if(filterFunc(te, root) && _isUnique(te, bag)){
- ret.push(te);
- }
- }
- return ret;
- };
-
- }else if(!wildcardTag && !query.loops){
- // it's tag only. Fast-path it.
- retFunc = function(root, arr, bag){
- var ret = getArr(0, arr), te, x=0;
- var tag = query.getTag(),
- tret = tag ? root.getElementsByTagName(tag) : [];
- while((te = tret[x++])){
- if(_isUnique(te, bag)){
- ret.push(te);
- }
- }
- return ret;
- };
- }else{
- // the common case:
- // a descendant selector without a fast path. By now it's got
- // to have a tag selector, even if it's just "*" so we query
- // by that and filter
- filterFunc = getSimpleFilterFunc(query, { el: 1, tag: 1, id: 1 });
- retFunc = function(root, arr, bag){
- var ret = getArr(0, arr), te, x=0;
- // we use getTag() to avoid case sensitivity issues
- var tag = query.getTag(),
- tret = tag ? root.getElementsByTagName(tag) : [];
- while((te = tret[x++])){
- if(filterFunc(te, root) && _isUnique(te, bag)){
- ret.push(te);
- }
- }
- return ret;
- };
- }
- }else{
- // the query is scoped in some way. Instead of querying by tag we
- // use some other collection to find candidate nodes
- var skipFilters = { el: 1 };
- if(wildcardTag){
- skipFilters.tag = 1;
- }
- filterFunc = getSimpleFilterFunc(query, skipFilters);
- if("+" == oper){
- retFunc = _nextSibling(filterFunc);
- }else if("~" == oper){
- retFunc = _nextSiblings(filterFunc);
- }else if(">" == oper){
- retFunc = _childElements(filterFunc);
- }
- }
- // cache it and return
- return _getElementsFuncCache[query.query] = retFunc;
- };
-
- var filterDown = function(root, queryParts){
- // NOTE:
- // this is the guts of the DOM query system. It takes a list of
- // parsed query parts and a root and finds children which match
- // the selector represented by the parts
- var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret;
-
- for(var i = 0; i < qpl; i++){
- ret = [];
- qp = queryParts[i];
- x = candidates.length - 1;
- if(x > 0){
- // if we have more than one root at this level, provide a new
- // hash to use for checking group membership but tell the
- // system not to post-filter us since we will already have been
- // guaranteed to be unique
- bag = {};
- ret.nozip = true;
- }
- var gef = getElementsFunc(qp);
- for(var j = 0; (te = candidates[j]); j++){
- // for every root, get the elements that match the descendant
- // selector, adding them to the "ret" array and filtering them
- // via membership in this level's bag. If there are more query
- // parts, then this level's return will be used as the next
- // level's candidates
- gef(te, ret, bag);
- }
- if(!ret.length){ break; }
- candidates = ret;
- }
- return ret;
- };
-
- ////////////////////////////////////////////////////////////////////////
- // the query runner
- ////////////////////////////////////////////////////////////////////////
-
- // these are the primary caches for full-query results. The query
- // dispatcher functions are generated then stored here for hash lookup in
- // the future
- var _queryFuncCacheDOM = {},
- _queryFuncCacheQSA = {};
-
- // this is the second level of splitting, from full-length queries (e.g.,
- // "div.foo .bar") into simple query expressions (e.g., ["div.foo",
- // ".bar"])
- var getStepQueryFunc = function(query){
- var qparts = getQueryParts(trim(query));
-
- // if it's trivial, avoid iteration and zipping costs
- if(qparts.length == 1){
- // we optimize this case here to prevent dispatch further down the
- // chain, potentially slowing things down. We could more elegantly
- // handle this in filterDown(), but it's slower for simple things
- // that need to be fast (e.g., "#someId").
- var tef = getElementsFunc(qparts[0]);
- return function(root){
- var r = tef(root, []);
- if(r){ r.nozip = true; }
- return r;
- };
- }
-
- // otherwise, break it up and return a runner that iterates over the parts recursively
- return function(root){
- return filterDown(root, qparts);
- };
- };
-
- // NOTES:
- // * we can't trust QSA for anything but document-rooted queries, so
- // caching is split into DOM query evaluators and QSA query evaluators
- // * caching query results is dirty and leak-prone (or, at a minimum,
- // prone to unbounded growth). Other toolkits may go this route, but
- // they totally destroy their own ability to manage their memory
- // footprint. If we implement it, it should only ever be with a fixed
- // total element reference # limit and an LRU-style algorithm since JS
- // has no weakref support. Caching compiled query evaluators is also
- // potentially problematic, but even on large documents the size of the
- // query evaluators is often < 100 function objects per evaluator (and
- // LRU can be applied if it's ever shown to be an issue).
- // * since IE's QSA support is currently only for HTML documents and even
- // then only in IE 8's "standards mode", we have to detect our dispatch
- // route at query time and keep 2 separate caches. Ugg.
-
- // we need to determine if we think we can run a given query via
- // querySelectorAll or if we'll need to fall back on DOM queries to get
- // there. We need a lot of information about the environment and the query
- // to make the determination (e.g. does it support QSA, does the query in
- // question work in the native QSA impl, etc.).
-
- // IE QSA queries may incorrectly include comment nodes, so we throw the
- // zipping function into "remove" comments mode instead of the normal "skip
- // it" which every other QSA-clued browser enjoys
- var noZip = has("ie") ? "commentStrip" : "nozip";
-
- var qsa = "querySelectorAll";
- var qsaAvail = !!getDoc()[qsa];
-
- //Don't bother with n+3 type of matches, IE complains if we modify those.
- var infixSpaceRe = /\\[>~+]|n\+\d|([^ \\])?([>~+])([^ =])?/g;
- var infixSpaceFunc = function(match, pre, ch, post){
- return ch ? (pre ? pre + " " : "") + ch + (post ? " " + post : "") : /*n+3*/ match;
- };
-
- //Don't apply the infixSpaceRe to attribute value selectors
- var attRe = /([^[]*)([^\]]*])?/g;
- var attFunc = function(match, nonAtt, att){
- return nonAtt.replace(infixSpaceRe, infixSpaceFunc) + (att||"");
- };
- var getQueryFunc = function(query, forceDOM){
- //Normalize query. The CSS3 selectors spec allows for omitting spaces around
- //infix operators, >, ~ and +
- //Do the work here since detection for spaces is used as a simple "not use QSA"
- //test below.
- query = query.replace(attRe, attFunc);
-
- if(qsaAvail){
- // if we've got a cached variant and we think we can do it, run it!
- var qsaCached = _queryFuncCacheQSA[query];
- if(qsaCached && !forceDOM){ return qsaCached; }
- }
-
- // else if we've got a DOM cached variant, assume that we already know
- // all we need to and use it
- var domCached = _queryFuncCacheDOM[query];
- if(domCached){ return domCached; }
-
- // TODO:
- // today we're caching DOM and QSA branches separately so we
- // recalc useQSA every time. If we had a way to tag root+query
- // efficiently, we'd be in good shape to do a global cache.
-
- var qcz = query.charAt(0);
- var nospace = (-1 == query.indexOf(" "));
-
- // byId searches are wicked fast compared to QSA, even when filtering
- // is required
- if( (query.indexOf("#") >= 0) && (nospace) ){
- forceDOM = true;
- }
-
- var useQSA = (
- qsaAvail && (!forceDOM) &&
- // as per CSS 3, we can't currently start w/ combinator:
- // http://www.w3.org/TR/css3-selectors/#w3cselgrammar
- (specials.indexOf(qcz) == -1) &&
- // IE's QSA impl sucks on pseudos
- (!has("ie") || (query.indexOf(":") == -1)) &&
-
- (!(cssCaseBug && (query.indexOf(".") >= 0))) &&
-
- // FIXME:
- // need to tighten up browser rules on ":contains" and "|=" to
- // figure out which aren't good
- // Latest webkit (around 531.21.8) does not seem to do well with :checked on option
- // elements, even though according to spec, selected options should
- // match :checked. So go nonQSA for it:
- // http://bugs.dojotoolkit.org/ticket/5179
- (query.indexOf(":contains") == -1) && (query.indexOf(":checked") == -1) &&
- (query.indexOf("|=") == -1) // some browsers don't grok it
- );
-
- // TODO:
- // if we've got a descendant query (e.g., "> .thinger" instead of
- // just ".thinger") in a QSA-able doc, but are passed a child as a
- // root, it should be possible to give the item a synthetic ID and
- // trivially rewrite the query to the form "#synid > .thinger" to
- // use the QSA branch
-
-
- if(useQSA){
- var tq = (specials.indexOf(query.charAt(query.length-1)) >= 0) ?
- (query + " *") : query;
- return _queryFuncCacheQSA[query] = function(root){
- try{
- // the QSA system contains an egregious spec bug which
- // limits us, effectively, to only running QSA queries over
- // entire documents. See:
- // http://ejohn.org/blog/thoughts-on-queryselectorall/
- // despite this, we can also handle QSA runs on simple
- // selectors, but we don't want detection to be expensive
- // so we're just checking for the presence of a space char
- // right now. Not elegant, but it's cheaper than running
- // the query parser when we might not need to
- if(!((9 == root.nodeType) || nospace)){ throw ""; }
- var r = root[qsa](tq);
- // skip expensive duplication checks and just wrap in a NodeList
- r[noZip] = true;
- return r;
- }catch(e){
- // else run the DOM branch on this query, ensuring that we
- // default that way in the future
- return getQueryFunc(query, true)(root);
- }
- };
- }else{
- // DOM branch
- var parts = query.match(/([^\s,](?:"(?:\\.|[^"])+"|'(?:\\.|[^'])+'|[^,])*)/g);
- return _queryFuncCacheDOM[query] = ((parts.length < 2) ?
- // if not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher
- getStepQueryFunc(query) :
- // if it *is* a complex query, break it up into its
- // constituent parts and return a dispatcher that will
- // merge the parts when run
- function(root){
- var pindex = 0, // avoid array alloc for every invocation
- ret = [],
- tp;
- while((tp = parts[pindex++])){
- ret = ret.concat(getStepQueryFunc(tp)(root));
- }
- return ret;
- }
- );
- }
- };
-
- var _zipIdx = 0;
-
- // NOTE:
- // this function is Moo inspired, but our own impl to deal correctly
- // with XML in IE
- var _nodeUID = has("ie") ? function(node){
- if(caseSensitive){
- // XML docs don't have uniqueID on their nodes
- return (node.getAttribute("_uid") || node.setAttribute("_uid", ++_zipIdx) || _zipIdx);
-
- }else{
- return node.uniqueID;
- }
- } :
- function(node){
- return (node._uid || (node._uid = ++_zipIdx));
- };
-
- // determine if a node in is unique in a "bag". In this case we don't want
- // to flatten a list of unique items, but rather just tell if the item in
- // question is already in the bag. Normally we'd just use hash lookup to do
- // this for us but IE's DOM is busted so we can't really count on that. On
- // the upside, it gives us a built in unique ID function.
- var _isUnique = function(node, bag){
- if(!bag){ return 1; }
- var id = _nodeUID(node);
- if(!bag[id]){ return bag[id] = 1; }
- return 0;
- };
-
- // attempt to efficiently determine if an item in a list is a dupe,
- // returning a list of "uniques", hopefully in document order
- var _zipIdxName = "_zipIdx";
- var _zip = function(arr){
- if(arr && arr.nozip){ return arr; }
-
- if(!arr || !arr.length){ return []; }
- if(arr.length < 2){ return [arr[0]]; }
-
- var ret = [];
-
- _zipIdx++;
-
- // we have to fork here for IE and XML docs because we can't set
- // expandos on their nodes (apparently). *sigh*
- var x, te;
- if(has("ie") && caseSensitive){
- var szidx = _zipIdx+"";
- for(x = 0; x < arr.length; x++){
- if((te = arr[x]) && te.getAttribute(_zipIdxName) != szidx){
- ret.push(te);
- te.setAttribute(_zipIdxName, szidx);
- }
- }
- }else if(has("ie") && arr.commentStrip){
- try{
- for(x = 0; x < arr.length; x++){
- if((te = arr[x]) && _isElement(te)){
- ret.push(te);
- }
- }
- }catch(e){ /* squelch */ }
- }else{
- for(x = 0; x < arr.length; x++){
- if((te = arr[x]) && te[_zipIdxName] != _zipIdx){
- ret.push(te);
- te[_zipIdxName] = _zipIdx;
- }
- }
- }
- return ret;
- };
-
- // the main executor
- var query = function(/*String*/ query, /*String|DOMNode?*/ root){
- // summary:
- // Returns nodes which match the given CSS3 selector, searching the
- // entire document by default but optionally taking a node to scope
- // the search by. Returns an array.
- // description:
- // dojo.query() is the swiss army knife of DOM node manipulation in
- // Dojo. Much like Prototype's "$$" (bling-bling) function or JQuery's
- // "$" function, dojo.query provides robust, high-performance
- // CSS-based node selector support with the option of scoping searches
- // to a particular sub-tree of a document.
- //
- // Supported Selectors:
- // --------------------
- //
- // acme supports a rich set of CSS3 selectors, including:
- //
- // - class selectors (e.g., `.foo`)
- // - node type selectors like `span`
- // - ` ` descendant selectors
- // - `>` child element selectors
- // - `#foo` style ID selectors
- // - `*` universal selector
- // - `~`, the preceded-by sibling selector
- // - `+`, the immediately preceded-by sibling selector
- // - attribute queries:
- // - `[foo]` attribute presence selector
- // - `[foo='bar']` attribute value exact match
- // - `[foo~='bar']` attribute value list item match
- // - `[foo^='bar']` attribute start match
- // - `[foo$='bar']` attribute end match
- // - `[foo*='bar']` attribute substring match
- // - `:first-child`, `:last-child`, and `:only-child` positional selectors
- // - `:empty` content emtpy selector
- // - `:checked` pseudo selector
- // - `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations
- // - `:nth-child(even)`, `:nth-child(odd)` positional selectors
- // - `:not(...)` negation pseudo selectors
- //
- // Any legal combination of these selectors will work with
- // `dojo.query()`, including compound selectors ("," delimited).
- // Very complex and useful searches can be constructed with this
- // palette of selectors and when combined with functions for
- // manipulation presented by dojo/NodeList, many types of DOM
- // manipulation operations become very straightforward.
- //
- // Unsupported Selectors:
- // ----------------------
- //
- // While dojo.query handles many CSS3 selectors, some fall outside of
- // what's reasonable for a programmatic node querying engine to
- // handle. Currently unsupported selectors include:
- //
- // - namespace-differentiated selectors of any form
- // - all `::` pseduo-element selectors
- // - certain pseudo-selectors which don't get a lot of day-to-day use:
- // - `:root`, `:lang()`, `:target`, `:focus`
- // - all visual and state selectors:
- // - `:root`, `:active`, `:hover`, `:visited`, `:link`,
- // `:enabled`, `:disabled`
- // - `:*-of-type` pseudo selectors
- //
- // dojo.query and XML Documents:
- // -----------------------------
- //
- // `dojo.query` (as of dojo 1.2) supports searching XML documents
- // in a case-sensitive manner. If an HTML document is served with
- // a doctype that forces case-sensitivity (e.g., XHTML 1.1
- // Strict), dojo.query() will detect this and "do the right
- // thing". Case sensitivity is dependent upon the document being
- // searched and not the query used. It is therefore possible to
- // use case-sensitive queries on strict sub-documents (iframes,
- // etc.) or XML documents while still assuming case-insensitivity
- // for a host/root document.
- //
- // Non-selector Queries:
- // ---------------------
- //
- // If something other than a String is passed for the query,
- // `dojo.query` will return a new `dojo/NodeList` instance
- // constructed from that parameter alone and all further
- // processing will stop. This means that if you have a reference
- // to a node or NodeList, you can quickly construct a new NodeList
- // from the original by calling `dojo.query(node)` or
- // `dojo.query(list)`.
- //
- // query:
- // The CSS3 expression to match against. For details on the syntax of
- // CSS3 selectors, see
- // root:
- // A DOMNode (or node id) to scope the search from. Optional.
- // returns: Array
- // example:
- // search the entire document for elements with the class "foo":
- // | require(["dojo/query"], function(query) {
- // | query(".foo").forEach(function(q) { console.log(q); });
- // | });
- // these elements will match:
- // |
- // |
- // |
- // example:
- // search the entire document for elements with the classes "foo" *and* "bar":
- // | require(["dojo/query"], function(query) {
- // | query(".foo.bar").forEach(function(q) { console.log(q); });
- // | });
-
- // these elements will match:
- // |
- // while these will not:
- // |
- // |
- // example:
- // find `` elements which are descendants of paragraphs and
- // which have a "highlighted" class:
- // | require(["dojo/query"], function(query) {
- // | query("p span.highlighted").forEach(function(q) { console.log(q); });
- // | });
- // the innermost span in this fragment matches:
- // |
- // | ...
- // | ...
- // |
- // |
- // example:
- // set an "odd" class on all odd table rows inside of the table
- // `#tabular_data`, using the `>` (direct child) selector to avoid
- // affecting any nested tables:
- // | require(["dojo/query"], function(query) {
- // | query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd");
- // | );
- // example:
- // remove all elements with the class "error" from the document:
- // | require(["dojo/query"], function(query) {
- // | query(".error").orphan();
- // | );
- // example:
- // add an onclick handler to every submit button in the document
- // which causes the form to be sent via Ajax instead:
- // | require(["dojo/query", "dojo/request", "dojo/dom-construct", "dojo/dom-style"
- // | ], function (query, request, domConstruct, domStyle) {
- // | query("input[type='submit']").on("click", function (e) {
- // | e.stopPropagation();
- // | e.preventDefault();
- // | var btn = e.target;
- // | request.post("", { data: btn.form, timeout: 2000 })
- // | .then(function (data) {
- // | // replace the form with the response
- // | domConstruct.create("div", { innerHTML: data }, btn.form, "after");
- // | domStyle.set(btn.form, "display", "none");
- // | });
- // | });
- // | });
-
-
- root = root || getDoc();
-
- // throw the big case sensitivity switch
- var od = root.ownerDocument || root; // root is either Document or a node inside the document
- caseSensitive = (od.createElement("div").tagName === "div");
-
- // NOTE:
- // adding "true" as the 2nd argument to getQueryFunc is useful for
- // testing the DOM branch without worrying about the
- // behavior/performance of the QSA branch.
- var r = getQueryFunc(query)(root);
-
- // FIXME:
- // need to investigate this branch WRT #8074 and #8075
- if(r && r.nozip){
- return r;
- }
- return _zip(r); // dojo/NodeList
- };
- query.filter = function(/*Node[]*/ nodeList, /*String*/ filter, /*String|DOMNode?*/ root){
- // summary:
- // function for filtering a NodeList based on a selector, optimized for simple selectors
- var tmpNodeList = [],
- parts = getQueryParts(filter),
- filterFunc =
- (parts.length == 1 && !/[^\w#\.]/.test(filter)) ?
- getSimpleFilterFunc(parts[0]) :
- function(node){
- return array.indexOf(query(filter, dom.byId(root)), node) != -1;
- };
- for(var x = 0, te; te = nodeList[x]; x++){
- if(filterFunc(te)){ tmpNodeList.push(te); }
- }
- return tmpNodeList;
- };
- return query;
-});
-
-},
-'dojo/errors/RequestTimeoutError':function(){
-define(['./create', './RequestError'], function(create, RequestError){
- // module:
- // dojo/errors/RequestTimeoutError
-
- /*=====
- return function(){
- // summary:
- // TODOC
- };
- =====*/
-
- return create("RequestTimeoutError", null, RequestError, {
- dojoType: "timeout"
- });
-});
-
-},
-'dojo/dom-style':function(){
-define(["./sniff", "./dom"], function(has, dom){
- // module:
- // dojo/dom-style
-
- // =============================
- // Style Functions
- // =============================
-
- // getComputedStyle drives most of the style code.
- // Wherever possible, reuse the returned object.
- //
- // API functions below that need to access computed styles accept an
- // optional computedStyle parameter.
- // If this parameter is omitted, the functions will call getComputedStyle themselves.
- // This way, calling code can access computedStyle once, and then pass the reference to
- // multiple API functions.
-
- // Although we normally eschew argument validation at this
- // level, here we test argument 'node' for (duck)type,
- // by testing nodeType, ecause 'document' is the 'parentNode' of 'body'
- // it is frequently sent to this function even
- // though it is not Element.
- var getComputedStyle, style = {
- // summary:
- // This module defines the core dojo DOM style API.
- };
- if(has("webkit")){
- getComputedStyle = function(/*DomNode*/ node){
- var s;
- if(node.nodeType == 1){
- var dv = node.ownerDocument.defaultView;
- s = dv.getComputedStyle(node, null);
- if(!s && node.style){
- node.style.display = "";
- s = dv.getComputedStyle(node, null);
- }
- }
- return s || {};
- };
- }else if(has("ie") && (has("ie") < 9 || has("quirks"))){
- getComputedStyle = function(node){
- // IE (as of 7) doesn't expose Element like sane browsers
- // currentStyle can be null on IE8!
- return node.nodeType == 1 /* ELEMENT_NODE*/ && node.currentStyle ? node.currentStyle : {};
- };
- }else{
- getComputedStyle = function(node){
- return node.nodeType == 1 /* ELEMENT_NODE*/ ?
- node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
- };
- }
- style.getComputedStyle = getComputedStyle;
- /*=====
- style.getComputedStyle = function(node){
- // summary:
- // Returns a "computed style" object.
- //
- // description:
- // Gets a "computed style" object which can be used to gather
- // information about the current state of the rendered node.
- //
- // Note that this may behave differently on different browsers.
- // Values may have different formats and value encodings across
- // browsers.
- //
- // Note also that this method is expensive. Wherever possible,
- // reuse the returned object.
- //
- // Use the dojo/dom-style.get() method for more consistent (pixelized)
- // return values.
- //
- // node: DOMNode
- // A reference to a DOM node. Does NOT support taking an
- // ID string for speed reasons.
- // example:
- // | require(["dojo/dom-style", "dojo/dom"], function(domStyle, dom){
- // | domStyle.getComputedStyle(dom.byId('foo')).borderWidth;
- // | });
- //
- // example:
- // Reusing the returned object, avoiding multiple lookups:
- // | require(["dojo/dom-style", "dojo/dom"], function(domStyle, dom){
- // | var cs = domStyle.getComputedStyle(dom.byId("someNode"));
- // | var w = cs.width, h = cs.height;
- // | });
- return; // CSS2Properties
- };
- =====*/
-
- var toPixel;
- if(!has("ie")){
- toPixel = function(element, value){
- // style values can be floats, client code may want
- // to round for integer pixels.
- return parseFloat(value) || 0;
- };
- }else{
- toPixel = function(element, avalue){
- if(!avalue){ return 0; }
- // on IE7, medium is usually 4 pixels
- if(avalue == "medium"){ return 4; }
- // style values can be floats, client code may
- // want to round this value for integer pixels.
- if(avalue.slice && avalue.slice(-2) == 'px'){ return parseFloat(avalue); }
- var s = element.style, rs = element.runtimeStyle, cs = element.currentStyle,
- sLeft = s.left, rsLeft = rs.left;
- rs.left = cs.left;
- try{
- // 'avalue' may be incompatible with style.left, which can cause IE to throw
- // this has been observed for border widths using "thin", "medium", "thick" constants
- // those particular constants could be trapped by a lookup
- // but perhaps there are more
- s.left = avalue;
- avalue = s.pixelLeft;
- }catch(e){
- avalue = 0;
- }
- s.left = sLeft;
- rs.left = rsLeft;
- return avalue;
- };
- }
- style.toPixelValue = toPixel;
- /*=====
- style.toPixelValue = function(node, value){
- // summary:
- // converts style value to pixels on IE or return a numeric value.
- // node: DOMNode
- // value: String
- // returns: Number
- };
- =====*/
-
- // FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
-
- var astr = "DXImageTransform.Microsoft.Alpha";
- var af = function(n, f){
- try{
- return n.filters.item(astr);
- }catch(e){
- return f ? {} : null;
- }
- };
-
- var _getOpacity =
- has("ie") < 9 || (has("ie") < 10 && has("quirks")) ? function(node){
- try{
- return af(node).Opacity / 100; // Number
- }catch(e){
- return 1; // Number
- }
- } :
- function(node){
- return getComputedStyle(node).opacity;
- };
-
- var _setOpacity =
- has("ie") < 9 || (has("ie") < 10 && has("quirks")) ? function(/*DomNode*/ node, /*Number*/ opacity){
- if(opacity === ""){ opacity = 1; }
- var ov = opacity * 100, fullyOpaque = opacity === 1;
-
- // on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661),
- // but still update the opacity value so we can get a correct reading if it is read later:
- // af(node, 1).Enabled = !fullyOpaque;
-
- if(fullyOpaque){
- node.style.zoom = "";
- if(af(node)){
- node.style.filter = node.style.filter.replace(
- new RegExp("\\s*progid:" + astr + "\\([^\\)]+?\\)", "i"), "");
- }
- }else{
- node.style.zoom = 1;
- if(af(node)){
- af(node, 1).Opacity = ov;
- }else{
- node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")";
- }
- af(node, 1).Enabled = true;
- }
-
- if(node.tagName.toLowerCase() == "tr"){
- for(var td = node.firstChild; td; td = td.nextSibling){
- if(td.tagName.toLowerCase() == "td"){
- _setOpacity(td, opacity);
- }
- }
- }
- return opacity;
- } :
- function(node, opacity){
- return node.style.opacity = opacity;
- };
-
- var _pixelNamesCache = {
- left: true, top: true
- };
- var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border
- function _toStyleValue(node, type, value){
- //TODO: should we really be doing string case conversion here? Should we cache it? Need to profile!
- type = type.toLowerCase();
- if(has("ie") || has("trident")){
- if(value == "auto"){
- if(type == "height"){ return node.offsetHeight; }
- if(type == "width"){ return node.offsetWidth; }
- }
- if(type == "fontweight"){
- switch(value){
- case 700: return "bold";
- case 400:
- default: return "normal";
- }
- }
- }
- if(!(type in _pixelNamesCache)){
- _pixelNamesCache[type] = _pixelRegExp.test(type);
- }
- return _pixelNamesCache[type] ? toPixel(node, value) : value;
- }
-
- var _floatAliases = {cssFloat: 1, styleFloat: 1, "float": 1};
-
- // public API
-
- style.get = function getStyle(/*DOMNode|String*/ node, /*String?*/ name){
- // summary:
- // Accesses styles on a node.
- // description:
- // Getting the style value uses the computed style for the node, so the value
- // will be a calculated value, not just the immediate node.style value.
- // Also when getting values, use specific style names,
- // like "borderBottomWidth" instead of "border" since compound values like
- // "border" are not necessarily reflected as expected.
- // If you want to get node dimensions, use `dojo/dom-geometry.getMarginBox()`,
- // `dojo/dom-geometry.getContentBox()` or `dojo/dom-geometry.getPosition()`.
- // node: DOMNode|String
- // id or reference to node to get style for
- // name: String?
- // the style property to get
- // example:
- // Passing only an ID or node returns the computed style object of
- // the node:
- // | require(["dojo/dom-style", "dojo/dom"], function(domStyle, dom){
- // | domStyle.get("thinger");
- // | });
- // example:
- // Passing a node and a style property returns the current
- // normalized, computed value for that property:
- // | require(["dojo/dom-style", "dojo/dom"], function(domStyle, dom){
- // | domStyle.get("thinger", "opacity"); // 1 by default
- // | });
-
- var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
- if(l == 2 && op){
- return _getOpacity(n);
- }
- name = _floatAliases[name] ? "cssFloat" in n.style ? "cssFloat" : "styleFloat" : name;
- var s = style.getComputedStyle(n);
- return (l == 1) ? s : _toStyleValue(n, name, s[name] || n.style[name]); /* CSS2Properties||String||Number */
- };
-
- style.set = function setStyle(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
- // summary:
- // Sets styles on a node.
- // node: DOMNode|String
- // id or reference to node to set style for
- // name: String|Object
- // the style property to set in DOM-accessor format
- // ("borderWidth", not "border-width") or an object with key/value
- // pairs suitable for setting each property.
- // value: String?
- // If passed, sets value on the node for style, handling
- // cross-browser concerns. When setting a pixel value,
- // be sure to include "px" in the value. For instance, top: "200px".
- // Otherwise, in some cases, some browsers will not apply the style.
- //
- // example:
- // Passing a node, a style property, and a value changes the
- // current display of the node and returns the new computed value
- // | require(["dojo/dom-style"], function(domStyle){
- // | domStyle.set("thinger", "opacity", 0.5); // == 0.5
- // | });
- //
- // example:
- // Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
- // | require(["dojo/dom-style"], function(domStyle){
- // | domStyle.set("thinger", {
- // | "opacity": 0.5,
- // | "border": "3px solid black",
- // | "height": "300px"
- // | });
- // | });
- //
- // example:
- // When the CSS style property is hyphenated, the JavaScript property is camelCased.
- // font-size becomes fontSize, and so on.
- // | require(["dojo/dom-style", "dojo/dom"], function(domStyle, dom){
- // | domStyle.set("thinger",{
- // | fontSize:"14pt",
- // | letterSpacing:"1.2em"
- // | });
- // | });
- //
- // example:
- // dojo/NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
- // dojo/dom-style.get() on every element of the list. See: `dojo/query` and `dojo/NodeList`
- // | require(["dojo/dom-style", "dojo/query", "dojo/NodeList-dom"],
- // | function(domStyle, query){
- // | query(".someClassName").style("visibility","hidden");
- // | // or
- // | query("#baz > div").style({
- // | opacity:0.75,
- // | fontSize:"13pt"
- // | });
- // | });
-
- var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
- name = _floatAliases[name] ? "cssFloat" in n.style ? "cssFloat" : "styleFloat" : name;
- if(l == 3){
- return op ? _setOpacity(n, value) : n.style[name] = value; // Number
- }
- for(var x in name){
- style.set(node, x, name[x]);
- }
- return style.getComputedStyle(n);
- };
-
- return style;
-});
-
-},
-'dojo/dom-geometry':function(){
-define(["./sniff", "./_base/window","./dom", "./dom-style"],
- function(has, win, dom, style){
- // module:
- // dojo/dom-geometry
-
- // the result object
- var geom = {
- // summary:
- // This module defines the core dojo DOM geometry API.
- };
-
- // Box functions will assume this model.
- // On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.
- // Can be set to change behavior of box setters.
-
- // can be either:
- // "border-box"
- // "content-box" (default)
- geom.boxModel = "content-box";
-
- // We punt per-node box mode testing completely.
- // If anybody cares, we can provide an additional (optional) unit
- // that overrides existing code to include per-node box sensitivity.
-
- // Opera documentation claims that Opera 9 uses border-box in BackCompat mode.
- // but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.
- // IIRC, earlier versions of Opera did in fact use border-box.
- // Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.
-
- if(has("ie") /*|| has("opera")*/){
- // client code may have to adjust if compatMode varies across iframes
- geom.boxModel = document.compatMode == "BackCompat" ? "border-box" : "content-box";
- }
-
- geom.getPadExtents = function getPadExtents(/*DomNode*/ node, /*Object*/ computedStyle){
- // summary:
- // Returns object with special values specifically useful for node
- // fitting.
- // description:
- // Returns an object with `w`, `h`, `l`, `t` properties:
- // | l/t/r/b = left/top/right/bottom padding (respectively)
- // | w = the total of the left and right padding
- // | h = the total of the top and bottom padding
- // If 'node' has position, l/t forms the origin for child nodes.
- // The w/h are used for calculating boxes.
- // Normally application code will not need to invoke this
- // directly, and will use the ...box... functions instead.
- // node: DOMNode
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
- l = px(node, s.paddingLeft), t = px(node, s.paddingTop), r = px(node, s.paddingRight), b = px(node, s.paddingBottom);
- return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
- };
-
- var none = "none";
-
- geom.getBorderExtents = function getBorderExtents(/*DomNode*/ node, /*Object*/ computedStyle){
- // summary:
- // returns an object with properties useful for noting the border
- // dimensions.
- // description:
- // - l/t/r/b = the sum of left/top/right/bottom border (respectively)
- // - w = the sum of the left and right border
- // - h = the sum of the top and bottom border
- //
- // The w/h are used for calculating boxes.
- // Normally application code will not need to invoke this
- // directly, and will use the ...box... functions instead.
- // node: DOMNode
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var px = style.toPixelValue, s = computedStyle || style.getComputedStyle(node),
- l = s.borderLeftStyle != none ? px(node, s.borderLeftWidth) : 0,
- t = s.borderTopStyle != none ? px(node, s.borderTopWidth) : 0,
- r = s.borderRightStyle != none ? px(node, s.borderRightWidth) : 0,
- b = s.borderBottomStyle != none ? px(node, s.borderBottomWidth) : 0;
- return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
- };
-
- geom.getPadBorderExtents = function getPadBorderExtents(/*DomNode*/ node, /*Object*/ computedStyle){
- // summary:
- // Returns object with properties useful for box fitting with
- // regards to padding.
- // description:
- // - l/t/r/b = the sum of left/top/right/bottom padding and left/top/right/bottom border (respectively)
- // - w = the sum of the left and right padding and border
- // - h = the sum of the top and bottom padding and border
- //
- // The w/h are used for calculating boxes.
- // Normally application code will not need to invoke this
- // directly, and will use the ...box... functions instead.
- // node: DOMNode
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var s = computedStyle || style.getComputedStyle(node),
- p = geom.getPadExtents(node, s),
- b = geom.getBorderExtents(node, s);
- return {
- l: p.l + b.l,
- t: p.t + b.t,
- r: p.r + b.r,
- b: p.b + b.b,
- w: p.w + b.w,
- h: p.h + b.h
- };
- };
-
- geom.getMarginExtents = function getMarginExtents(node, computedStyle){
- // summary:
- // returns object with properties useful for box fitting with
- // regards to box margins (i.e., the outer-box).
- //
- // - l/t = marginLeft, marginTop, respectively
- // - w = total width, margin inclusive
- // - h = total height, margin inclusive
- //
- // The w/h are used for calculating boxes.
- // Normally application code will not need to invoke this
- // directly, and will use the ...box... functions instead.
- // node: DOMNode
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
- l = px(node, s.marginLeft), t = px(node, s.marginTop), r = px(node, s.marginRight), b = px(node, s.marginBottom);
- return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
- };
-
- // Box getters work in any box context because offsetWidth/clientWidth
- // are invariant wrt box context
- //
- // They do *not* work for display: inline objects that have padding styles
- // because the user agent ignores padding (it's bogus styling in any case)
- //
- // Be careful with IMGs because they are inline or block depending on
- // browser and browser mode.
-
- // Although it would be easier to read, there are not separate versions of
- // _getMarginBox for each browser because:
- // 1. the branching is not expensive
- // 2. factoring the shared code wastes cycles (function call overhead)
- // 3. duplicating the shared code wastes bytes
-
- geom.getMarginBox = function getMarginBox(/*DomNode*/ node, /*Object*/ computedStyle){
- // summary:
- // returns an object that encodes the width, height, left and top
- // positions of the node's margin box.
- // node: DOMNode
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var s = computedStyle || style.getComputedStyle(node), me = geom.getMarginExtents(node, s),
- l = node.offsetLeft - me.l, t = node.offsetTop - me.t, p = node.parentNode, px = style.toPixelValue, pcs;
- if(has("mozilla")){
- // Mozilla:
- // If offsetParent has a computed overflow != visible, the offsetLeft is decreased
- // by the parent's border.
- // We don't want to compute the parent's style, so instead we examine node's
- // computed left/top which is more stable.
- var sl = parseFloat(s.left), st = parseFloat(s.top);
- if(!isNaN(sl) && !isNaN(st)){
- l = sl;
- t = st;
- }else{
- // If child's computed left/top are not parseable as a number (e.g. "auto"), we
- // have no choice but to examine the parent's computed style.
- if(p && p.style){
- pcs = style.getComputedStyle(p);
- if(pcs.overflow != "visible"){
- l += pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
- t += pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
- }
- }
- }
- }else if(has("opera") || (has("ie") == 8 && !has("quirks"))){
- // On Opera and IE 8, offsetLeft/Top includes the parent's border
- if(p){
- pcs = style.getComputedStyle(p);
- l -= pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
- t -= pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
- }
- }
- return {l: l, t: t, w: node.offsetWidth + me.w, h: node.offsetHeight + me.h};
- };
-
- geom.getContentBox = function getContentBox(node, computedStyle){
- // summary:
- // Returns an object that encodes the width, height, left and top
- // positions of the node's content box, irrespective of the
- // current box model.
- // node: DOMNode
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- // clientWidth/Height are important since the automatically account for scrollbars
- // fallback to offsetWidth/Height for special cases (see #3378)
- node = dom.byId(node);
- var s = computedStyle || style.getComputedStyle(node), w = node.clientWidth, h,
- pe = geom.getPadExtents(node, s), be = geom.getBorderExtents(node, s);
- if(!w){
- w = node.offsetWidth;
- h = node.offsetHeight;
- }else{
- h = node.clientHeight;
- be.w = be.h = 0;
- }
- // On Opera, offsetLeft includes the parent's border
- if(has("opera")){
- pe.l += be.l;
- pe.t += be.t;
- }
- return {l: pe.l, t: pe.t, w: w - pe.w - be.w, h: h - pe.h - be.h};
- };
-
- // Box setters depend on box context because interpretation of width/height styles
- // vary wrt box context.
- //
- // The value of boxModel is used to determine box context.
- // boxModel can be set directly to change behavior.
- //
- // Beware of display: inline objects that have padding styles
- // because the user agent ignores padding (it's a bogus setup anyway)
- //
- // Be careful with IMGs because they are inline or block depending on
- // browser and browser mode.
- //
- // Elements other than DIV may have special quirks, like built-in
- // margins or padding, or values not detectable via computedStyle.
- // In particular, margins on TABLE do not seems to appear
- // at all in computedStyle on Mozilla.
-
- function setBox(/*DomNode*/ node, /*Number?*/ l, /*Number?*/ t, /*Number?*/ w, /*Number?*/ h, /*String?*/ u){
- // summary:
- // sets width/height/left/top in the current (native) box-model
- // dimensions. Uses the unit passed in u.
- // node:
- // DOM Node reference. Id string not supported for performance
- // reasons.
- // l:
- // left offset from parent.
- // t:
- // top offset from parent.
- // w:
- // width in current box model.
- // h:
- // width in current box model.
- // u:
- // unit measure to use for other measures. Defaults to "px".
- u = u || "px";
- var s = node.style;
- if(!isNaN(l)){
- s.left = l + u;
- }
- if(!isNaN(t)){
- s.top = t + u;
- }
- if(w >= 0){
- s.width = w + u;
- }
- if(h >= 0){
- s.height = h + u;
- }
- }
-
- function isButtonTag(/*DomNode*/ node){
- // summary:
- // True if the node is BUTTON or INPUT.type="button".
- return node.tagName.toLowerCase() == "button" ||
- node.tagName.toLowerCase() == "input" && (node.getAttribute("type") || "").toLowerCase() == "button"; // boolean
- }
-
- function usesBorderBox(/*DomNode*/ node){
- // summary:
- // True if the node uses border-box layout.
-
- // We could test the computed style of node to see if a particular box
- // has been specified, but there are details and we choose not to bother.
-
- // TABLE and BUTTON (and INPUT type=button) are always border-box by default.
- // If you have assigned a different box to either one via CSS then
- // box functions will break.
-
- return geom.boxModel == "border-box" || node.tagName.toLowerCase() == "table" || isButtonTag(node); // boolean
- }
-
- geom.setContentSize = function setContentSize(/*DomNode*/ node, /*Object*/ box, /*Object*/ computedStyle){
- // summary:
- // Sets the size of the node's contents, irrespective of margins,
- // padding, or borders.
- // node: DOMNode
- // box: Object
- // hash with optional "w", and "h" properties for "width", and "height"
- // respectively. All specified properties should have numeric values in whole pixels.
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var w = box.w, h = box.h;
- if(usesBorderBox(node)){
- var pb = geom.getPadBorderExtents(node, computedStyle);
- if(w >= 0){
- w += pb.w;
- }
- if(h >= 0){
- h += pb.h;
- }
- }
- setBox(node, NaN, NaN, w, h);
- };
-
- var nilExtents = {l: 0, t: 0, w: 0, h: 0};
-
- geom.setMarginBox = function setMarginBox(/*DomNode*/ node, /*Object*/ box, /*Object*/ computedStyle){
- // summary:
- // sets the size of the node's margin box and placement
- // (left/top), irrespective of box model. Think of it as a
- // passthrough to setBox that handles box-model vagaries for
- // you.
- // node: DOMNode
- // box: Object
- // hash with optional "l", "t", "w", and "h" properties for "left", "right", "width", and "height"
- // respectively. All specified properties should have numeric values in whole pixels.
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var s = computedStyle || style.getComputedStyle(node), w = box.w, h = box.h,
- // Some elements have special padding, margin, and box-model settings.
- // To use box functions you may need to set padding, margin explicitly.
- // Controlling box-model is harder, in a pinch you might set dojo/dom-geometry.boxModel.
- pb = usesBorderBox(node) ? nilExtents : geom.getPadBorderExtents(node, s),
- mb = geom.getMarginExtents(node, s);
- if(has("webkit")){
- // on Safari (3.1.2), button nodes with no explicit size have a default margin
- // setting an explicit size eliminates the margin.
- // We have to swizzle the width to get correct margin reading.
- if(isButtonTag(node)){
- var ns = node.style;
- if(w >= 0 && !ns.width){
- ns.width = "4px";
- }
- if(h >= 0 && !ns.height){
- ns.height = "4px";
- }
- }
- }
- if(w >= 0){
- w = Math.max(w - pb.w - mb.w, 0);
- }
- if(h >= 0){
- h = Math.max(h - pb.h - mb.h, 0);
- }
- setBox(node, box.l, box.t, w, h);
- };
-
- // =============================
- // Positioning
- // =============================
-
- geom.isBodyLtr = function isBodyLtr(/*Document?*/ doc){
- // summary:
- // Returns true if the current language is left-to-right, and false otherwise.
- // doc: Document?
- // Optional document to query. If unspecified, use win.doc.
- // returns: Boolean
-
- doc = doc || win.doc;
- return (win.body(doc).dir || doc.documentElement.dir || "ltr").toLowerCase() == "ltr"; // Boolean
- };
-
- geom.docScroll = function docScroll(/*Document?*/ doc){
- // summary:
- // Returns an object with {node, x, y} with corresponding offsets.
- // doc: Document?
- // Optional document to query. If unspecified, use win.doc.
- // returns: Object
-
- doc = doc || win.doc;
- var node = win.doc.parentWindow || win.doc.defaultView; // use UI window, not dojo.global window. TODO: use dojo/window::get() except for circular dependency problem
- return "pageXOffset" in node ? {x: node.pageXOffset, y: node.pageYOffset } :
- (node = has("quirks") ? win.body(doc) : doc.documentElement) &&
- {x: geom.fixIeBiDiScrollLeft(node.scrollLeft || 0, doc), y: node.scrollTop || 0 };
- };
-
- if(has("ie")){
- geom.getIeDocumentElementOffset = function getIeDocumentElementOffset(/*Document?*/ doc){
- // summary:
- // returns the offset in x and y from the document body to the
- // visual edge of the page for IE
- // doc: Document?
- // Optional document to query. If unspecified, use win.doc.
- // description:
- // The following values in IE contain an offset:
- // | event.clientX
- // | event.clientY
- // | node.getBoundingClientRect().left
- // | node.getBoundingClientRect().top
- // But other position related values do not contain this offset,
- // such as node.offsetLeft, node.offsetTop, node.style.left and
- // node.style.top. The offset is always (2, 2) in LTR direction.
- // When the body is in RTL direction, the offset counts the width
- // of left scroll bar's width. This function computes the actual
- // offset.
-
- //NOTE: assumes we're being called in an IE browser
-
- doc = doc || win.doc;
- var de = doc.documentElement; // only deal with HTML element here, position() handles body/quirks
-
- if(has("ie") < 8){
- var r = de.getBoundingClientRect(), // works well for IE6+
- l = r.left, t = r.top;
- if(has("ie") < 7){
- l += de.clientLeft; // scrollbar size in strict/RTL, or,
- t += de.clientTop; // HTML border size in strict
- }
- return {
- x: l < 0 ? 0 : l, // FRAME element border size can lead to inaccurate negative values
- y: t < 0 ? 0 : t
- };
- }else{
- return {
- x: 0,
- y: 0
- };
- }
- };
- }
-
- geom.fixIeBiDiScrollLeft = function fixIeBiDiScrollLeft(/*Integer*/ scrollLeft, /*Document?*/ doc){
- // summary:
- // In RTL direction, scrollLeft should be a negative value, but IE
- // returns a positive one. All codes using documentElement.scrollLeft
- // must call this function to fix this error, otherwise the position
- // will offset to right when there is a horizontal scrollbar.
- // scrollLeft: Number
- // doc: Document?
- // Optional document to query. If unspecified, use win.doc.
- // returns: Number
-
- // In RTL direction, scrollLeft should be a negative value, but IE
- // returns a positive one. All codes using documentElement.scrollLeft
- // must call this function to fix this error, otherwise the position
- // will offset to right when there is a horizontal scrollbar.
-
- doc = doc || win.doc;
- var ie = has("ie");
- if(ie && !geom.isBodyLtr(doc)){
- var qk = has("quirks"),
- de = qk ? win.body(doc) : doc.documentElement,
- pwin = win.global; // TODO: use winUtils.get(doc) after resolving circular dependency b/w dom-geometry.js and dojo/window.js
- if(ie == 6 && !qk && pwin.frameElement && de.scrollHeight > de.clientHeight){
- scrollLeft += de.clientLeft; // workaround ie6+strict+rtl+iframe+vertical-scrollbar bug where clientWidth is too small by clientLeft pixels
- }
- return (ie < 8 || qk) ? (scrollLeft + de.clientWidth - de.scrollWidth) : -scrollLeft; // Integer
- }
- return scrollLeft; // Integer
- };
-
- geom.position = function(/*DomNode*/ node, /*Boolean?*/ includeScroll){
- // summary:
- // Gets the position and size of the passed element relative to
- // the viewport (if includeScroll==false), or relative to the
- // document root (if includeScroll==true).
- //
- // description:
- // Returns an object of the form:
- // `{ x: 100, y: 300, w: 20, h: 15 }`.
- // If includeScroll==true, the x and y values will include any
- // document offsets that may affect the position relative to the
- // viewport.
- // Uses the border-box model (inclusive of border and padding but
- // not margin). Does not act as a setter.
- // node: DOMNode|String
- // includeScroll: Boolean?
- // returns: Object
-
- node = dom.byId(node);
- var db = win.body(node.ownerDocument),
- ret = node.getBoundingClientRect();
- ret = {x: ret.left, y: ret.top, w: ret.right - ret.left, h: ret.bottom - ret.top};
-
- if(has("ie") < 9){
- // On IE<9 there's a 2px offset that we need to adjust for, see dojo.getIeDocumentElementOffset()
- var offset = geom.getIeDocumentElementOffset(node.ownerDocument);
-
- // fixes the position in IE, quirks mode
- ret.x -= offset.x + (has("quirks") ? db.clientLeft + db.offsetLeft : 0);
- ret.y -= offset.y + (has("quirks") ? db.clientTop + db.offsetTop : 0);
- }
-
- // account for document scrolling
- // if offsetParent is used, ret value already includes scroll position
- // so we may have to actually remove that value if !includeScroll
- if(includeScroll){
- var scroll = geom.docScroll(node.ownerDocument);
- ret.x += scroll.x;
- ret.y += scroll.y;
- }
-
- return ret; // Object
- };
-
- // random "private" functions wildly used throughout the toolkit
-
- geom.getMarginSize = function getMarginSize(/*DomNode*/ node, /*Object*/ computedStyle){
- // summary:
- // returns an object that encodes the width and height of
- // the node's margin box
- // node: DOMNode|String
- // computedStyle: Object?
- // This parameter accepts computed styles object.
- // If this parameter is omitted, the functions will call
- // dojo/dom-style.getComputedStyle to get one. It is a better way, calling
- // dojo/dom-style.getComputedStyle once, and then pass the reference to this
- // computedStyle parameter. Wherever possible, reuse the returned
- // object of dojo/dom-style.getComputedStyle().
-
- node = dom.byId(node);
- var me = geom.getMarginExtents(node, computedStyle || style.getComputedStyle(node));
- var size = node.getBoundingClientRect();
- return {
- w: (size.right - size.left) + me.w,
- h: (size.bottom - size.top) + me.h
- };
- };
-
- geom.normalizeEvent = function(event){
- // summary:
- // Normalizes the geometry of a DOM event, normalizing the pageX, pageY,
- // offsetX, offsetY, layerX, and layerX properties
- // event: Object
- if(!("layerX" in event)){
- event.layerX = event.offsetX;
- event.layerY = event.offsetY;
- }
- if(!has("dom-addeventlistener")){
- // old IE version
- // FIXME: scroll position query is duped from dojo/_base/html to
- // avoid dependency on that entire module. Now that HTML is in
- // Base, we should convert back to something similar there.
- var se = event.target;
- var doc = (se && se.ownerDocument) || document;
- // DO NOT replace the following to use dojo/_base/window.body(), in IE, document.documentElement should be used
- // here rather than document.body
- var docBody = has("quirks") ? doc.body : doc.documentElement;
- var offset = geom.getIeDocumentElementOffset(doc);
- event.pageX = event.clientX + geom.fixIeBiDiScrollLeft(docBody.scrollLeft || 0, doc) - offset.x;
- event.pageY = event.clientY + (docBody.scrollTop || 0) - offset.y;
- }
- };
-
- // TODO: evaluate separate getters/setters for position and sizes?
-
- return geom;
-});
-
-},
-'dojo/dom-prop':function(){
-define(["exports", "./_base/kernel", "./sniff", "./_base/lang", "./dom", "./dom-style", "./dom-construct", "./_base/connect"],
- function(exports, dojo, has, lang, dom, style, ctr, conn){
- // module:
- // dojo/dom-prop
- // summary:
- // This module defines the core dojo DOM properties API.
-
- // TODOC: summary not showing up in output, see https://github.com/csnover/js-doc-parse/issues/42
-
- // =============================
- // Element properties Functions
- // =============================
-
- // helper to connect events
- var _evtHdlrMap = {}, _ctr = 0, _attrId = dojo._scopeName + "attrid";
- has.add('dom-textContent', function (global, doc, element) { return 'textContent' in element; });
-
- exports.names = {
- // properties renamed to avoid clashes with reserved words
- "class": "className",
- "for": "htmlFor",
- // properties written as camelCase
- tabindex: "tabIndex",
- readonly: "readOnly",
- colspan: "colSpan",
- frameborder: "frameBorder",
- rowspan: "rowSpan",
- textcontent: "textContent",
- valuetype: "valueType"
- };
-
- function getText(/*DOMNode*/node){
- // summary:
- // recursion method for get('textContent') to use. Gets text value for a node.
- // description:
- // Juse uses nodedValue so things like tags do not end up in
- // the text as any sort of line return.
- var text = "", ch = node.childNodes;
- for(var i = 0, n; n = ch[i]; i++){
- //Skip comments.
- if(n.nodeType != 8){
- if(n.nodeType == 1){
- text += getText(n);
- }else{
- text += n.nodeValue;
- }
- }
- }
- return text;
- }
-
- exports.get = function getProp(/*DOMNode|String*/ node, /*String*/ name){
- // summary:
- // Gets a property on an HTML element.
- // description:
- // Handles normalized getting of properties on DOM nodes.
- //
- // node: DOMNode|String
- // id or reference to the element to get the property on
- // name: String
- // the name of the property to get.
- // returns:
- // the value of the requested property or its default value
- //
- // example:
- // | // get the current value of the "foo" property on a node
- // | require(["dojo/dom-prop", "dojo/dom"], function(domProp, dom){
- // | domProp.get(dom.byId("nodeId"), "foo");
- // | // or we can just pass the id:
- // | domProp.get("nodeId", "foo");
- // | });
-
- node = dom.byId(node);
- var lc = name.toLowerCase(), propName = exports.names[lc] || name;
-
- if(propName == "textContent" && !has("dom-textContent")){
- return getText(node);
- }
-
- return node[propName]; // Anything
- };
-
- exports.set = function setProp(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
- // summary:
- // Sets a property on an HTML element.
- // description:
- // Handles normalized setting of properties on DOM nodes.
- //
- // When passing functions as values, note that they will not be
- // directly assigned to slots on the node, but rather the default
- // behavior will be removed and the new behavior will be added
- // using `dojo.connect()`, meaning that event handler properties
- // will be normalized and that some caveats with regards to
- // non-standard behaviors for onsubmit apply. Namely that you
- // should cancel form submission using `dojo.stopEvent()` on the
- // passed event object instead of returning a boolean value from
- // the handler itself.
- // node: DOMNode|String
- // id or reference to the element to set the property on
- // name: String|Object
- // the name of the property to set, or a hash object to set
- // multiple properties at once.
- // value: String?
- // The value to set for the property
- // returns:
- // the DOM node
- //
- // example:
- // | // use prop() to set the tab index
- // | require(["dojo/dom-prop"], function(domProp){
- // | domProp.set("nodeId", "tabIndex", 3);
- // | });
- //
- // example:
- // Set multiple values at once, including event handlers:
- // | require(["dojo/dom-prop"], function(domProp){
- // | domProp.set("formId", {
- // | "foo": "bar",
- // | "tabIndex": -1,
- // | "method": "POST",
- // | });
- // | });
-
- node = dom.byId(node);
- var l = arguments.length;
- if(l == 2 && typeof name != "string"){ // inline'd type check
- // the object form of setter: the 2nd argument is a dictionary
- for(var x in name){
- exports.set(node, x, name[x]);
- }
- return node; // DomNode
- }
- var lc = name.toLowerCase(), propName = exports.names[lc] || name;
- if(propName == "style" && typeof value != "string"){ // inline'd type check
- // special case: setting a style
- style.set(node, value);
- return node; // DomNode
- }
- if(propName == "innerHTML"){
- // special case: assigning HTML
- // the hash lists elements with read-only innerHTML on IE
- if(has("ie") && node.tagName.toLowerCase() in {col: 1, colgroup: 1,
- table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1}){
- ctr.empty(node);
- node.appendChild(ctr.toDom(value, node.ownerDocument));
- }else{
- node[propName] = value;
- }
- return node; // DomNode
- }
- if(propName == "textContent" && !has("dom-textContent")) {
- ctr.empty(node);
- node.appendChild(node.ownerDocument.createTextNode(value));
- return node;
- }
- if(lang.isFunction(value)){
- // special case: assigning an event handler
- // clobber if we can
- var attrId = node[_attrId];
- if(!attrId){
- attrId = _ctr++;
- node[_attrId] = attrId;
- }
- if(!_evtHdlrMap[attrId]){
- _evtHdlrMap[attrId] = {};
- }
- var h = _evtHdlrMap[attrId][propName];
- if(h){
- //h.remove();
- conn.disconnect(h);
- }else{
- try{
- delete node[propName];
- }catch(e){}
- }
- // ensure that event objects are normalized, etc.
- if(value){
- //_evtHdlrMap[attrId][propName] = on(node, propName, value);
- _evtHdlrMap[attrId][propName] = conn.connect(node, propName, value);
- }else{
- node[propName] = null;
- }
- return node; // DomNode
- }
- node[propName] = value;
- return node; // DomNode
- };
-});
-
-},
-'dojo/when':function(){
-define([
- "./Deferred",
- "./promise/Promise"
-], function(Deferred, Promise){
- "use strict";
-
- // module:
- // dojo/when
-
- return function when(valueOrPromise, callback, errback, progback){
- // summary:
- // Transparently applies callbacks to values and/or promises.
- // description:
- // Accepts promises but also transparently handles non-promises. If no
- // callbacks are provided returns a promise, regardless of the initial
- // value. Foreign promises are converted.
- //
- // If callbacks are provided and the initial value is not a promise,
- // the callback is executed immediately with no error handling. Returns
- // a promise if the initial value is a promise, or the result of the
- // callback otherwise.
- // valueOrPromise:
- // Either a regular value or an object with a `then()` method that
- // follows the Promises/A specification.
- // callback: Function?
- // Callback to be invoked when the promise is resolved, or a non-promise
- // is received.
- // errback: Function?
- // Callback to be invoked when the promise is rejected.
- // progback: Function?
- // Callback to be invoked when the promise emits a progress update.
- // returns: dojo/promise/Promise
- // Promise, or if a callback is provided, the result of the callback.
-
- var receivedPromise = valueOrPromise && typeof valueOrPromise.then === "function";
- var nativePromise = receivedPromise && valueOrPromise instanceof Promise;
-
- if(!receivedPromise){
- if(arguments.length > 1){
- return callback ? callback(valueOrPromise) : valueOrPromise;
- }else{
- return new Deferred().resolve(valueOrPromise);
- }
- }else if(!nativePromise){
- var deferred = new Deferred(valueOrPromise.cancel);
- valueOrPromise.then(deferred.resolve, deferred.reject, deferred.progress);
- valueOrPromise = deferred.promise;
- }
-
- if(callback || errback || progback){
- return valueOrPromise.then(callback, errback, progback);
- }
- return valueOrPromise;
- };
-});
-
-},
-'dojo/dom-attr':function(){
-define(["exports", "./sniff", "./_base/lang", "./dom", "./dom-style", "./dom-prop"],
- function(exports, has, lang, dom, style, prop){
- // module:
- // dojo/dom-attr
- // summary:
- // This module defines the core dojo DOM attributes API.
-
- // TODOC: summary not showing up in output see https://github.com/csnover/js-doc-parse/issues/42
-
- // =============================
- // Element attribute Functions
- // =============================
-
- // This module will be obsolete soon. Use dojo/prop instead.
-
- // dojo/dom-attr.get() should conform to http://www.w3.org/TR/DOM-Level-2-Core/
-
- // attribute-related functions (to be obsolete soon)
- var forcePropNames = {
- innerHTML: 1,
- textContent:1,
- className: 1,
- htmlFor: has("ie"),
- value: 1
- },
- attrNames = {
- // original attribute names
- classname: "class",
- htmlfor: "for",
- // for IE
- tabindex: "tabIndex",
- readonly: "readOnly"
- };
-
- function _hasAttr(node, name){
- var attr = node.getAttributeNode && node.getAttributeNode(name);
- return attr && attr.specified; // Boolean
- }
-
- // There is a difference in the presence of certain properties and their default values
- // between browsers. For example, on IE "disabled" is present on all elements,
- // but it is value is "false"; "tabIndex" of
returns 0 by default on IE, yet other browsers
- // can return -1.
-
- exports.has = function hasAttr(/*DOMNode|String*/ node, /*String*/ name){
- // summary:
- // Returns true if the requested attribute is specified on the
- // given element, and false otherwise.
- // node: DOMNode|String
- // id or reference to the element to check
- // name: String
- // the name of the attribute
- // returns: Boolean
- // true if the requested attribute is specified on the
- // given element, and false otherwise
-
- var lc = name.toLowerCase();
- return forcePropNames[prop.names[lc] || name] || _hasAttr(dom.byId(node), attrNames[lc] || name); // Boolean
- };
-
- exports.get = function getAttr(/*DOMNode|String*/ node, /*String*/ name){
- // summary:
- // Gets an attribute on an HTML element.
- // description:
- // Handles normalized getting of attributes on DOM Nodes.
- // node: DOMNode|String
- // id or reference to the element to get the attribute on
- // name: String
- // the name of the attribute to get.
- // returns:
- // the value of the requested attribute or null if that attribute does not have a specified or
- // default value;
- //
- // example:
- // | // get the current value of the "foo" attribute on a node
- // | require(["dojo/dom-attr", "dojo/dom"], function(domAttr, dom){
- // | domAttr.get(dom.byId("nodeId"), "foo");
- // | // or we can just pass the id:
- // | domAttr.get("nodeId", "foo");
- // | });
- // |
-
- node = dom.byId(node);
- var lc = name.toLowerCase(),
- propName = prop.names[lc] || name,
- forceProp = forcePropNames[propName],
- value = node[propName]; // should we access this attribute via a property or via getAttribute()?
-
- if(forceProp && typeof value != "undefined"){
- // node's property
- return value; // Anything
- }
-
- if(propName == "textContent"){
- return prop.get(node, propName);
- }
-
- if(propName != "href" && (typeof value == "boolean" || lang.isFunction(value))){
- // node's property
- return value; // Anything
- }
- // node's attribute
- // we need _hasAttr() here to guard against IE returning a default value
- var attrName = attrNames[lc] || name;
- return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
- };
-
- exports.set = function setAttr(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
- // summary:
- // Sets an attribute on an HTML element.
- // description:
- // Handles normalized setting of attributes on DOM Nodes.
- //
- // When passing functions as values, note that they will not be
- // directly assigned to slots on the node, but rather the default
- // behavior will be removed and the new behavior will be added
- // using `dojo.connect()`, meaning that event handler properties
- // will be normalized and that some caveats with regards to
- // non-standard behaviors for onsubmit apply. Namely that you
- // should cancel form submission using `dojo.stopEvent()` on the
- // passed event object instead of returning a boolean value from
- // the handler itself.
- // node: DOMNode|String
- // id or reference to the element to set the attribute on
- // name: String|Object
- // the name of the attribute to set, or a hash of key-value pairs to set.
- // value: String?
- // the value to set for the attribute, if the name is a string.
- // returns:
- // the DOM node
- //
- // example:
- // | // use attr() to set the tab index
- // | require(["dojo/dom-attr"], function(domAttr){
- // | domAttr.set("nodeId", "tabIndex", 3);
- // | });
- //
- // example:
- // Set multiple values at once, including event handlers:
- // | require(["dojo/dom-attr"],
- // | function(domAttr){
- // | domAttr.set("formId", {
- // | "foo": "bar",
- // | "tabIndex": -1,
- // | "method": "POST"
- // | }
- // | });
-
- node = dom.byId(node);
- if(arguments.length == 2){ // inline'd type check
- // the object form of setter: the 2nd argument is a dictionary
- for(var x in name){
- exports.set(node, x, name[x]);
- }
- return node; // DomNode
- }
- var lc = name.toLowerCase(),
- propName = prop.names[lc] || name,
- forceProp = forcePropNames[propName];
- if(propName == "style" && typeof value != "string"){ // inline'd type check
- // special case: setting a style
- style.set(node, value);
- return node; // DomNode
- }
- if(forceProp || typeof value == "boolean" || lang.isFunction(value)){
- return prop.set(node, name, value);
- }
- // node's attribute
- node.setAttribute(attrNames[lc] || name, value);
- return node; // DomNode
- };
-
- exports.remove = function removeAttr(/*DOMNode|String*/ node, /*String*/ name){
- // summary:
- // Removes an attribute from an HTML element.
- // node: DOMNode|String
- // id or reference to the element to remove the attribute from
- // name: String
- // the name of the attribute to remove
-
- dom.byId(node).removeAttribute(attrNames[name.toLowerCase()] || name);
- };
-
- exports.getNodeProp = function getNodeProp(/*DomNode|String*/ node, /*String*/ name){
- // summary:
- // Returns an effective value of a property or an attribute.
- // node: DOMNode|String
- // id or reference to the element to remove the attribute from
- // name: String
- // the name of the attribute
- // returns:
- // the value of the attribute
-
- node = dom.byId(node);
- var lc = name.toLowerCase(), propName = prop.names[lc] || name;
- if((propName in node) && propName != "href"){
- // node's property
- return node[propName]; // Anything
- }
- // node's attribute
- var attrName = attrNames[lc] || name;
- return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
- };
-});
-
-},
-'dojo/dom-construct':function(){
-define(["exports", "./_base/kernel", "./sniff", "./_base/window", "./dom", "./dom-attr"],
- function(exports, dojo, has, win, dom, attr){
- // module:
- // dojo/dom-construct
- // summary:
- // This module defines the core dojo DOM construction API.
-
- // TODOC: summary not showing up in output, see https://github.com/csnover/js-doc-parse/issues/42
-
- // support stuff for toDom()
- var tagWrap = {
- option: ["select"],
- tbody: ["table"],
- thead: ["table"],
- tfoot: ["table"],
- tr: ["table", "tbody"],
- td: ["table", "tbody", "tr"],
- th: ["table", "thead", "tr"],
- legend: ["fieldset"],
- caption: ["table"],
- colgroup: ["table"],
- col: ["table", "colgroup"],
- li: ["ul"]
- },
- reTag = /<\s*([\w\:]+)/,
- masterNode = {}, masterNum = 0,
- masterName = "__" + dojo._scopeName + "ToDomId";
-
- // generate start/end tag strings to use
- // for the injection for each special tag wrap case.
- for(var param in tagWrap){
- if(tagWrap.hasOwnProperty(param)){
- var tw = tagWrap[param];
- tw.pre = param == "option" ? '