Añade dijit, sockjs y stomp-ws como librerías

define([

	"require",			// require.toUrl

	"./main",	// to export dijit.BackgroundIframe

	"dojo/_base/config",

	"dojo/dom-construct", // domConstruct.create

	"dojo/dom-style", // domStyle.set

	"dojo/_base/lang", // lang.extend lang.hitch

	"dojo/on",

	"dojo/sniff" // has("ie"), has("trident"), has("quirks")

], function(require, dijit, config, domConstruct, domStyle, lang, on, has){

	// module:

	//		dijit/BackgroundIFrame

	// Flag for whether to create background iframe behind popups like Menus and Dialog.

	// A background iframe is useful to prevent problems with popups appearing behind applets/pdf files,

	// and is also useful on older versions of IE (IE6 and IE7) to prevent the "bleed through select" problem.

	// By default, it's enabled for IE6-10, excluding Windows Phone 8,

	// and it's also enabled for IE11 on Windows 7 and Windows 2008 Server.

	// TODO: For 2.0, make this false by default.  Also, possibly move definition to has.js so that this module can be

	// conditionally required via  dojo/has!bgIfame?dijit/BackgroundIframe

	has.add("config-bgIframe",

		(has("ie") && !/IEMobile\/10\.0/.test(navigator.userAgent)) || // No iframe on WP8, to match 1.9 behavior

		(has("trident") && /Windows NT 6.[01]/.test(navigator.userAgent)));

	var _frames = new function(){

		// summary:

		//		cache of iframes

		var queue = [];

		this.pop = function(){

			var iframe;

			if(queue.length){

				iframe = queue.pop();

				iframe.style.display="";

			}else{

				// transparency needed for DialogUnderlay and for tooltips on IE (to see screen near connector)

				if(has("ie") < 9){

					var burl = config["dojoBlankHtmlUrl"] || require.toUrl("dojo/resources/blank.html") || "javascript:\"\"";

					var html="<iframe src='" + burl + "' role='presentation'"

						+ " style='position: absolute; left: 0px; top: 0px;"

						+ "z-index: -1; filter:Alpha(Opacity=\"0\");'>";

					iframe = document.createElement(html);

				}else{

					iframe = domConstruct.create("iframe");

					iframe.src = 'javascript:""';

					iframe.className = "dijitBackgroundIframe";

					iframe.setAttribute("role", "presentation");

					domStyle.set(iframe, "opacity", 0.1);

				}

				iframe.tabIndex = -1; // Magic to prevent iframe from getting focus on tab keypress - as style didn't work.

			}

			return iframe;

		};

		this.push = function(iframe){

			iframe.style.display="none";

			queue.push(iframe);

		}

	}();

	dijit.BackgroundIframe = function(/*DomNode*/ node){

		// summary:

		//		For IE/FF z-index shenanigans. id attribute is required.

		//

		// description:

		//		new dijit.BackgroundIframe(node).

		//

		//		Makes a background iframe as a child of node, that fills

		//		area (and position) of node

		if(!node.id){ throw new Error("no id"); }

		if(has("config-bgIframe")){

			var iframe = (this.iframe = _frames.pop());

			node.appendChild(iframe);

			if(has("ie")<7 || has("quirks")){

				this.resize(node);

				this._conn = on(node, 'resize', lang.hitch(this, "resize", node));

			}else{

				domStyle.set(iframe, {

					width: '100%',

					height: '100%'

				});

			}

		}

	};

	lang.extend(dijit.BackgroundIframe, {

		resize: function(node){

			// summary:

			//		Resize the iframe so it's the same size as node.

			//		Needed on IE6 and IE/quirks because height:100% doesn't work right.

			if(this.iframe){

				domStyle.set(this.iframe, {

					width: node.offsetWidth + 'px',

					height: node.offsetHeight + 'px'

				});

			}

		},

		destroy: function(){

			// summary:

			//		destroy the iframe

			if(this._conn){

				this._conn.remove();

				this._conn = null;

			}

			if(this.iframe){

				this.iframe.parentNode.removeChild(this.iframe);

				_frames.push(this.iframe);

				delete this.iframe;

			}

		}

	});

	return dijit.BackgroundIframe;

});

