/*
* This file has been generated to support Visual Studio IntelliSense.
* You should not use this file at runtime inside the browser--it is only
* intended to be used only for design-time IntelliSense. Please use the
* standard jQuery library for all production use.
*
* Comment version: 1.7.2
*/
/*!
* jQuery JavaScript Library v1.7.2
* http://jquery.com/
*
* Distributed in whole under the terms of the MIT
*
* Copyright 2010, John Resig
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Includes Sizzle.js
* http://sizzlejs.com/
* Copyright 2010, The Dojo Foundation
* Released under the MIT and BSD Licenses.
*/
(function (window, undefined) {
var jQuery = function (selector, context) {
/// <summary>
/// 1: Accepts a string containing a CSS selector which is then used to match a set of elements.
/// 1.1 - $(selector, context)
/// 1.2 - $(element)
/// 1.3 - $(object)
/// 1.4 - $(elementArray)
/// 1.5 - $(jQuery object)
/// 1.6 - $()
/// 2: Creates DOM elements on the fly from the provided string of raw HTML.
/// 2.1 - $(html, ownerDocument)
/// 2.2 - $(html, props)
/// 3: Binds a function to be executed when the DOM has finished loading.
/// 3.1 - $(callback)
/// </summary>
/// <param name="selector" type="String">
/// A string containing a selector expression
/// </param>
/// <param name="context" type="jQuery">
/// A DOM Element, Document, or jQuery to use as context
/// </param>
/// <returns type="jQuery" />
// The jQuery object is actually just the init constructor 'enhanced'
return new jQuery.fn.init(selector, context, rootjQuery);
};
jQuery.Callbacks = function (flags) {
/// <summary>
/// A multi-purpose callbacks list object that provides a powerful way to manage callback lists.
/// </summary>
/// <param name="flags" type="String">
/// An optional list of space-separated flags that change how the callback list behaves.
/// </param>
// Convert flags from String-formatted to Object-formatted
// (we check in cache first)
flags = flags ? (flagsCache[flags] || createFlags(flags)) : {};
var // Actual callback list
list = [],
// Stack of fire calls for repeatable lists
stack = [],
// Last fire value (for non-forgettable lists)
memory,
// Flag to know if list was already fired
fired,
// Flag to know if list is currently firing
firing,
// First callback to fire (used internally by add and fireWith)
firingStart,
// End of the loop when firing
firingLength,
// Index of currently firing callback (modified by remove if needed)
firingIndex,
// Add one or several callbacks to the list
add = function (args) {
var i,
length,
elem,
type,
actual;
for (i = 0, length = args.length; i < length; i++) {
elem = args[i];
type = jQuery.type(elem);
if (type === "array") {
// Inspect recursively
add(elem);
} else if (type === "function") {
// Add if not in unique mode and callback is not in
if (!flags.unique || !self.has(elem)) {
list.push(elem);
}
}
}
},
// Fire callbacks
fire = function (context, args) {
args = args || [];
memory = !flags.memory || [context, args];
fired = true;
firing = true;
firingIndex = firingStart || 0;
firingStart = 0;
firingLength = list.length;
for (; list && firingIndex < firingLength; firingIndex++) {
if (list[firingIndex].apply(context, args) === false && flags.stopOnFalse) {
memory = true; // Mark as halted
break;
}
}
firing = false;
if (list) {
if (!flags.once) {
if (stack && stack.length) {
memory = stack.shift();
self.fireWith(memory[0], memory[1]);
}
} else if (memory === true) {
self.disable();
} else {
list = [];
}
}
},
// Actual Callbacks object
self = {
// Add a callback or a collection of callbacks to the list
add: function () {
if (list) {
var length = list.length;
add(arguments);
// Do we need to add the callbacks to the
// current firing batch?
if (firing) {
firingLength = list.length;
// With memory, if we're not firing then
// we should call right away, unless previous
// firing was halted (stopOnFalse)
} else if (memory && memory !== true) {
firingStart = length;
fire(memory[0], memory[1]);
}
}
return this;
},
// Remove a callback from the list
remove: function () {
if (list) {
var args = arguments,
argIndex = 0,
argLength = args.length;
for (; argIndex < argLength ; argIndex++) {
for (var i = 0; i < list.length; i++) {
if (args[argIndex] === list[i]) {
// Handle firingIndex and firingLength
if (firing) {
if (i <= firingLength) {
firingLength--;
if (i <= firingIndex) {
firingIndex--;
}
}
}
// Remove the element
list.splice(i--, 1);
// If we have some unicity property then
// we only need to do this once
if (flags.unique) {
break;
}
}
}
}
}
return this;
},
// Control if a given callback is in the list
has: function (fn) {
if (list) {
var i = 0,
length = list.length;
for (; i < length; i++) {
if (fn === list[i]) {
return true;
}
}
}
return false;
},
// Remove all callbacks from the list
emp
评论11
最新资源