_Do you have a contribution?  We welcome contributions, but please ensure that you read the following information

before issuing a pull request.  Also refer back to this document as a checklist before issuing your pull request.

This will save time for everyone._

# Before You Start

## Understanding the Basics

If you don't understand what a *pull request* is, or how to submit one, please refer to the [help documentation][]

provided by GitHub.

## Is It Really a Support Issue

If you aren't sure if your contribution is needed or necessary, please visit the [support forum][] before attempting to

submit a pull request or a ticket.

## Search Dojo Toolkit's Bug Database

We require every commit to be tracked via our [bug database][].  It is useful, before you get too far, that you have

checked that your issue isn't already known, otherwise addressed?  If you think it is a valid defect or enhancement,

please open a new ticket before submitting your pull request.

## Discuss Non-Trivial Contributions with the Committers

If your desired contribution is more than a non-trivial fix, you should discuss it on the

[contributor's mailing list][dojo-contrib].  If you currently are not a member, you can request to be added.

## Contributor License Agreement

We require all contributions, to be covered under the Dojo Foundation's [Contributor License Agreement][cla].  This can

be done electronically and essentially ensures that you are making it clear that your contributions are your

contributions, you have the legal right to contribute and you are transferring the copyright of your works to the Dojo

Foundation.

If you are an unfamiliar contributor to the committer assessing your pull request, it is best to make it clear how

you are covered by a CLA in the notes of the pull request.  The committer will [verify][claCheck] your status.

If your GitHub user id you are submitting your pull request from differs from the Dojo Community ID or e-mail address

which you have signed your CLA under, you should specifically note what you have your CLA filed under (and for CCLA

that you are listed under your companies authorised contributors).

# Submitting a Pull Request

The following are the general steps you should follow in creating a pull request.  Subsequent pull requests only need

to follow step 3 and beyond:

1. Fork the repository on GitHub

2. Clone the forked repository to your machine

3. Create a "feature" branch in your local repository

4. Make your changes and commit them to your local repository

5. Rebase and push your commits to your GitHub remote fork/repository

6. Issue a Pull Request to the official repository

7. Your Pull Request is reviewed by a committer and merged into the repository

*Note* While there are other ways to accomplish the steps using other tools, the examples here will assume the most

actions will be performed via the `git` command line.

## 1. Fork the Repository

When logged into your GitHub account, and you are viewing one of the main repositories, you will see the *Fork* button.

Clicking this button will show you which repositories your can fork to.  Choose your own account.  Once the process

finishes, you will have your own repository that is "forked" from the GitHub one.

Forking is a GitHub term and not a git term.  Git is a wholly distributed source control system and simply worries

about local and remote repositories and allows you to manage your code against them.  GitHub then adds this additional

layer of structure of how repositories can relate to each other.

## 2. Clone the Forked Repository

Once you have successfully forked your repository, you will need to clone it locally to your machine:

```bash

$ git clone --recursive git@github.com:username/dijit.git

```

This will clone your fork to your current path in a directory named `dijit`.

It is important that you clone recursively for ``dojox``, ``demos`` or ``util``because some of the code is contained in

submodules.  You won't be able to submit your changes to the repositories that way though.  If you are working on any of

these sub-projects, you should contact those project leads to see if their workflow differs.

You should also setup the `upstream` repository.  This will allow you to take changes from the "master" repository

and merge them into your local clone and then push them to your GitHub fork:

```bash

$ cd dojo

$ git remote add upstream git@github.com:dojo/dijit.git

$ git fetch upstream

```

Then you can retrieve upstream changes and rebase on them into your code like this:

```bash

$ git pull --rebase upstream master

```

For more information on maintaining a fork, please see the GitHub Help article [Fork a Repo][] and information on

[rebasing][] from git.

## 3. Create a Branch

The easiest workflow is to keep your master branch in sync with the upstream branch and do not locate any of your own

commits in that branch.  When you want to work on a new feature, you then ensure you are on the master branch and create

a new branch from there.  While the name of the branch can be anything, it can often be easy to use the ticket number

you might be working on.  For example:

```bash

$ git checkout -b t12345 master

Switched to a new branch 't12345'

```

You will then be on the feature branch.  You can verify what branch you are on like this:

```bash

$ git status

# On branch t12345

nothing to commit, working directory clean

```

## 4. Make Changes and Commit

Now you just need to make your changes.  Once you have finished your changes (and tested them) you need to commit them

to your local repository (assuming you have staged your changes for committing):

```bash

$ git status

# On branch t12345

# Changes to be committed:

#   (use "git reset HEAD <file>..." to unstage)

#

#        modified:   somefile.js

#

$ git commit -m "Corrects some defect, fixes #12345, refs #12346"

[t12345 0000000] Corrects some defect, fixes #12345, refs #12346

 1 file changed, 2 insertions(+), 2 deletions(-)

```

## 5. Rebase and Push Changes

If you have been working on your contribution for a while, the upstream repository may have changed.  You may want to

ensure your work is on top of the latest changes so your pull request can be applied cleanly:

```bash

$ git pull --rebase upstream master

```

When you are ready to push your commit to your GitHub repository for the first time on this branch you would do the

following:

```bash

$ git push -u origin t12345

```

After the first time, you simply need to do:

```bash

$ git push

```

## 6. Issue a Pull Request

In order to have your commits merged into the main repository, you need to create a pull request.  The instructions for

this can be found in the GitHub Help Article [Creating a Pull Request][].  Essentially you do the following:

1. Go to the site for your repository.

2. Click the Pull Request button.

3. Select the feature branch from your repository.

4. Enter a title and description of your pull request mentioning the corresponding [bug database][] ticket in the description.

5. Review the commit and files changed tabs.

6. Click `Send Pull Request`

You will get notified about the status of your pull request based on your GitHub settings.

## 7. Request is Reviewed and Merged

Your request will be reviewed.  It may be merged directly, or you may receive feedback or questions on your pull

request.

# What Makes a Successful Pull Request?

Having your contribution accepted is more than just the mechanics of getting your contribution into a pull request,

there are several other things that are expected when contributing to the Dojo Toolkit which are covered below.

## Coding Style and Linting

Dojo has a very specific [coding style][styleguide].  All pull requests should adhere to this.

## Inline Documentation

Dojo has an inline API documentation called [DojoDoc][].  Any pull request should ensure it has updated the inline

documentation appropriately or added the appropriate inline documentation.

## Test Cases

If the pull request changes the functional behaviour or is fixing a defect, the unit test cases should be modified to

reflect this.  The committer reviewing your pull request is likely to request the appropriate changes in the test

cases.  Dojo utilises [Intern][] for all new tests, and has legacy support for its previous generation test harness called [D.O.H.][] and is available as part of the [dojo/util][] repository. All new tests should be authored using Intern.

It is expected that you will have tested your changes against the existing test cases and appropriate platforms prior to

submitting your pull request.

## Licensing

All of your submissions are licensed under a dual "New" BSD/AFL license.

## Expect Discussion and Rework

Unless you have been working with contributing to Dojo for a while, expect a significant amount of feedback on your

pull requests.  We are a very passionate community and even the committers often will provide robust feedback to each

other about their code.  Don't be offended by such feedback or feel that your contributions aren't welcome, it is just

that we are quite passionate and Dojo has a long history with many things that are the "Dojo-way" which may be

unfamiliar to those who are just starting to contribute.

[help documentation]: http://help.github.com/send-pull-requests

[bug database]: http://bugs.dojotoolkit.org/

[support forum]: http://dojotoolkit.org/community/

[dojo-contrib]: http://mail.dojotoolkit.org/mailman/listinfo/dojo-contributors

[cla]: http://dojofoundation.org/about/cla

[claCheck]: http://dojofoundation.org/about/claCheck

[Creating a Pull Request]: https://help.github.com/articles/creating-a-pull-request

[Fork a Repo]: https://help.github.com/articles/fork-a-repo

[Intern]: http://theintern.io/

[styleguide]: http://dojotoolkit.org/reference-guide/developer/styleguide.html

[DojoDoc]: http://dojotoolkit.org/reference-guide/developer/markup.html

[D.O.H.]: http://dojotoolkit.org/reference-guide/util/doh.html

[dojo/util]: https://github.com/dojo/util

[interactive rebase]: http://git-scm.com/book/en/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages

[rebasing]: http://git-scm.com/book/en/Git-Branching-Rebasing

define([

	"dojo/_base/array", // array.map

	"dojo/date",

	"dojo/date/locale",

	"dojo/_base/declare", // declare

	"dojo/dom-attr", // domAttr.get

	"dojo/dom-class", // domClass.add domClass.contains domClass.remove domClass.toggle

	"dojo/dom-construct",	// create

	"dojo/_base/kernel", // kernel.deprecated

	"dojo/keys", // keys

	"dojo/_base/lang", // lang.hitch

	"dojo/on",

	"dojo/sniff", // has("ie")

	"./CalendarLite",

	"./_Widget",

	"./_CssStateMixin",

	"./_TemplatedMixin",

	"./form/DropDownButton"

], function(array, date, local, declare, domAttr, domClass, domConstruct, kernel, keys, lang, on, has,

			CalendarLite, _Widget, _CssStateMixin, _TemplatedMixin, DropDownButton){

	// module:

	//		dijit/Calendar

	// _Widget for deprecated methods like setAttribute()

	var Calendar = declare("dijit.Calendar", [CalendarLite, _Widget, _CssStateMixin], {

		// summary:

		//		A simple GUI for choosing a date in the context of a monthly calendar.

		//

		// description:

		//		See CalendarLite for general description.   Calendar extends CalendarLite, adding:

		//

		//		- month drop down list

		//		- keyboard navigation

		//		- CSS classes for hover/mousepress on date, month, and year nodes

		//		- support of deprecated methods (will be removed in 2.0)

		baseClass: "dijitCalendar",

		// Set node classes for various mouse events, see dijit._CssStateMixin for more details

		cssStateNodes: {

			"decrementMonth": "dijitCalendarArrow",

			"incrementMonth": "dijitCalendarArrow",

			"previousYearLabelNode": "dijitCalendarPreviousYear",

			"nextYearLabelNode": "dijitCalendarNextYear"

		},

		setValue: function(/*Date*/ value){

			// summary:

			//		Deprecated.   Use set('value', ...) instead.

			// tags:

			//		deprecated

			kernel.deprecated("dijit.Calendar:setValue() is deprecated.  Use set('value', ...) instead.", "", "2.0");

			this.set('value', value);

		},

		_createMonthWidget: function(){

			// summary:

			//		Creates the drop down button that displays the current month and lets user pick a new one

			return new Calendar._MonthDropDownButton({

				id: this.id + "_mddb",

				tabIndex: -1,

				onMonthSelect: lang.hitch(this, "_onMonthSelect"),

				lang: this.lang,

				dateLocaleModule: this.dateLocaleModule

			}, this.monthNode);

		},

		postCreate: function(){

			this.inherited(arguments);

			// Events specific to Calendar, not used in CalendarLite

			this.own(

				on(this.domNode, "keydown", lang.hitch(this, "_onKeyDown")),

				on(this.dateRowsNode, "mouseover", lang.hitch(this, "_onDayMouseOver")),

				on(this.dateRowsNode, "mouseout", lang.hitch(this, "_onDayMouseOut")),

				on(this.dateRowsNode, "mousedown", lang.hitch(this, "_onDayMouseDown")),

				on(this.dateRowsNode, "mouseup", lang.hitch(this, "_onDayMouseUp"))

			);

		},

		_onMonthSelect: function(/*Number*/ newMonth){

			// summary:

			//		Handler for when user selects a month from the drop down list

			// tags:

			//		protected

			// move to selected month, bounding by the number of days in the month

			// (ex: jan 31 --> feb 28, not feb 31)

			var date = new this.dateClassObj(this.currentFocus);

			date.setDate(1);

			date.setMonth(newMonth);

			var daysInMonth = this.dateModule.getDaysInMonth(date);

			var currentDate = this.currentFocus.getDate();

			date.setDate(Math.min(currentDate, daysInMonth));

			this._setCurrentFocusAttr(date);

		},

		_onDayMouseOver: function(/*Event*/ evt){

			// summary:

			//		Handler for mouse over events on days, sets hovered style

			// tags:

			//		protected

			// event can occur on <td> or the <span> inside the td,

			// set node to the <td>.

			var node =

				domClass.contains(evt.target, "dijitCalendarDateLabel") ?

					evt.target.parentNode :

					evt.target;

			if(node && (

				(node.dijitDateValue && !domClass.contains(node, "dijitCalendarDisabledDate"))

					|| node == this.previousYearLabelNode || node == this.nextYearLabelNode

				)){

				domClass.add(node, "dijitCalendarHoveredDate");

				this._currentNode = node;

			}

		},

		_onDayMouseOut: function(/*Event*/ evt){

			// summary:

			//		Handler for mouse out events on days, clears hovered style

			// tags:

			//		protected

			if(!this._currentNode){

				return;

			}

			// if mouse out occurs moving from <td> to <span> inside <td>, ignore it

			if(evt.relatedTarget && evt.relatedTarget.parentNode == this._currentNode){

				return;

			}

			var cls = "dijitCalendarHoveredDate";

			if(domClass.contains(this._currentNode, "dijitCalendarActiveDate")){

				cls += " dijitCalendarActiveDate";

			}

			domClass.remove(this._currentNode, cls);

			this._currentNode = null;

		},

		_onDayMouseDown: function(/*Event*/ evt){

			var node = evt.target.parentNode;

			if(node && node.dijitDateValue && !domClass.contains(node, "dijitCalendarDisabledDate")){

				domClass.add(node, "dijitCalendarActiveDate");

				this._currentNode = node;

			}

		},

		_onDayMouseUp: function(/*Event*/ evt){

			var node = evt.target.parentNode;

			if(node && node.dijitDateValue){

				domClass.remove(node, "dijitCalendarActiveDate");

			}

		},

		handleKey: function(/*Event*/ evt){

			// summary:

			//		Provides keyboard navigation of calendar.

			// description:

			//		Called from _onKeyDown() to handle keydown on a stand alone Calendar,

			//		and also from `dijit/form/_DateTimeTextBox` to pass a keydown event

			//		from the `dijit/form/DateTextBox` to be handled in this widget

			// returns:

			//		False if the key was recognized as a navigation key,

			//		to indicate that the event was handled by Calendar and shouldn't be propagated

			// tags:

			//		protected

			var increment = -1,

				interval,

				newValue = this.currentFocus;

			switch(evt.keyCode){

				case keys.RIGHT_ARROW:

					increment = 1;

				//fallthrough...

				case keys.LEFT_ARROW:

					interval = "day";

					if(!this.isLeftToRight()){

						increment *= -1;

					}

					break;

				case keys.DOWN_ARROW:

					increment = 1;

				//fallthrough...

				case keys.UP_ARROW:

					interval = "week";

					break;

				case keys.PAGE_DOWN:

					increment = 1;

				//fallthrough...

				case keys.PAGE_UP:

					interval = evt.ctrlKey || evt.altKey ? "year" : "month";

					break;

				case keys.END:

					// go to the next month

					newValue = this.dateModule.add(newValue, "month", 1);

					// subtract a day from the result when we're done

					interval = "day";

				//fallthrough...

				case keys.HOME:

					newValue = new this.dateClassObj(newValue);

					newValue.setDate(1);

					break;

				default:

					return true;

			}

			if(interval){

				newValue = this.dateModule.add(newValue, interval, increment);

			}

			this._setCurrentFocusAttr(newValue);

			return false;

		},

		_onKeyDown: function(/*Event*/ evt){

			// summary:

			//		For handling keydown events on a stand alone calendar

			if(!this.handleKey(evt)){

				evt.stopPropagation();

				evt.preventDefault();

			}

		},

		onValueSelected: function(/*Date*/ /*===== date =====*/){

			// summary:

			//		Deprecated.   Notification that a date cell was selected.  It may be the same as the previous value.

			// description:

			//		Formerly used by `dijit/form/_DateTimeTextBox` (and thus `dijit/form/DateTextBox`)

			//		to get notification when the user has clicked a date.  Now onExecute() (above) is used.

			// tags:

			//		protected

		},

		onChange: function(value){

			this.onValueSelected(value);	// remove in 2.0

		},

		getClassForDate: function(/*===== dateObject, locale =====*/){

			// summary:

			//		May be overridden to return CSS classes to associate with the date entry for the given dateObject,

			//		for example to indicate a holiday in specified locale.

			// dateObject: Date

			// locale: String?

			// tags:

			//		extension

			/*=====

			 return ""; // String

			 =====*/

		}

	});

	Calendar._MonthDropDownButton = declare("dijit.Calendar._MonthDropDownButton", DropDownButton, {

		// summary:

		//		DropDownButton for the current month.    Displays name of current month

		//		and a list of month names in the drop down

		onMonthSelect: function(){

		},

		postCreate: function(){

			this.inherited(arguments);

			this.dropDown = new Calendar._MonthDropDown({

				id: this.id + "_mdd", //do not change this id because it is referenced in the template

				onChange: this.onMonthSelect

			});

		},

		_setMonthAttr: function(month){

			// summary:

			//		Set the current month to display as a label

			var monthNames = this.dateLocaleModule.getNames('months', 'wide', 'standAlone', this.lang, month);

			this.dropDown.set("months", monthNames);

			// Set name of current month and also fill in spacer element with all the month names

			// (invisible) so that the maximum width will affect layout.   But not on IE6 because then

			// the center <TH> overlaps the right <TH> (due to a browser bug).

			this.containerNode.innerHTML =

				(has("ie") == 6 ? "" : "<div class='dijitSpacer'>" + this.dropDown.domNode.innerHTML + "</div>") +

					"<div class='dijitCalendarMonthLabel dijitCalendarCurrentMonthLabel'>" + monthNames[month.getMonth()] + "</div>";

		}

	});

	Calendar._MonthDropDown = declare("dijit.Calendar._MonthDropDown", [_Widget, _TemplatedMixin, _CssStateMixin], {

		// summary:

		//		The list-of-months drop down from the MonthDropDownButton

		// months: String[]

		//		List of names of months, possibly w/some undefined entries for Hebrew leap months

		//		(ex: ["January", "February", undefined, "April", ...])

		months: [],

		baseClass: "dijitCalendarMonthMenu dijitMenu",

		templateString: "<div data-dojo-attach-event='ondijitclick:_onClick'></div>",

		_setMonthsAttr: function(/*String[]*/ months){

			this.domNode.innerHTML = "";

			array.forEach(months, function(month, idx){

				var div = domConstruct.create("div", {

					className: "dijitCalendarMonthLabel",

					month: idx,

					innerHTML: month

				}, this.domNode);

				div._cssState = "dijitCalendarMonthLabel";	// trigger _CSSStateMixin magic; property, not attribute.

			}, this);

		},

		_onClick: function(/*Event*/ evt){

			this.onChange(domAttr.get(evt.target, "month"));

		},

		onChange: function(/*Number*/ /*===== month =====*/){

			// summary:

			//		Callback when month is selected from drop down

		}

	});

	return Calendar;

});