topical media & game development
mobile-application-03-MVCDerbyService-MVCDerbyService-Scripts-MicrosoftAjax.debug.js / js
// Name: MicrosoftAjax.debug.js
// Assembly: System.Web.Extensions
// Version: 4.0.0.0
// FileVersion: 4.0.20526.0
//-----------------------------------------------------------------------
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------
// MicrosoftAjax.js
// Microsoft AJAX Framework.
Function.__typeName = 'Function';
Function.__class = true;
Function.createCallback = function Function <summary locid="M:J#Function.createCallback" />
<param name="method" type="Function">
</param>
<param name="context" mayBeNull="true">
</param>
<returns type="Function">
</returns>
var e = Function._validateParams(arguments, [
{name: "method", type: Function},
{name: "context", mayBeNull: true}
]);
if (e) throw e;
return function() {
var l = arguments.length;
if (l > 0) {
var args = [];
for (var i = 0; i < l; i++) {
args[i] = arguments[i];
}
args[l] = context;
return method.apply(this, args);
}
return method.call(this, context);
}
}
Function.createDelegate = function FunctioncreateDelegate(instance, method) {
<summary locid="M:J#Function.createDelegate" />
<param name="instance" mayBeNull="true">
</param>
<param name="method" type="Function">
</param>
<returns type="Function">
</returns>
var e = Function._validateParams(arguments, [
{name: "instance", mayBeNull: true},
{name: "method", type: Function}
]);
if (e) throw e;
return function() {
return method.apply(instance, arguments);
}
}
Function.emptyFunction = Function.emptyMethod = function Function
validateParameters(parameters, expectedParameters, validateParameterCount) {
<summary locid="M:J#Function.validateParameters" />
<param name="parameters">
</param>
<param name="expectedParameters">
</param>
<param name="validateParameterCount" type="Boolean" optional="true">
</param>
<returns type="Error" mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "parameters"},
{name: "expectedParameters"},
{name: "validateParameterCount", type: Boolean, optional: true}
]);
if (e) throw e;
return Function._validateParams(parameters, expectedParameters, validateParameterCount);
}
Function._validateParams = function Function
_validateParameterCount(params, expectedParams, validateParameterCount) {
var i, error,
expectedLen = expectedParams.length,
actualLen = params.length;
if (actualLen < expectedLen) {
var minParams = expectedLen;
for (i = 0; i < expectedLen; i++) {
var param = expectedParams[i];
if (param.optional || param.parameterArray) {
minParams--;
}
}
if (actualLen < minParams) {
error = true;
}
}
else if (validateParameterCount && (actualLen > expectedLen)) {
error = true;
for (i = 0; i < expectedLen; i++) {
if (expectedParams[i].parameterArray) {
error = false;
break;
}
}
}
if (error) {
var e = Error.parameterCount();
e.popStackFrame();
return e;
}
return null;
}
Function._validateParameter = function Function
_validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName) {
var e, i;
if (typeof(param) === "undefined") {
if (mayBeNull) {
return null;
}
else {
e = Error.argumentUndefined(paramName);
e.popStackFrame();
return e;
}
}
if (param === null) {
if (mayBeNull) {
return null;
}
else {
e = Error.argumentNull(paramName);
e.popStackFrame();
return e;
}
}
if (expectedType && expectedType.__enum) {
if (typeof(param) !== 'number') {
e = Error.argumentType(paramName, Object.getType(param), expectedType);
e.popStackFrame();
return e;
}
if ((param % 1) === 0) {
var values = expectedType.prototype;
if (!expectedType.__flags || (param === 0)) {
for (i in values) {
if (values[i] === param) return null;
}
}
else {
var v = param;
for (i in values) {
var vali = values[i];
if (vali === 0) continue;
if ((vali & param) === vali) {
v -= vali;
}
if (v === 0) return null;
}
}
}
e = Error.argumentOutOfRange(paramName, param, String.format(Sys.Res.enumInvalidValue, param, expectedType.getName()));
e.popStackFrame();
return e;
}
if (expectedDomElement && (!Sys._isDomElement(param) || (param.nodeType === 3))) {
e = Error.argument(paramName, Sys.Res.argumentDomElement);
e.popStackFrame();
return e;
}
if (expectedType && !Sys._isInstanceOfType(expectedType, param)) {
e = Error.argumentType(paramName, Object.getType(param), expectedType);
e.popStackFrame();
return e;
}
if (expectedType === Number && expectedInteger) {
if ((param % 1) !== 0) {
e = Error.argumentOutOfRange(paramName, param, Sys.Res.argumentInteger);
e.popStackFrame();
return e;
}
}
return null;
}
Error.__typeName = 'Error';
Error.__class = true;
Error.create = function Error
argument(paramName, message) {
<summary locid="M:J#Error.argument" />
<param name="paramName" type="String" optional="true" mayBeNull="true">
</param>
<param name="message" type="String" optional="true" mayBeNull="true">
</param>
<returns></returns>
var e = Function._validateParams(arguments, [
{name: "paramName", type: String, mayBeNull: true, optional: true},
{name: "message", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
var displayMessage = "Sys.ArgumentException: " + (message ? message : Sys.Res.argument);
if (paramName) {
displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);
}
var err = Error.create(displayMessage, { name: "Sys.ArgumentException", paramName: paramName });
err.popStackFrame();
return err;
}
Error.argumentNull = function Error
argumentOutOfRange(paramName, actualValue, message) {
<summary locid="M:J#Error.argumentOutOfRange" />
<param name="paramName" type="String" optional="true" mayBeNull="true">
</param>
<param name="actualValue" optional="true" mayBeNull="true">
</param>
<param name="message" type="String" optional="true" mayBeNull="true">
</param>
<returns></returns>
var e = Function._validateParams(arguments, [
{name: "paramName", type: String, mayBeNull: true, optional: true},
{name: "actualValue", mayBeNull: true, optional: true},
{name: "message", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
var displayMessage = "Sys.ArgumentOutOfRangeException: " + (message ? message : Sys.Res.argumentOutOfRange);
if (paramName) {
displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);
}
if (typeof(actualValue) !== "undefined" && actualValue !== null) {
displayMessage += "\n" + String.format(Sys.Res.actualValue, actualValue);
}
var err = Error.create(displayMessage, {
name: "Sys.ArgumentOutOfRangeException",
paramName: paramName,
actualValue: actualValue
});
err.popStackFrame();
return err;
}
Error.argumentType = function Error
argumentUndefined(paramName, message) {
<summary locid="M:J#Error.argumentUndefined" />
<param name="paramName" type="String" optional="true" mayBeNull="true">
</param>
<param name="message" type="String" optional="true" mayBeNull="true">
</param>
<returns></returns>
var e = Function._validateParams(arguments, [
{name: "paramName", type: String, mayBeNull: true, optional: true},
{name: "message", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
var displayMessage = "Sys.ArgumentUndefinedException: " + (message ? message : Sys.Res.argumentUndefined);
if (paramName) {
displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);
}
var err = Error.create(displayMessage, { name: "Sys.ArgumentUndefinedException", paramName: paramName });
err.popStackFrame();
return err;
}
Error.format = function Error
invalidOperation(message) {
<summary locid="M:J#Error.invalidOperation" />
<param name="message" type="String" optional="true" mayBeNull="true">
</param>
<returns></returns>
var e = Function._validateParams(arguments, [
{name: "message", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
var displayMessage = "Sys.InvalidOperationException: " + (message ? message : Sys.Res.invalidOperation);
var err = Error.create(displayMessage, {name: 'Sys.InvalidOperationException'});
err.popStackFrame();
return err;
}
Error.notImplemented = function Error
parameterCount(message) {
<summary locid="M:J#Error.parameterCount" />
<param name="message" type="String" optional="true" mayBeNull="true">
</param>
<returns></returns>
var e = Function._validateParams(arguments, [
{name: "message", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
var displayMessage = "Sys.ParameterCountException: " + (message ? message : Sys.Res.parameterCount);
var err = Error.create(displayMessage, {name: 'Sys.ParameterCountException'});
err.popStackFrame();
return err;
}
Error.prototype.popStackFrame = function Error
/);
if (typeof(nextFrameParts) === "undefined" || nextFrameParts === null) {
return;
}
this.fileName = nextFrameParts[1];
this.lineNumber = parseInt(nextFrameParts[2]);
stackFrames.shift();
this.stack = stackFrames.join("\n");
}
Object.__typeName = 'Object';
Object.__class = true;
Object.getType = function Object
getTypeName(instance) {
<summary locid="M:J#Object.getTypeName" />
<param name="instance">
</param>
<returns type="String">
</returns>
var e = Function._validateParams(arguments, [
{name: "instance"}
]);
if (e) throw e;
return Object.getType(instance).getName();
}
String.__typeName = 'String';
String.__class = true;
String.prototype.endsWith = function String
startsWith(prefix) {
<summary locid="M:J#String.startsWith" />
<param name="prefix" type="String">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "prefix", type: String}
]);
if (e) throw e;
return (this.substr(0, prefix.length) === prefix);
}
String.prototype.trim = function String
/g, '');
}
String.prototype.trimEnd = function String
/, '');
}
String.prototype.trimStart = function String
format(format, args) {
<summary locid="M:J#String.format" />
<param name="format" type="String">
</param>
<param name="args" parameterArray="true" mayBeNull="true">
</param>
<returns type="String">
</returns>
var e = Function._validateParams(arguments, [
{name: "format", type: String},
{name: "args", mayBeNull: true, parameterArray: true}
]);
if (e) throw e;
return String._toFormattedString(false, arguments);
}
String._toFormattedString = function String
parse(value) {
<summary locid="M:J#Boolean.parse" />
<param name="value" type="String">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "value", type: String}
], false);
if (e) throw e;
var v = value.trim().toLowerCase();
if (v === 'false') return false;
if (v === 'true') return true;
throw Error.argumentOutOfRange('value', value, Sys.Res.boolTrueOrFalse);
}
Date.__typeName = 'Date';
Date.__class = true;
Number.__typeName = 'Number';
Number.__class = true;
RegExp.__typeName = 'RegExp';
RegExp.__class = true;
if (!window) this.window = this;
window.Type = Function;
Type.__fullyQualifiedIdentifierRegExp = new RegExp("^[^.0-9 \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]([^ \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]*[^. \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\])?
", "i");
Type.prototype.callBaseMethod = function Type
getBaseMethod(instance, name) {
<summary locid="M:J#Type.getBaseMethod" />
<param name="instance">
</param>
<param name="name" type="String">
</param>
<returns type="Function" mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "instance"},
{name: "name", type: String}
]);
if (e) throw e;
return Sys._getBaseMethod(this, instance, name);
}
Type.prototype.getBaseType = function Type
getInterfaces() {
<summary locid="M:J#Type.getInterfaces" />
<returns type="Array" elementType="Type" mayBeNull="false" elementMayBeNull="false">
</returns>
if (arguments.length !== 0) throw Error.parameterCount();
var result = [];
var type = this;
while(type) {
var interfaces = type.__interfaces;
if (interfaces) {
for (var i = 0, l = interfaces.length; i < l; i++) {
var interfaceType = interfaces[i];
if (!Array.contains(result, interfaceType)) {
result[result.length] = interfaceType;
}
}
}
type = type.__baseType;
}
return result;
}
Type.prototype.getName = function Type
implementsInterface(interfaceType) {
<summary locid="M:J#Type.implementsInterface" />
<param name="interfaceType" type="Type">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "interfaceType", type: Type}
]);
if (e) throw e;
this.resolveInheritance();
var interfaceName = interfaceType.getName();
var cache = this.__interfaceCache;
if (cache) {
var cacheEntry = cache
[interfaceName];
if (typeof(cacheEntry) !== 'undefined') return cacheEntry;
}
else {
cache = this.__interfaceCache = {};
}
var baseType = this;
while (baseType) {
var interfaces = baseType.__interfaces;
if (interfaces) {
if (Array.indexOf(interfaces, interfaceType) !== -1) {
return cache
[interfaceName] = true;
}
}
baseType = baseType.__baseType;
}
return cache
[interfaceName] = false;
}
Type.prototype.inheritsFrom = function Type
initializeBase(instance, baseArguments) {
<summary locid="M:J#Type.initializeBase" />
<param name="instance">
</param>
<param name="baseArguments" type="Array" optional="true" mayBeNull="true" elementMayBeNull="true">
</param>
<returns></returns>
var e = Function._validateParams(arguments, [
{name: "instance"},
{name: "baseArguments", type: Array, mayBeNull: true, optional: true, elementMayBeNull: true}
]);
if (e) throw e;
if (!Sys._isInstanceOfType(this, instance)) throw Error.argumentType('instance', Object.getType(instance), this);
this.resolveInheritance();
if (this.__baseType) {
if (!baseArguments) {
this.__baseType.apply(instance);
}
else {
this.__baseType.apply(instance, baseArguments);
}
}
return instance;
}
Type.prototype.isImplementedBy = function Type
isInstanceOfType(instance) {
<summary locid="M:J#Type.isInstanceOfType" />
<param name="instance" mayBeNull="true">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "instance", mayBeNull: true}
]);
if (e) throw e;
return Sys._isInstanceOfType(this, instance);
}
Type.prototype.registerClass = function Type
registerInterface(typeName) {
<summary locid="M:J#Type.registerInterface" />
<param name="typeName" type="String">
</param>
<returns type="Type">
</returns>
var e = Function._validateParams(arguments, [
{name: "typeName", type: String}
]);
if (e) throw e;
if (!Type.__fullyQualifiedIdentifierRegExp.test(typeName)) throw Error.argument('typeName', Sys.Res.notATypeName);
var parsedName;
try {
parsedName = eval(typeName);
}
catch(e) {
throw Error.argument('typeName', Sys.Res.argumentTypeName);
}
if (parsedName !== this) throw Error.argument('typeName', Sys.Res.badTypeName);
if (Sys.__registeredTypes
[typeName]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, typeName));
Sys.__upperCaseTypes[typeName.toUpperCase()] = this;
this.prototype.constructor = this;
this.__typeName = typeName;
this.__interface = true;
Sys.__registeredTypes
[typeName] = true;
return this;
}
Type.prototype.resolveInheritance = function Type
getRootNamespaces() {
<summary locid="M:J#Type.getRootNamespaces" />
<returns type="Array">
</returns>
if (arguments.length !== 0) throw Error.parameterCount();
return Array.clone(Sys.__rootNamespaces);
}
Type.isClass = function Type
isInterface(type) {
<summary locid="M:J#Type.isInterface" />
<param name="type" mayBeNull="true">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "type", mayBeNull: true}
]);
if (e) throw e;
if ((typeof(type) === 'undefined') || (type === null)) return false;
return !!type.__interface;
}
Type.isNamespace = function Type
parse(typeName, ns) {
<summary locid="M:J#Type.parse" />
<param name="typeName" type="String" mayBeNull="true">
</param>
<param name="ns" optional="true" mayBeNull="true">
</param>
<returns type="Type" mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "typeName", type: String, mayBeNull: true},
{name: "ns", mayBeNull: true, optional: true}
]);
if (e) throw e;
var fn;
if (ns) {
fn = Sys.__upperCaseTypes[ns.getName().toUpperCase() + '.' + typeName.toUpperCase()];
return fn || null;
}
if (!typeName) return null;
if (!Type.__htClasses) {
Type.__htClasses = {};
}
fn = Type.__htClasses
[typeName];
if (!fn) {
fn = eval(typeName);
if (typeof(fn) !== 'function') throw Error.argument('typeName', Sys.Res.notATypeName);
Type.__htClasses
[typeName] = fn;
}
return fn;
}
Type.registerNamespace = function Type
_registerNamespace(namespacePath) {
if (!Type.__fullyQualifiedIdentifierRegExp.test(namespacePath)) throw Error.argument('namespacePath', Sys.Res.invalidNameSpace);
var rootObject = window;
var namespaceParts = namespacePath.split('.');
for (var i = 0; i < namespaceParts.length; i++) {
var currentPart = namespaceParts[i];
var ns = rootObject
[currentPart];
var nsType = typeof(ns);
if ((nsType !== "undefined") && (ns !== null)) {
if (nsType === "function") {
throw Error.invalidOperation(String.format(Sys.Res.namespaceContainsClass, namespaceParts.splice(0, i + 1).join('.')));
}
if ((typeof(ns) !== "object") || (ns instanceof Array)) {
throw Error.invalidOperation(String.format(Sys.Res.namespaceContainsNonObject, namespaceParts.splice(0, i + 1).join('.')));
}
}
if (!ns) {
ns = rootObject
[currentPart] = {};
}
if (!ns.__namespace) {
if ((i === 0) && (namespacePath !== "Sys")) {
Sys.__rootNamespaces[Sys.__rootNamespaces.length] = ns;
}
ns.__namespace = true;
ns.__typeName = namespaceParts.slice(0, i + 1).join('.');
var parsedName;
try {
parsedName = eval(ns.__typeName);
}
catch(e) {
parsedName = null;
}
if (parsedName !== ns) {
delete rootObject
[currentPart];
throw Error.argument('namespacePath', Sys.Res.invalidNameSpace);
}
ns.getName = function ns
_checkDependency(dependency, featureName) {
var scripts = Type._register
Script._scripts, isDependent = (scripts ? (!!scripts[dependency]) : false);
if ((typeof(featureName) !== 'undefined') && !isDependent) {
throw Error.invalidOperation(String.format(Sys.Res.requiredScriptReferenceNotIncluded,
featureName, dependency));
}
return isDependent;
}
Type._register
Script = function Type
_isInstanceOfType(type, instance) {
if (typeof(instance) === "undefined" || instance === null) return false;
if (instance instanceof type) return true;
var instanceType = Object.getType(instance);
return !!(instanceType === type) ||
(instanceType.inheritsFrom && instanceType.inheritsFrom(type)) ||
(instanceType.implementsInterface && instanceType.implementsInterface(type));
}
Sys._getBaseMethod = function Sys
_isDomElement(obj) {
var val = false;
if (typeof (obj.nodeType) !== 'number') {
var doc = obj.ownerDocument || obj.document || obj;
if (doc != obj) {
var w = doc.defaultView || doc.parentWindow;
val = (w != obj);
}
else {
val = (typeof (doc.body) === 'undefined');
}
}
return !val;
}
Array.__typeName = 'Array';
Array.__class = true;
Array.add = Array.enqueue = function Array
addRange(array, items) {
<summary locid="M:J#Array.addRange" />
<param name="array" type="Array" elementMayBeNull="true">
</param>
<param name="items" type="Array" elementMayBeNull="true">
</param>
var e = Function._validateParams(arguments, [
{name: "array", type: Array, elementMayBeNull: true},
{name: "items", type: Array, elementMayBeNull: true}
]);
if (e) throw e;
array.push.apply(array, items);
}
Array.clear = function Array
clone(array) {
<summary locid="M:J#Array.clone" />
<param name="array" type="Array" elementMayBeNull="true">
</param>
<returns type="Array" elementMayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "array", type: Array, elementMayBeNull: true}
]);
if (e) throw e;
if (array.length === 1) {
return [array[0]];
}
else {
return Array.apply(null, array);
}
}
Array.contains = function Array
dequeue(array) {
<summary locid="M:J#Array.dequeue" />
<param name="array" type="Array" elementMayBeNull="true">
</param>
<returns mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "array", type: Array, elementMayBeNull: true}
]);
if (e) throw e;
return array.shift();
}
Array.forEach = function Array
indexOf(array, item, start) {
<summary locid="M:J#Array.indexOf" />
<param name="array" type="Array" elementMayBeNull="true">
</param>
<param name="item" optional="true" mayBeNull="true">
</param>
<param name="start" optional="true" mayBeNull="true">
</param>
<returns type="Number">
</returns>
var e = Function._validateParams(arguments, [
{name: "array", type: Array, elementMayBeNull: true},
{name: "item", mayBeNull: true, optional: true},
{name: "start", mayBeNull: true, optional: true}
]);
if (e) throw e;
return Sys._indexOf(array, item, start);
}
Array.insert = function Array
parse(value) {
<summary locid="M:J#Array.parse" />
<param name="value" type="String" mayBeNull="true">
</param>
<returns type="Array" elementMayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "value", type: String, mayBeNull: true}
]);
if (e) throw e;
if (!value) return [];
var v = eval(value);
if (!Array.isInstanceOfType(v)) throw Error.argument('value', Sys.Res.arrayParseBadFormat);
return v;
}
Array.remove = function Array
removeAt(array, index) {
<summary locid="M:J#Array.removeAt" />
<param name="array" type="Array" elementMayBeNull="true">
</param>
<param name="index" mayBeNull="true">
</param>
var e = Function._validateParams(arguments, [
{name: "array", type: Array, elementMayBeNull: true},
{name: "index", mayBeNull: true}
]);
if (e) throw e;
array.splice(index, 1);
}
Sys._indexOf = function Sys
IDisposable() {
throw Error.notImplemented();
}
function Sys
IDisposabledispose() {
throw Error.notImplemented();
}
Sys.IDisposable.prototype = {
dispose: Sys
IDisposabledispose
}
Sys.IDisposable.registerInterface('Sys.IDisposable');
Sys.StringBuilder = function Sys
EventArgs() {
<summary locid="M:J#Sys.EventArgs.#ctor" />
if (arguments.length !== 0) throw Error.parameterCount();
}
Sys.EventArgs.registerClass('Sys.EventArgs');
Sys.EventArgs.Empty = new Sys.EventArgs();
Sys.CancelEventArgs = function Sys
_Debug() {
<summary locid="M:J#Sys.Debug.#ctor" />
<field name="isDebug" type="Boolean" locid="F:J#Sys.Debug.isDebug">
</field>
if (arguments.length !== 0) throw Error.parameterCount();
}
function Sys
_appendConsole(text) {
if ((typeof(Debug) !== 'undefined') && Debug.writeln) {
Debug.writeln(text);
}
if (window.console && window.console.log) {
window.console.log(text);
}
if (window.opera) {
window.opera.postError(text);
}
if (window.debugService) {
window.debugService.trace(text);
}
}
function Sys
_appendTrace(text) {
var traceElement = document.getElementById('TraceConsole');
if (traceElement && (traceElement.tagName.toUpperCase() === 'TEXTAREA')) {
traceElement.value += text + '\n';
}
}
function Sys
assert(condition, message, displayCaller) {
<summary locid="M:J#Sys.Debug.assert" />
<param name="condition" type="Boolean">
</param>
<param name="message" type="String" optional="true" mayBeNull="true">
</param>
<param name="displayCaller" type="Boolean" optional="true">
</param>
var e = Function._validateParams(arguments, [
{name: "condition", type: Boolean},
{name: "message", type: String, mayBeNull: true, optional: true},
{name: "displayCaller", type: Boolean, optional: true}
]);
if (e) throw e;
if (!condition) {
message = (displayCaller && this.assert.caller) ?
String.format(Sys.Res.assertFailedCaller, message, this.assert.caller) :
String.format(Sys.Res.assertFailed, message);
if (confirm(String.format(Sys.Res.breakIntoDebugger, message))) {
this.fail(message);
}
}
}
function Sys
clearTrace() {
<summary locid="M:J#Sys.Debug.clearTrace" />
if (arguments.length !== 0) throw Error.parameterCount();
var traceElement = document.getElementById('TraceConsole');
if (traceElement && (traceElement.tagName.toUpperCase() === 'TEXTAREA')) {
traceElement.value = '';
}
}
function Sys
fail(message) {
<summary locid="M:J#Sys.Debug.fail" />
<param name="message" type="String" mayBeNull="true">
</param>
var e = Function._validateParams(arguments, [
{name: "message", type: String, mayBeNull: true}
]);
if (e) throw e;
this._appendConsole(message);
if (Sys.Browser.hasDebuggerStatement) {
eval('debugger');
}
}
function Sys
trace(text) {
<summary locid="M:J#Sys.Debug.trace" />
<param name="text">
</param>
var e = Function._validateParams(arguments, [
{name: "text"}
]);
if (e) throw e;
this._appendConsole(text);
this._appendTrace(text);
}
function Sys
traceDump(object, name) {
<summary locid="M:J#Sys.Debug.traceDump" />
<param name="object" mayBeNull="true">
</param>
<param name="name" type="String" mayBeNull="true" optional="true">
</param>
var e = Function._validateParams(arguments, [
{name: "object", mayBeNull: true},
{name: "name", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
var text = this._traceDump(object, name, true);
}
function Sys
_traceDump(object, name, recursive, indentationPadding, loopArray) {
name = name? name : 'traceDump';
indentationPadding = indentationPadding? indentationPadding : '';
if (object === null) {
this.trace(indentationPadding + name + ': null');
return;
}
switch(typeof(object)) {
case 'undefined':
this.trace(indentationPadding + name + ': Undefined');
break;
case 'number': case 'string': case 'boolean':
this.trace(indentationPadding + name + ': ' + object);
break;
default:
if (Date.isInstanceOfType(object) || RegExp.isInstanceOfType(object)) {
this.trace(indentationPadding + name + ': ' + object.toString());
break;
}
if (!loopArray) {
loopArray = [];
}
else if (Array.contains(loopArray, object)) {
this.trace(indentationPadding + name + ': ...');
return;
}
Array.add(loopArray, object);
if ((object == window) || (object === document) ||
(window.HTMLElement && (object instanceof HTMLElement)) ||
(typeof(object.nodeName) === 'string')) {
var tag = object.tagName? object.tagName : 'DomElement';
if (object.id) {
tag += ' - ' + object.id;
}
this.trace(indentationPadding + name + ' {' + tag + '}');
}
else {
var typeName = Object.getTypeName(object);
this.trace(indentationPadding + name + (typeof(typeName) === 'string' ? ' {' + typeName + '}' : ''));
if ((indentationPadding === '') || recursive) {
indentationPadding += " ";
var i, length, properties, p, v;
if (Array.isInstanceOfType(object)) {
length = object.length;
for (i = 0; i < length; i++) {
this._traceDump(object[i], '[' + i + ']', recursive, indentationPadding, loopArray);
}
}
else {
for (p in object) {
v = object[p];
if (!Function.isInstanceOfType(v)) {
this._traceDump(v, p, recursive, indentationPadding, loopArray);
}
}
}
}
}
Array.remove(loopArray, object);
}
}
Sys._Debug.prototype = {
_appendConsole: Sys
_appendConsole,
_appendTrace: Sys
_appendTrace,
assert: Sys
assert,
clearTrace: Sys
clearTrace,
fail: Sys
fail,
trace: Sys
trace,
traceDump: Sys
traceDump,
_traceDump: Sys
_traceDump
}
Sys._Debug.registerClass('Sys._Debug');
Sys.Debug = new Sys._Debug();
Sys.Debug.isDebug = true;
function Sys
Enumparse(value, ignoreCase) {
<summary locid="M:J#Sys.Enum.parse" />
<param name="value" type="String">
</param>
<param name="ignoreCase" type="Boolean" optional="true">
</param>
<returns></returns>
var e = Function._validateParams(arguments, [
{name: "value", type: String},
{name: "ignoreCase", type: Boolean, optional: true}
]);
if (e) throw e;
var values, parsed, val;
if (ignoreCase) {
values = this.__lowerCaseValues;
if (!values) {
this.__lowerCaseValues = values = {};
var prototype = this.prototype;
for (var name in prototype) {
values[name.toLowerCase()] = prototype[name];
}
}
}
else {
values = this.prototype;
}
if (!this.__flags) {
val = (ignoreCase ? value.toLowerCase() : value);
parsed = values[val.trim()];
if (typeof(parsed) !== 'number') throw Error.argument('value', String.format(Sys.Res.enumInvalidValue, value, this.__typeName));
return parsed;
}
else {
var parts = (ignoreCase ? value.toLowerCase() : value).split(',');
var v = 0;
for (var i = parts.length - 1; i >= 0; i--) {
var part = parts[i].trim();
parsed = values[part];
if (typeof(parsed) !== 'number') throw Error.argument('value', String.format(Sys.Res.enumInvalidValue, value.split(',')[i].trim(), this.__typeName));
v |= parsed;
}
return v;
}
}
function Sys
EnumtoString(value) {
<summary locid="M:J#Sys.Enum.toString" />
<param name="value" optional="true" mayBeNull="true">
</param>
<returns type="String">
</returns>
var e = Function._validateParams(arguments, [
{name: "value", mayBeNull: true, optional: true}
]);
if (e) throw e;
if ((typeof(value) === 'undefined') || (value === null)) return this.__string;
if ((typeof(value) != 'number') || ((value % 1) !== 0)) throw Error.argumentType('value', Object.getType(value), this);
var values = this.prototype;
var i;
if (!this.__flags || (value === 0)) {
for (i in values) {
if (values[i] === value) {
return i;
}
}
}
else {
var sorted = this.__sortedValues;
if (!sorted) {
sorted = [];
for (i in values) {
sorted[sorted.length] = {key: i, value: values[i]};
}
sorted.sort(function(a, b) {
return a.value - b.value;
});
this.__sortedValues = sorted;
}
var parts = [];
var v = value;
for (i = sorted.length - 1; i >= 0; i--) {
var kvp = sorted[i];
var vali = kvp.value;
if (vali === 0) continue;
if ((vali & value) === vali) {
parts[parts.length] = kvp.key;
v -= vali;
if (v === 0) break;
}
}
if (parts.length && v === 0) return parts.reverse().join(', ');
}
throw Error.argumentOutOfRange('value', value, String.format(Sys.Res.enumInvalidValue, value, this.__typeName));
}
Type.prototype.registerEnum = function Type
isEnum(type) {
<summary locid="M:J#Type.isEnum" />
<param name="type" mayBeNull="true">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "type", mayBeNull: true}
]);
if (e) throw e;
if ((typeof(type) === 'undefined') || (type === null)) return false;
return !!type.__enum;
}
Type.isFlags = function Type
CollectionChange(action, newItems, newStartingIndex, oldItems, oldStartingIndex) {
<summary locid="M:J#Sys.CollectionChange.#ctor" />
<param name="action" type="Sys.NotifyCollectionChangedAction">
</param>
<param name="newItems" optional="true" mayBeNull="true">
</param>
<param name="newStartingIndex" type="Number" integer="true" optional="true" mayBeNull="true">
</param>
<param name="oldItems" optional="true" mayBeNull="true">
</param>
<param name="oldStartingIndex" type="Number" integer="true" optional="true" mayBeNull="true">
</param>
<field name="action" type="Sys.NotifyCollectionChangedAction" locid="F:J#Sys.CollectionChange.action">
</field>
<field name="newItems" type="Array" mayBeNull="true" elementMayBeNull="true" locid="F:J#Sys.CollectionChange.newItems">
</field>
<field name="newStartingIndex" type="Number" integer="true" locid="F:J#Sys.CollectionChange.newStartingIndex">
</field>
<field name="oldItems" type="Array" mayBeNull="true" elementMayBeNull="true" locid="F:J#Sys.CollectionChange.oldItems">
</field>
<field name="oldStartingIndex" type="Number" integer="true" locid="F:J#Sys.CollectionChange.oldStartingIndex">
</field>
var e = Function._validateParams(arguments, [
{name: "action", type: Sys.NotifyCollectionChangedAction},
{name: "newItems", mayBeNull: true, optional: true},
{name: "newStartingIndex", type: Number, mayBeNull: true, integer: true, optional: true},
{name: "oldItems", mayBeNull: true, optional: true},
{name: "oldStartingIndex", type: Number, mayBeNull: true, integer: true, optional: true}
]);
if (e) throw e;
this.action = action;
if (newItems) {
if (!(newItems instanceof Array)) {
newItems =
[newItems];
}
}
this.newItems = newItems || null;
if (typeof newStartingIndex !== "number") {
newStartingIndex = -1;
}
this.newStartingIndex = newStartingIndex;
if (oldItems) {
if (!(oldItems instanceof Array)) {
oldItems =
[oldItems];
}
}
this.oldItems = oldItems || null;
if (typeof oldStartingIndex !== "number") {
oldStartingIndex = -1;
}
this.oldStartingIndex = oldStartingIndex;
}
Sys.CollectionChange.registerClass("Sys.CollectionChange");
Sys.NotifyCollectionChangedAction = function Sys
NotifyCollectionChangedEventArgs(changes) {
<summary locid="M:J#Sys.NotifyCollectionChangedEventArgs.#ctor" />
<param name="changes" type="Array" elementType="Sys.CollectionChange">
</param>
var e = Function._validateParams(arguments, [
{name: "changes", type: Array, elementType: Sys.CollectionChange}
]);
if (e) throw e;
this._changes = changes;
Sys.NotifyCollectionChangedEventArgs.initializeBase(this);
}
function Sys
NotifyCollectionChangedEventArgsget_changes() {
<value type="Array" elementType="Sys.CollectionChange" locid="P:J#Sys.NotifyCollectionChangedEventArgs.changes">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._changes || [];
}
Sys.NotifyCollectionChangedEventArgs.prototype = {
get_changes: Sys
NotifyCollectionChangedEventArgsget_changes
}
Sys.NotifyCollectionChangedEventArgs.registerClass("Sys.NotifyCollectionChangedEventArgs", Sys.EventArgs);
Sys.Observer = function Sys
_appendPreOrPostMatch(preMatch, strBuilder) {
var quoteCount = 0;
var escaped = false;
for (var i = 0, il = preMatch.length; i < il; i++) {
var c = preMatch.charAt(i);
switch (c) {
case '\'':
if (escaped) strBuilder.append("'");
else quoteCount++;
escaped = false;
break;
case '\\':
if (escaped) strBuilder.append("\\");
escaped = !escaped;
break;
default:
strBuilder.append(c);
escaped = false;
break;
}
}
return quoteCount;
}
Date._expandFormat = function Date
_expandYear(dtf, year) {
var now = new Date(),
era = Date._getEra(now);
if (year < 100) {
var curr = Date._getEraYear(now, dtf, era);
year += curr - (curr % 100);
if (year > dtf.Calendar.TwoDigitYearMax) {
year -= 100;
}
}
return year;
}
Date._getEra = function Date
_getEraYear(date, dtf, era, sortable) {
var year = date.getFullYear();
if (!sortable && dtf.eras) {
year -= dtf.eras[era + 3];
}
return year;
}
Date._getParseRegExp = function Date
");
var regexpStr = regexp.toString().replace(/\s+/g, "\\s+");
var parseRegExp = {'regExp': regexpStr, 'groups': groups};
dtf._parseRegExp[format] = parseRegExp;
return parseRegExp;
}
Date._getTokenRegExp = function Date
parseLocale(value, formats) {
<summary locid="M:J#Date.parseLocale" />
<param name="value" type="String">
</param>
<param name="formats" parameterArray="true" optional="true" mayBeNull="true">
</param>
<returns type="Date">
</returns>
var e = Function._validateParams(arguments, [
{name: "value", type: String},
{name: "formats", mayBeNull: true, optional: true, parameterArray: true}
]);
if (e) throw e;
return Date._parse(value, Sys.CultureInfo.CurrentCulture, arguments);
}
Date.parseInvariant = function Date
_parse(value, cultureInfo, args) {
var i, l, date, format, formats, custom = false;
for (i = 1, l = args.length; i < l; i++) {
format = args[i];
if (format) {
custom = true;
date = Date._parseExact(value, format, cultureInfo);
if (date) return date;
}
}
if (! custom) {
formats = cultureInfo._getDateTimeFormats();
for (i = 0, l = formats.length; i < l; i++) {
date = Date._parseExact(value, formats[i], cultureInfo);
if (date) return date;
}
}
return null;
}
Date._parseExact = function Date
format(format) {
<summary locid="M:J#Date.format" />
<param name="format" type="String">
</param>
<returns type="String">
</returns>
var e = Function._validateParams(arguments, [
{name: "format", type: String}
]);
if (e) throw e;
return this._toFormattedString(format, Sys.CultureInfo.InvariantCulture);
}
Date.prototype.localeFormat = function Date
_toFormattedString(format, cultureInfo) {
var dtf = cultureInfo.dateTimeFormat,
convert = dtf.Calendar.convert;
if (!format || !format.length || (format === 'i')) {
if (cultureInfo && cultureInfo.name.length) {
if (convert) {
return this._toFormattedString(dtf.FullDateTimePattern, cultureInfo);
}
else {
var eraDate = new Date(this.getTime());
var era = Date._getEra(this, dtf.eras);
eraDate.setFullYear(Date._getEraYear(this, dtf, era));
return eraDate.toLocaleString();
}
}
else {
return this.toString();
}
}
var eras = dtf.eras,
sortable = (format === "s");
format = Date._expandFormat(dtf, format);
var ret = new Sys.StringBuilder();
var hour;
function addLeadingZero(num) {
if (num < 10) {
return '0' + num;
}
return num.toString();
}
function addLeadingZeros(num) {
if (num < 10) {
return '00' + num;
}
if (num < 100) {
return '0' + num;
}
return num.toString();
}
function padYear(year) {
if (year < 10) {
return '000' + year;
}
else if (year < 100) {
return '00' + year;
}
else if (year < 1000) {
return '0' + year;
}
return year.toString();
}
var foundDay, checkedDay, dayPartRegExp = /([^d]|^)(d|dd)([^d]|
localeFormat(format, args) {
<summary locid="M:J#String.localeFormat" />
<param name="format" type="String">
</param>
<param name="args" parameterArray="true" mayBeNull="true">
</param>
<returns type="String">
</returns>
var e = Function._validateParams(arguments, [
{name: "format", type: String},
{name: "args", mayBeNull: true, parameterArray: true}
]);
if (e) throw e;
return String._toFormattedString(true, arguments);
}
Number.parseLocale = function Number
parseInvariant(value) {
<summary locid="M:J#Number.parseInvariant" />
<param name="value" type="String">
</param>
<returns type="Number">
</returns>
var e = Function._validateParams(arguments, [
{name: "value", type: String}
], false);
if (e) throw e;
return Number._parse(value, Sys.CultureInfo.InvariantCulture);
}
Number._parse = function Number
/i)) {
return parseFloat(value);
}
if (value.match(/^0x[a-f0-9]+
/)) {
return parseFloat(p);
}
return Number.NaN;
}
Number._parseNumberNegativePattern = function Number
format(format) {
<summary locid="M:J#Number.format" />
<param name="format" type="String">
</param>
<returns type="String">
</returns>
var e = Function._validateParams(arguments, [
{name: "format", type: String}
]);
if (e) throw e;
return this._toFormattedString(format, Sys.CultureInfo.InvariantCulture);
}
Number.prototype.localeFormat = function Number
_toFormattedString(format, cultureInfo) {
if (!format || (format.length === 0) || (format === 'i')) {
if (cultureInfo && (cultureInfo.name.length > 0)) {
return this.toLocaleString();
}
else {
return this.toString();
}
}
var _percentPositivePattern = ["n %", "n%", "%n" ];
var _percentNegativePattern = ["-n %", "-n%", "-%n"];
var _numberNegativePattern = ["(n)","-n","- n","n-","n -"];
var _currencyPositivePattern = ["
","
"];
var _currencyNegativePattern = ["(
n","
n-","(n
","n-
-","-n
n","n
n-","
","(
)"];
function zeroPad(str, count, left) {
for (var l=str.length; l < count; l++) {
str = (left ? ('0' + str) : (str + '0'));
}
return str;
}
function expandNumber(number, precision, groupSizes, sep, decimalChar) {
Sys.Debug.assert(groupSizes.length > 0, "groupSizes must be an array of at least 1");
var curSize = groupSizes[0];
var curGroupIndex = 1;
var factor = Math.pow(10, precision);
var rounded = (Math.round(number * factor) / factor);
if (!isFinite(rounded)) {
rounded = number;
}
number = rounded;
var numberString = number.toString();
var right = "";
var exponent;
var split = numberString.split(/e/i);
numberString = split[0];
exponent = (split.length > 1 ? parseInt(split[1]) : 0);
split = numberString.split('.');
numberString = split[0];
right = split.length > 1 ? split[1] : "";
var l;
if (exponent > 0) {
right = zeroPad(right, exponent, false);
numberString += right.slice(0, exponent);
right = right.substr(exponent);
}
else if (exponent < 0) {
exponent = -exponent;
numberString = zeroPad(numberString, exponent+1, true);
right = numberString.slice(-exponent, numberString.length) + right;
numberString = numberString.slice(0, -exponent);
}
if (precision > 0) {
if (right.length > precision) {
right = right.slice(0, precision);
}
else {
right = zeroPad(right, precision, false);
}
right = decimalChar + right;
}
else {
right = "";
}
var stringIndex = numberString.length-1;
var ret = "";
while (stringIndex >= 0) {
if (curSize === 0 || curSize > stringIndex) {
if (ret.length > 0)
return numberString.slice(0, stringIndex + 1) + sep + ret + right;
else
return numberString.slice(0, stringIndex + 1) + right;
}
if (ret.length > 0)
ret = numberString.slice(stringIndex - curSize + 1, stringIndex+1) + sep + ret;
else
ret = numberString.slice(stringIndex - curSize + 1, stringIndex+1);
stringIndex -= curSize;
if (curGroupIndex < groupSizes.length) {
curSize = groupSizes
[curGroupIndex];
curGroupIndex++;
}
}
return numberString.slice(0, stringIndex + 1) + sep + ret + right;
}
var nf = cultureInfo.numberFormat;
var number = Math.abs(this);
if (!format)
format = "D";
var precision = -1;
if (format.length > 1) precision = parseInt(format.slice(1), 10);
var pattern;
switch (format.charAt(0)) {
case "d":
case "D":
pattern = 'n';
if (precision !== -1) {
number = zeroPad(""+number, precision, true);
}
if (this < 0) number = -number;
break;
case "c":
case "C":
if (this < 0) pattern = _currencyNegativePattern[nf.CurrencyNegativePattern];
else pattern = _currencyPositivePattern[nf.CurrencyPositivePattern];
if (precision === -1) precision = nf.CurrencyDecimalDigits;
number = expandNumber(Math.abs(this), precision, nf.CurrencyGroupSizes, nf.CurrencyGroupSeparator, nf.CurrencyDecimalSeparator);
break;
case "n":
case "N":
if (this < 0) pattern = _numberNegativePattern[nf.NumberNegativePattern];
else pattern = 'n';
if (precision === -1) precision = nf.NumberDecimalDigits;
number = expandNumber(Math.abs(this), precision, nf.NumberGroupSizes, nf.NumberGroupSeparator, nf.NumberDecimalSeparator);
break;
case "p":
case "P":
if (this < 0) pattern = _percentNegativePattern[nf.PercentNegativePattern];
else pattern = _percentPositivePattern[nf.PercentPositivePattern];
if (precision === -1) precision = nf.PercentDecimalDigits;
number = expandNumber(Math.abs(this) * 100, precision, nf.PercentGroupSizes, nf.PercentGroupSeparator, nf.PercentDecimalSeparator);
break;
default:
throw Error.format(Sys.Res.formatBadFormatSpecifier);
}
var regex = /n|$|-|%/g;
var ret = "";
for (;;) {
var index = regex.lastIndex;
var ar = regex.exec(pattern);
ret += pattern.slice(index, ar ? ar.index : pattern.length);
if (!ar)
break;
switch (ar[0]) {
case "n":
ret += number;
break;
case "
CultureInfo(name, numberFormat, dateTimeFormat) {
<summary locid="M:J#Sys.CultureInfo.#ctor" />
<param name="name" type="String">
</param>
<param name="numberFormat" type="Object">
</param>
<param name="dateTimeFormat" type="Object">
</param>
var e = Function._validateParams(arguments, [
{name: "name", type: String},
{name: "numberFormat", type: Object},
{name: "dateTimeFormat", type: Object}
]);
if (e) throw e;
this.name = name;
this.numberFormat = numberFormat;
this.dateTimeFormat = dateTimeFormat;
}
function Sys
CultureInfo_getDateTimeFormats() {
if (! this._dateTimeFormats) {
var dtf = this.dateTimeFormat;
this._dateTimeFormats =
[ dtf.MonthDayPattern,
dtf.YearMonthPattern,
dtf.ShortDatePattern,
dtf.ShortTimePattern,
dtf.LongDatePattern,
dtf.LongTimePattern,
dtf.FullDateTimePattern,
dtf.RFC1123Pattern,
dtf.SortableDateTimePattern,
dtf.UniversalSortableDateTimePattern ];
}
return this._dateTimeFormats;
}
function Sys
CultureInfo_getIndex(value, a1, a2) {
var upper = this._toUpper(value),
i = Array.indexOf(a1, upper);
if (i === -1) {
i = Array.indexOf(a2, upper);
}
return i;
}
function Sys
CultureInfo_getMonthIndex(value) {
if (!this._upperMonths) {
this._upperMonths = this._toUpperArray(this.dateTimeFormat.MonthNames);
this._upperMonthsGenitive = this._toUpperArray(this.dateTimeFormat.MonthGenitiveNames);
}
return this._getIndex(value, this._upperMonths, this._upperMonthsGenitive);
}
function Sys
CultureInfo_getAbbrMonthIndex(value) {
if (!this._upperAbbrMonths) {
this._upperAbbrMonths = this._toUpperArray(this.dateTimeFormat.AbbreviatedMonthNames);
this._upperAbbrMonthsGenitive = this._toUpperArray(this.dateTimeFormat.AbbreviatedMonthGenitiveNames);
}
return this._getIndex(value, this._upperAbbrMonths, this._upperAbbrMonthsGenitive);
}
function Sys
CultureInfo_getDayIndex(value) {
if (!this._upperDays) {
this._upperDays = this._toUpperArray(this.dateTimeFormat.DayNames);
}
return Array.indexOf(this._upperDays, this._toUpper(value));
}
function Sys
CultureInfo_getAbbrDayIndex(value) {
if (!this._upperAbbrDays) {
this._upperAbbrDays = this._toUpperArray(this.dateTimeFormat.AbbreviatedDayNames);
}
return Array.indexOf(this._upperAbbrDays, this._toUpper(value));
}
function Sys
CultureInfo_toUpperArray(arr) {
var result = [];
for (var i = 0, il = arr.length; i < il; i++) {
result[i] = this._toUpper(arr[i]);
}
return result;
}
function Sys
CultureInfo_toUpper(value) {
return value.split("\u00A0").join(' ').toUpperCase();
}
Sys.CultureInfo.prototype = {
_getDateTimeFormats: Sys
CultureInfo_getDateTimeFormats,
_getIndex: Sys
CultureInfo_getIndex,
_getMonthIndex: Sys
CultureInfo_getMonthIndex,
_getAbbrMonthIndex: Sys
CultureInfo_getAbbrMonthIndex,
_getDayIndex: Sys
CultureInfo_getDayIndex,
_getAbbrDayIndex: Sys
CultureInfo_getAbbrDayIndex,
_toUpperArray: Sys
CultureInfo_toUpperArray,
_toUpper: Sys
CultureInfo_toUpper
}
Sys.CultureInfo.registerClass('Sys.CultureInfo');
Sys.CultureInfo._parse = function Sys
CultureInfo_parse(value) {
var dtf = value.dateTimeFormat;
if (dtf && !dtf.eras) {
dtf.eras = value.eras;
}
return new Sys.CultureInfo(value.name, value.numberFormat, dtf);
}
Sys.CultureInfo.InvariantCulture = Sys.CultureInfo._parse({"name":"","numberFormat":{"CurrencyDecimalDigits":2,"CurrencyDecimalSeparator":".","IsReadOnly":true,"CurrencyGroupSizes":[3],"NumberGroupSizes":[3],"PercentGroupSizes":[3],"CurrencyGroupSeparator":",","CurrencySymbol":"\u00A4","NaNSymbol":"NaN","CurrencyNegativePattern":0,"NumberNegativePattern":1,"PercentPositivePattern":0,"PercentNegativePattern":0,"NegativeInfinitySymbol":"-Infinity","NegativeSign":"-","NumberDecimalDigits":2,"NumberDecimalSeparator":".","NumberGroupSeparator":",","CurrencyPositivePattern":0,"PositiveInfinitySymbol":"Infinity","PositiveSign":"+","PercentDecimalDigits":2,"PercentDecimalSeparator":".","PercentGroupSeparator":",","PercentSymbol":"%","PerMilleSymbol":"\u2030","NativeDigits":["0","1","2","3","4","5","6","7","8","9"],"DigitSubstitution":1},"dateTimeFormat":{"AMDesignator":"AM","Calendar":{"MinSupportedDateTime":"@-62135568000000@","MaxSupportedDateTime":"@253402300799999@","AlgorithmType":1,"CalendarType":1,"Eras":[1],"TwoDigitYearMax":2029,"IsReadOnly":true},"DateSeparator":"/","FirstDayOfWeek":0,"CalendarWeekRule":0,"FullDateTimePattern":"dddd, dd MMMM yyyy HH:mm:ss","LongDatePattern":"dddd, dd MMMM yyyy","LongTimePattern":"HH:mm:ss","MonthDayPattern":"MMMM dd","PMDesignator":"PM","RFC1123Pattern":"ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'","ShortDatePattern":"MM/dd/yyyy","ShortTimePattern":"HH:mm","SortableDateTimePattern":"yyyy\'-\'MM\'-\'dd\'T\'HH\':\'mm\':\'ss","TimeSeparator":":","UniversalSortableDateTimePattern":"yyyy\'-\'MM\'-\'dd HH\':\'mm\':\'ss\'Z\'","YearMonthPattern":"yyyy MMMM","AbbreviatedDayNames":["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],"ShortestDayNames":["Su","Mo","Tu","We","Th","Fr","Sa"],"DayNames":["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],"AbbreviatedMonthNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthNames":["January","February","March","April","May","June","July","August","September","October","November","December",""],"IsReadOnly":true,"NativeCalendarName":"Gregorian Calendar","AbbreviatedMonthGenitiveNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthGenitiveNames":["January","February","March","April","May","June","July","August","September","October","November","December",""]},"eras":[1,"A.D.",null,0]});
if (typeof(__cultureInfo) === "object") {
Sys.CultureInfo.CurrentCulture = Sys.CultureInfo._parse(__cultureInfo);
delete __cultureInfo;
}
else {
Sys.CultureInfo.CurrentCulture = Sys.CultureInfo._parse({"name":"en-US","numberFormat":{"CurrencyDecimalDigits":2,"CurrencyDecimalSeparator":".","IsReadOnly":false,"CurrencyGroupSizes":[3],"NumberGroupSizes":[3],"PercentGroupSizes":[3],"CurrencyGroupSeparator":",","CurrencySymbol":"
_init() {
var replaceChars = ['\\u0000','\\u0001','\\u0002','\\u0003','\\u0004','\\u0005','\\u0006','\\u0007',
'\\b','\\t','\\n','\\u000b','\\f','\\r','\\u000e','\\u000f','\\u0010','\\u0011',
'\\u0012','\\u0013','\\u0014','\\u0015','\\u0016','\\u0017','\\u0018','\\u0019',
'\\u001a','\\u001b','\\u001c','\\u001d','\\u001e','\\u001f'];
Sys.Serialization.JavaScriptSerializer._charsToEscape[0] = '\\';
Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs['\\'] = new RegExp('\\\\', 'g');
Sys.Serialization.JavaScriptSerializer._escapeChars['\\'] = '\\\\';
Sys.Serialization.JavaScriptSerializer._charsToEscape[1] = '"';
Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs['"'] = new RegExp('"', 'g');
Sys.Serialization.JavaScriptSerializer._escapeChars['"'] = '\\"';
for (var i = 0; i < 32; i++) {
var c = String.fromCharCode(i);
Sys.Serialization.JavaScriptSerializer._charsToEscape[i+2] = c;
Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[c] = new RegExp(c, 'g');
Sys.Serialization.JavaScriptSerializer._escapeChars[c] = replaceChars[i];
}
}
Sys.Serialization.JavaScriptSerializer._serializeBooleanWithBuilder = function Sys
SerializationJavaScriptSerializer
_serializeNumberWithBuilder(object, stringBuilder) {
if (isFinite(object)) {
stringBuilder.append(String(object));
}
else {
throw Error.invalidOperation(Sys.Res.cannotSerializeNonFiniteNumbers);
}
}
Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder = function Sys
SerializationJavaScriptSerializer
_serializeWithBuilder(object, stringBuilder, sort, prevObjects) {
var i;
switch (typeof object) {
case 'object':
if (object) {
if (prevObjects){
for( var j = 0; j < prevObjects.length; j++) {
if (prevObjects[j] === object) {
throw Error.invalidOperation(Sys.Res.cannotSerializeObjectWithCycle);
}
}
}
else {
prevObjects = new Array();
}
try {
Array.add(prevObjects, object);
if (Number.isInstanceOfType(object)){
Sys.Serialization.JavaScriptSerializer._serializeNumberWithBuilder(object, stringBuilder);
}
else if (Boolean.isInstanceOfType(object)){
Sys.Serialization.JavaScriptSerializer._serializeBooleanWithBuilder(object, stringBuilder);
}
else if (String.isInstanceOfType(object)){
Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder(object, stringBuilder);
}
else if (Array.isInstanceOfType(object)) {
stringBuilder.append('[');
for (i = 0; i < object.length; ++i) {
if (i > 0) {
stringBuilder.append(',');
}
Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(object[i], stringBuilder,false,prevObjects);
}
stringBuilder.append(']');
}
else {
if (Date.isInstanceOfType(object)) {
stringBuilder.append('"\\/Date(');
stringBuilder.append(object.getTime());
stringBuilder.append(')\\/"');
break;
}
var properties = [];
var propertyCount = 0;
for (var name in object) {
if (name.startsWith('
serialize(object) {
<summary locid="M:J#Sys.Serialization.JavaScriptSerializer.serialize" />
<param name="object" mayBeNull="true">
</param>
<returns type="String">
</returns>
var e = Function._validateParams(arguments, [
{name: "object", mayBeNull: true}
]);
if (e) throw e;
var stringBuilder = new Sys.StringBuilder();
Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(object, stringBuilder, false);
return stringBuilder.toString();
}
Sys.Serialization.JavaScriptSerializer.deserialize = function Sys
SerializationJavaScriptSerializer
EventHandlerList() {
<summary locid="M:J#Sys.EventHandlerList.#ctor" />
if (arguments.length !== 0) throw Error.parameterCount();
this._list = {};
}
function Sys
EventHandlerList_addHandler(id, handler) {
Array.add(this._get
Event(id, true), handler);
}
function Sys
EventHandlerListaddHandler(id, handler) {
<summary locid="M:J#Sys.EventHandlerList.addHandler" />
<param name="id" type="String">
</param>
<param name="handler" type="Function">
</param>
var e = Function._validateParams(arguments, [
{name: "id", type: String},
{name: "handler", type: Function}
]);
if (e) throw e;
this._addHandler(id, handler);
}
function Sys
EventHandlerList_removeHandler(id, handler) {
var evt = this._get
Event(id);
if (!evt) return;
Array.remove(evt, handler);
}
function Sys
EventHandlerListremoveHandler(id, handler) {
<summary locid="M:J#Sys.EventHandlerList.removeHandler" />
<param name="id" type="String">
</param>
<param name="handler" type="Function">
</param>
var e = Function._validateParams(arguments, [
{name: "id", type: String},
{name: "handler", type: Function}
]);
if (e) throw e;
this._removeHandler(id, handler);
}
function Sys
EventHandlerListgetHandler(id) {
<summary locid="M:J#Sys.EventHandlerList.getHandler" />
<param name="id" type="String">
</param>
<returns type="Function">
</returns>
var e = Function._validateParams(arguments, [
{name: "id", type: String}
]);
if (e) throw e;
var evt = this._get
Event(id);
if (!evt || (evt.length === 0)) return null;
evt = Array.clone(evt);
return function(source, args) {
for (var i = 0, l = evt.length; i < l; i++) {
evt[i](source, args);
}
};
}
function Sys
EventHandlerList_get
Event(id, create) {
if (!this._list[id]) {
if (!create) return null;
this._list[id] = [];
}
return this._list[id];
}
Sys.EventHandlerList.prototype = {
_addHandler: Sys
EventHandlerList_addHandler,
addHandler: Sys
EventHandlerListaddHandler,
_removeHandler: Sys
EventHandlerList_removeHandler,
removeHandler: Sys
EventHandlerListremoveHandler,
getHandler: Sys
EventHandlerListgetHandler,
_get
Event: Sys
EventHandlerList_get
Event
}
Sys.EventHandlerList.registerClass('Sys.EventHandlerList');
Sys.CommandEventArgs = function Sys
INotifyPropertyChange() {
<summary locid="M:J#Sys.INotifyPropertyChange.#ctor" />
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
function Sys
INotifyPropertyChangeadd_propertyChanged(handler) {
<summary locid="E:J#Sys.INotifyPropertyChange.propertyChanged" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
throw Error.notImplemented();
}
function Sys
INotifyPropertyChangeremove_propertyChanged(handler) {
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
throw Error.notImplemented();
}
Sys.INotifyPropertyChange.prototype = {
add_propertyChanged: Sys
INotifyPropertyChangeadd_propertyChanged,
remove_propertyChanged: Sys
INotifyPropertyChangeremove_propertyChanged
}
Sys.INotifyPropertyChange.registerInterface('Sys.INotifyPropertyChange');
Sys.PropertyChangedEventArgs = function Sys
INotifyDisposing() {
<summary locid="M:J#Sys.INotifyDisposing.#ctor" />
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
function Sys
INotifyDisposingadd_disposing(handler) {
<summary locid="E:J#Sys.INotifyDisposing.disposing" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
throw Error.notImplemented();
}
function Sys
INotifyDisposingremove_disposing(handler) {
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
throw Error.notImplemented();
}
Sys.INotifyDisposing.prototype = {
add_disposing: Sys
INotifyDisposingadd_disposing,
remove_disposing: Sys
INotifyDisposingremove_disposing
}
Sys.INotifyDisposing.registerInterface("Sys.INotifyDisposing");
Sys.Component = function Sys
find(references[name]);
if (typeof(setter) !== 'function') throw new Error.invalidOperation(String.format(Sys.Res.propertyNotWritable, name));
if (!reference) throw Error.invalidOperation(String.format(Sys.Res.referenceNotFound, references[name]));
setter.apply(component, [reference]);
}
}
var
preventDefault() {
<summary locid="M:J#Sys.UI.DomEvent.preventDefault" />
if (arguments.length !== 0) throw Error.parameterCount();
if (this.rawEvent.preventDefault) {
this.rawEvent.preventDefault();
}
else if (window.event) {
this.rawEvent.returnValue = false;
}
}
function Sys
UIDomEvent
preventDefault,
stopPropagation: Sys
UIDomEvent
addHandler = Sys.UI.DomEvent.addHandler = function Sys
UIDomEvent
addHandlers = Sys.UI.DomEvent.addHandlers = function Sys
UIDomEvent
addHandler(element, name, handler, autoRemove || false);
}
}
var
clearHandlers(element) {
<summary locid="M:J#Sys.UI.DomEvent.clearHandlers" />
<param name="element">
</param>
var e = Function._validateParams(arguments, [
{name: "element"}
]);
if (e) throw e;
Sys.UI.DomEvent._ensureDomNode(element);
Sys.UI.DomEvent._clearHandlers(element, false);
}
Sys.UI.DomEvent._clearHandlers = function Sys
UIDomEvent
removeHandler(element, name, entry.handler);
}
}
}
element._events = null;
}
}
Sys.UI.DomEvent._disposeHandlers = function Sys
UIDomEvent
removeHandler = Sys.UI.DomEvent.removeHandler = function Sys
UIDomEvent
_removeHandler(element, eventName, handler) {
Sys.UI.DomEvent._ensureDomNode(element);
var browserHandler = null;
if ((typeof(element._events) !== 'object') || !element._events) throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);
var cache = element._events
[eventName];
if (!(cache instanceof Array)) throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);
for (var i = 0, l = cache.length; i < l; i++) {
if (cache[i].handler === handler) {
browserHandler = cache[i].browserHandler;
break;
}
}
if (typeof(browserHandler) !== 'function') throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);
if (element.removeEventListener) {
element.removeEventListener(eventName, browserHandler, false);
}
else if (element.detachEvent) {
element.detachEvent('on' + eventName, browserHandler);
}
cache.splice(i, 1);
}
Sys.UI.DomEvent._ensureDomNode = function Sys
UIDomEvent
addCssClass(element, className) {
<summary locid="M:J#Sys.UI.DomElement.addCssClass" />
<param name="element" domElement="true">
</param>
<param name="className" type="String">
</param>
var e = Function._validateParams(arguments, [
{name: "element", domElement: true},
{name: "className", type: String}
]);
if (e) throw e;
if (!Sys.UI.DomElement.containsCssClass(element, className)) {
if (element.className === '') {
element.className = className;
}
else {
element.className += ' ' + className;
}
}
}
Sys.UI.DomElement.containsCssClass = function Sys
UIDomElement
getBounds(element) {
<summary locid="M:J#Sys.UI.DomElement.getBounds" />
<param name="element" domElement="true">
</param>
<returns type="Sys.UI.Bounds">
</returns>
var e = Function._validateParams(arguments, [
{name: "element", domElement: true}
]);
if (e) throw e;
var offset = Sys.UI.DomElement.getLocation(element);
return new Sys.UI.Bounds(offset.x, offset.y, element.offsetWidth || 0, element.offsetHeight || 0);
}
var
getElementById(id, element) {
<summary locid="M:J#Sys.UI.DomElement.getElementById" />
<param name="id" type="String">
</param>
<param name="element" domElement="true" optional="true" mayBeNull="true">
</param>
<returns domElement="true" mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "id", type: String},
{name: "element", mayBeNull: true, domElement: true, optional: true}
]);
if (e) throw e;
if (!element) return document.getElementById(id);
if (element.getElementById) return element.getElementById(id);
var nodeQueue = [];
var childNodes = element.childNodes;
for (var i = 0; i < childNodes.length; i++) {
var node = childNodes[i];
if (node.nodeType == 1) {
nodeQueue[nodeQueue.length] = node;
}
}
while (nodeQueue.length) {
node = nodeQueue.shift();
if (node.id == id) {
return node;
}
childNodes = node.childNodes;
for (i = 0; i < childNodes.length; i++) {
node = childNodes[i];
if (node.nodeType == 1) {
nodeQueue[nodeQueue.length] = node;
}
}
}
return null;
}
if (document.documentElement.getBoundingClientRect) {
Sys.UI.DomElement.getLocation = function Sys
UIDomElement
getLocation(element) {
<summary locid="M:J#Sys.UI.DomElement.getLocation" />
<param name="element" domElement="true">
</param>
<returns type="Sys.UI.Point">
</returns>
var e = Function._validateParams(arguments, [
{name: "element", domElement: true}
]);
if (e) throw e;
if ((element.window && (element.window === element)) || element.nodeType === 9) return new Sys.UI.Point(0,0);
var offsetX = 0, offsetY = 0,
parent,
previous = null,
previousStyle = null,
currentStyle;
for (parent = element; parent; previous = parent, previousStyle = currentStyle, parent = parent.offsetParent) {
currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);
var tagName = parent.tagName ? parent.tagName.toUpperCase() : null;
if ((parent.offsetLeft || parent.offsetTop) &&
((tagName !== "BODY") || (!previousStyle || previousStyle.position !== "absolute"))) {
offsetX += parent.offsetLeft;
offsetY += parent.offsetTop;
}
if (previous && Sys.Browser.version >= 3) {
offsetX += parseInt(currentStyle.borderLeftWidth);
offsetY += parseInt(currentStyle.borderTopWidth);
}
}
currentStyle = Sys.UI.DomElement._getCurrentStyle(element);
var elementPosition = currentStyle ? currentStyle.position : null;
if (!elementPosition || (elementPosition !== "absolute")) {
for (parent = element.parentNode; parent; parent = parent.parentNode) {
tagName = parent.tagName ? parent.tagName.toUpperCase() : null;
if ((tagName !== "BODY") && (tagName !== "HTML") && (parent.scrollLeft || parent.scrollTop)) {
offsetX -= (parent.scrollLeft || 0);
offsetY -= (parent.scrollTop || 0);
}
currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);
var parentPosition = currentStyle ? currentStyle.position : null;
if (parentPosition && (parentPosition === "absolute")) break;
}
}
return new Sys.UI.Point(offsetX, offsetY);
}
}
else {
Sys.UI.DomElement.getLocation = function Sys
UIDomElement
isDomElement(obj) {
<summary locid="M:J#Sys.UI.DomElement.isDomElement" />
<param name="obj">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "obj"}
]);
if (e) throw e;
return Sys._isDomElement(obj);
}
Sys.UI.DomElement.removeCssClass = function Sys
UIDomElement
resolveElement(elementOrElementId, containerElement) {
<summary locid="M:J#Sys.UI.DomElement.resolveElement" />
<param name="elementOrElementId" mayBeNull="true">
</param>
<param name="containerElement" domElement="true" optional="true" mayBeNull="true">
</param>
<returns domElement="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "elementOrElementId", mayBeNull: true},
{name: "containerElement", mayBeNull: true, domElement: true, optional: true}
]);
if (e) throw e;
var el = elementOrElementId;
if (!el) return null;
if (typeof(el) === "string") {
el = Sys.UI.DomElement.getElementById(el, containerElement);
if (!el) {
throw Error.argument("elementOrElementId", String.format(Sys.Res.elementNotFound, elementOrElementId));
}
}
else if(!Sys.UI.DomElement.isDomElement(el)) {
throw Error.argument("elementOrElementId", Sys.Res.expectedElementOrId);
}
return el;
}
Sys.UI.DomElement.raiseBubbleEvent = function Sys
UIDomElement
_raiseBubbleEventFromControl(control, source, args) {
if (!control.onBubbleEvent(source, args)) {
control._raiseBubbleEvent(source, args);
}
}
Sys.UI.DomElement.setLocation = function Sys
UIDomElement
toggleCssClass(element, className) {
<summary locid="M:J#Sys.UI.DomElement.toggleCssClass" />
<param name="element" domElement="true">
</param>
<param name="className" type="String">
</param>
var e = Function._validateParams(arguments, [
{name: "element", domElement: true},
{name: "className", type: String}
]);
if (e) throw e;
if (Sys.UI.DomElement.containsCssClass(element, className)) {
Sys.UI.DomElement.removeCssClass(element, className);
}
else {
Sys.UI.DomElement.addCssClass(element, className);
}
}
Sys.UI.DomElement.getVisibilityMode = function Sys
UIDomElement
setVisibilityMode(element, value) {
<summary locid="M:J#Sys.UI.DomElement.setVisibilityMode" />
<param name="element" domElement="true">
</param>
<param name="value" type="Sys.UI.VisibilityMode">
</param>
var e = Function._validateParams(arguments, [
{name: "element", domElement: true},
{name: "value", type: Sys.UI.VisibilityMode}
]);
if (e) throw e;
Sys.UI.DomElement._ensureOldDisplayMode(element);
if (element._visibilityMode !== value) {
element._visibilityMode = value;
if (Sys.UI.DomElement.getVisible(element) === false) {
if (element._visibilityMode === Sys.UI.VisibilityMode.hide) {
element.style.display = element._oldDisplayMode;
}
else {
element.style.display = 'none';
}
}
element._visibilityMode = value;
}
}
Sys.UI.DomElement.getVisible = function Sys
UIDomElement
setVisible(element, value) {
<summary locid="M:J#Sys.UI.DomElement.setVisible" />
<param name="element" domElement="true">
</param>
<param name="value" type="Boolean">
</param>
var e = Function._validateParams(arguments, [
{name: "element", domElement: true},
{name: "value", type: Boolean}
]);
if (e) throw e;
if (value !== Sys.UI.DomElement.getVisible(element)) {
Sys.UI.DomElement._ensureOldDisplayMode(element);
element.style.visibility = value ? 'visible' : 'hidden';
if (value || (element._visibilityMode === Sys.UI.VisibilityMode.hide)) {
element.style.display = element._oldDisplayMode;
}
else {
element.style.display = 'none';
}
}
}
Sys.UI.DomElement._ensureOldDisplayMode = function Sys
UIDomElement
_getWindow(element) {
var doc = element.ownerDocument || element.document || element;
return doc.defaultView || doc.parentWindow;
}
Sys.UI.DomElement._getCurrentStyle = function Sys
UIDomElement
IContainer() {
throw Error.notImplemented();
}
function Sys
IContaineraddComponent(component) {
<summary locid="M:J#Sys.IContainer.addComponent" />
<param name="component" type="Sys.Component">
</param>
var e = Function._validateParams(arguments, [
{name: "component", type: Sys.Component}
]);
if (e) throw e;
throw Error.notImplemented();
}
function Sys
IContainerremoveComponent(component) {
<summary locid="M:J#Sys.IContainer.removeComponent" />
<param name="component" type="Sys.Component">
</param>
var e = Function._validateParams(arguments, [
{name: "component", type: Sys.Component}
]);
if (e) throw e;
throw Error.notImplemented();
}
function Sys
IContainerfindComponent(id) {
<summary locid="M:J#Sys.IContainer.findComponent" />
<param name="id" type="String">
</param>
<returns type="Sys.Component">
</returns>
var e = Function._validateParams(arguments, [
{name: "id", type: String}
]);
if (e) throw e;
throw Error.notImplemented();
}
function Sys
IContainergetComponents() {
<summary locid="M:J#Sys.IContainer.getComponents" />
<returns type="Array" elementType="Sys.Component">
</returns>
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
Sys.IContainer.prototype = {
addComponent: Sys
IContaineraddComponent,
removeComponent: Sys
IContainerremoveComponent,
findComponent: Sys
IContainerfindComponent,
getComponents: Sys
IContainergetComponents
}
Sys.IContainer.registerInterface("Sys.IContainer");
Sys.ApplicationLoadEventArgs = function Sys
_Application() {
<summary locid="M:J#Sys.Application.#ctor" />
if (arguments.length !== 0) throw Error.parameterCount();
Sys._Application.initializeBase(this);
this._disposableObjects = [];
this._components = {};
this._createdComponents = [];
this._secondPassComponents = [];
this._unloadHandlerDelegate = Function.createDelegate(this, this._unloadHandler);
Sys.UI.DomEvent.addHandler(window, "unload", this._unloadHandlerDelegate);
this._domReady();
}
function Sys
get_isCreatingComponents() {
<value type="Boolean" locid="P:J#Sys.Application.isCreatingComponents">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._creatingComponents;
}
function Sys
get_isDisposing() {
<value type="Boolean" locid="P:J#Sys.Application.isDisposing">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._disposing;
}
function Sys
add_init(handler) {
<summary locid="E:J#Sys.Application.init" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
if (this._initialized) {
handler(this, Sys.EventArgs.Empty);
}
else {
this.get_events().addHandler("init", handler);
}
}
function Sys
remove_init(handler) {
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this.get_events().removeHandler("init", handler);
}
function Sys
add_load(handler) {
<summary locid="E:J#Sys.Application.load" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this.get_events().addHandler("load", handler);
}
function Sys
remove_load(handler) {
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this.get_events().removeHandler("load", handler);
}
function Sys
add_unload(handler) {
<summary locid="E:J#Sys.Application.unload" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this.get_events().addHandler("unload", handler);
}
function Sys
remove_unload(handler) {
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this.get_events().removeHandler("unload", handler);
}
function Sys
addComponent(component) {
<summary locid="M:J#Sys.Application.addComponent" />
<param name="component" type="Sys.Component">
</param>
var e = Function._validateParams(arguments, [
{name: "component", type: Sys.Component}
]);
if (e) throw e;
var id = component.get_id();
if (!id) throw Error.invalidOperation(Sys.Res.cantAddWithoutId);
if (typeof(this._components[id]) !== 'undefined') throw Error.invalidOperation(String.format(Sys.Res.appDuplicateComponent, id));
this._components[id] = component;
}
function Sys
beginCreateComponents() {
<summary locid="M:J#Sys.Application.beginCreateComponents" />
if (arguments.length !== 0) throw Error.parameterCount();
this._creatingComponents = true;
}
function Sys
dispose() {
<summary locid="M:J#Sys.Application.dispose" />
if (arguments.length !== 0) throw Error.parameterCount();
if (!this._disposing) {
this._disposing = true;
if (this._timerCookie) {
window.clearTimeout(this._timerCookie);
delete this._timerCookie;
}
if (this._endRequestHandler) {
Sys.WebForms.PageRequestManager.getInstance().remove_endRequest(this._endRequestHandler);
delete this._endRequestHandler;
}
if (this._beginRequestHandler) {
Sys.WebForms.PageRequestManager.getInstance().remove_beginRequest(this._beginRequestHandler);
delete this._beginRequestHandler;
}
if (window.pageUnload) {
window.pageUnload(this, Sys.EventArgs.Empty);
}
var unloadHandler = this.get_events().getHandler("unload");
if (unloadHandler) {
unloadHandler(this, Sys.EventArgs.Empty);
}
var disposableObjects = Array.clone(this._disposableObjects);
for (var i = 0, l = disposableObjects.length; i < l; i++) {
var object = disposableObjects[i];
if (typeof(object) !== "undefined") {
object.dispose();
}
}
Array.clear(this._disposableObjects);
Sys.UI.DomEvent.removeHandler(window, "unload", this._unloadHandlerDelegate);
if (Sys._ScriptLoader) {
var sl = Sys._ScriptLoader.getInstance();
if(sl) {
sl.dispose();
}
}
Sys._Application.callBaseMethod(this, 'dispose');
}
}
function Sys
disposeElement(element, childNodesOnly) {
<summary locid="M:J#Sys._Application.disposeElement" />
<param name="element">
</param>
<param name="childNodesOnly" type="Boolean">
</param>
var e = Function._validateParams(arguments, [
{name: "element"},
{name: "childNodesOnly", type: Boolean}
]);
if (e) throw e;
if (element.nodeType === 1) {
var children = element.getElementsByTagName("*");
for (var i = children.length - 1; i >= 0; i--) {
this._disposeElementInternal(children[i]);
}
if (!childNodesOnly) {
this._disposeElementInternal(element);
}
}
}
function Sys
endCreateComponents() {
<summary locid="M:J#Sys.Application.endCreateComponents" />
if (arguments.length !== 0) throw Error.parameterCount();
var components = this._secondPassComponents;
for (var i = 0, l = components.length; i < l; i++) {
var component = components[i].component;
Sys
Component_setReferences(component, components[i].references);
component.endUpdate();
}
this._secondPassComponents = [];
this._creatingComponents = false;
}
function Sys
findComponent(id, parent) {
<summary locid="M:J#Sys.Application.findComponent" />
<param name="id" type="String">
</param>
<param name="parent" optional="true" mayBeNull="true">
</param>
<returns type="Sys.Component" mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "id", type: String},
{name: "parent", mayBeNull: true, optional: true}
]);
if (e) throw e;
return (parent ?
((Sys.IContainer.isInstanceOfType(parent)) ?
parent.findComponent(id) :
parent[id] || null) :
Sys.Application._components[id] || null);
}
function Sys
getComponents() {
<summary locid="M:J#Sys.Application.getComponents" />
<returns type="Array" elementType="Sys.Component">
</returns>
if (arguments.length !== 0) throw Error.parameterCount();
var res = [];
var components = this._components;
for (var name in components) {
res[res.length] = components[name];
}
return res;
}
function Sys
initialize() {
<summary locid="M:J#Sys.Application.initialize" />
if (arguments.length !== 0) throw Error.parameterCount();
if(!this.get_isInitialized() && !this._disposing) {
Sys._Application.callBaseMethod(this, 'initialize');
this._raiseInit();
if (this.get_stateString) {
if (Sys.WebForms && Sys.WebForms.PageRequestManager) {
this._beginRequestHandler = Function.createDelegate(this, this._onPageRequestManagerBeginRequest);
Sys.WebForms.PageRequestManager.getInstance().add_beginRequest(this._beginRequestHandler);
this._endRequestHandler = Function.createDelegate(this, this._onPageRequestManagerEndRequest);
Sys.WebForms.PageRequestManager.getInstance().add_endRequest(this._endRequestHandler);
}
var loadedEntry = this.get_stateString();
if (loadedEntry !== this._currentEntry) {
this._navigate(loadedEntry);
}
else {
this._ensureHistory();
}
}
this.raiseLoad();
}
}
function Sys
notifyScriptLoaded() {
<summary locid="M:J#Sys.Application.notifyScriptLoaded" />
if (arguments.length !== 0) throw Error.parameterCount();
}
function Sys
registerDisposableObject(object) {
<summary locid="M:J#Sys.Application.registerDisposableObject" />
<param name="object" type="Sys.IDisposable">
</param>
var e = Function._validateParams(arguments, [
{name: "object", type: Sys.IDisposable}
]);
if (e) throw e;
if (!this._disposing) {
var objects = this._disposableObjects,
i = objects.length;
objects[i] = object;
object.__msdisposeindex = i;
}
}
function Sys
raiseLoad() {
<summary locid="M:J#Sys.Application.raiseLoad" />
if (arguments.length !== 0) throw Error.parameterCount();
var h = this.get_events().getHandler("load");
var args = new Sys.ApplicationLoadEventArgs(Array.clone(this._createdComponents), !!this._loaded);
this._loaded = true;
if (h) {
h(this, args);
}
if (window.pageLoad) {
window.pageLoad(this, args);
}
this._createdComponents = [];
}
function Sys
removeComponent(component) {
<summary locid="M:J#Sys.Application.removeComponent" />
<param name="component" type="Sys.Component">
</param>
var e = Function._validateParams(arguments, [
{name: "component", type: Sys.Component}
]);
if (e) throw e;
var id = component.get_id();
if (id) delete this._components[id];
}
function Sys
unregisterDisposableObject(object) {
<summary locid="M:J#Sys.Application.unregisterDisposableObject" />
<param name="object" type="Sys.IDisposable">
</param>
var e = Function._validateParams(arguments, [
{name: "object", type: Sys.IDisposable}
]);
if (e) throw e;
if (!this._disposing) {
var i = object.__msdisposeindex;
if (typeof(i) === "number") {
var disposableObjects = this._disposableObjects;
delete disposableObjects[i];
delete object.__msdisposeindex;
if (++this._deleteCount > 1000) {
var newArray = [];
for (var j = 0, l = disposableObjects.length; j < l; j++) {
object = disposableObjects[j];
if (typeof(object) !== "undefined") {
object.__msdisposeindex = newArray.length;
newArray.push(object);
}
}
this._disposableObjects = newArray;
this._deleteCount = 0;
}
}
}
}
function Sys
_addComponentToSecondPass(component, references) {
this._secondPassComponents[this._secondPassComponents.length] = {component: component, references: references};
}
function Sys
_disposeComponents(list) {
if (list) {
for (var i = list.length - 1; i >= 0; i--) {
var item = list[i];
if (typeof(item.dispose) === "function") {
item.dispose();
}
}
}
}
function Sys
_disposeElementInternal(element) {
var d = element.dispose;
if (d && typeof(d) === "function") {
element.dispose();
}
else {
var c = element.control;
if (c && typeof(c.dispose) === "function") {
c.dispose();
}
}
var list = element._behaviors;
if (list) {
this._disposeComponents(list);
}
list = element._components;
if (list) {
this._disposeComponents(list);
element._components = null;
}
}
function Sys
_domReady() {
var check, er, app = this;
function init() { app.initialize(); }
var onload = function() {
Sys.UI.DomEvent.removeHandler(window, "load", onload);
init();
}
Sys.UI.DomEvent.addHandler(window, "load", onload);
if (document.addEventListener) {
try {
document.addEventListener("DOMContentLoaded", check = function() {
document.removeEventListener("DOMContentLoaded", check, false);
init();
}, false);
}
catch (er) { }
}
else if (document.attachEvent) {
if ((window == window.top) && document.documentElement.doScroll) {
var timeout, el = document.createElement("div");
check = function() {
try {
el.doScroll("left");
}
catch (er) {
timeout = window.setTimeout(check, 0);
return;
}
el = null;
init();
}
check();
}
else {
document.attachEvent("onreadystatechange", check = function() {
if (document.readyState === "complete") {
document.detachEvent("onreadystatechange", check);
init();
}
});
}
}
}
function Sys
_raiseInit() {
var handler = this.get_events().getHandler("init");
if (handler) {
this.beginCreateComponents();
handler(this, Sys.EventArgs.Empty);
this.endCreateComponents();
}
}
function Sys
_unloadHandler(event) {
this.dispose();
}
Sys._Application.prototype = {
_creatingComponents: false,
_disposing: false,
_deleteCount: 0,
get_isCreatingComponents: Sys
get_isCreatingComponents,
get_isDisposing: Sys
get_isDisposing,
add_init: Sys
add_init,
remove_init: Sys
remove_init,
add_load: Sys
add_load,
remove_load: Sys
remove_load,
add_unload: Sys
add_unload,
remove_unload: Sys
remove_unload,
addComponent: Sys
addComponent,
beginCreateComponents: Sys
beginCreateComponents,
dispose: Sys
dispose,
disposeElement: Sys
disposeElement,
endCreateComponents: Sys
endCreateComponents,
findComponent: Sys
findComponent,
getComponents: Sys
getComponents,
initialize: Sys
initialize,
notifyScriptLoaded: Sys
notifyScriptLoaded,
registerDisposableObject: Sys
registerDisposableObject,
raiseLoad: Sys
raiseLoad,
removeComponent: Sys
removeComponent,
unregisterDisposableObject: Sys
unregisterDisposableObject,
_addComponentToSecondPass: Sys
_addComponentToSecondPass,
_disposeComponents: Sys
_disposeComponents,
_disposeElementInternal: Sys
_disposeElementInternal,
_domReady: Sys
_domReady,
_raiseInit: Sys
_raiseInit,
_unloadHandler: Sys
_unloadHandler
}
Sys._Application.registerClass('Sys._Application', Sys.Component, Sys.IContainer);
Sys.Application = new Sys._Application();
var
get_element() {
<value domElement="true" locid="P:J#Sys.UI.Behavior.element">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._element;
}
function Sys
UIBehavior
' + this.get_name();
}
function Sys
UIBehavior
set_name(value) {
var e = Function._validateParams(arguments, [{name: "value", type: String}]);
if (e) throw e;
if ((value === '') || (value.charAt(0) === ' ') || (value.charAt(value.length - 1) === ' '))
throw Error.argument('value', Sys.Res.invalidId);
if (typeof(this._element[value]) !== 'undefined')
throw Error.invalidOperation(String.format(Sys.Res.behaviorDuplicateName, value));
if (this.get_isInitialized()) throw Error.invalidOperation(Sys.Res.cantSetNameAfterInit);
this._name = value;
}
function Sys
UIBehavior
dispose() {
Sys.UI.Behavior.callBaseMethod(this, 'dispose');
var e = this._element;
if (e) {
var name = this.get_name();
if (name) {
e[name] = null;
}
var behaviors = e._behaviors;
Array.remove(behaviors, this);
if (behaviors.length === 0) {
e._behaviors = null;
}
delete this._element;
}
}
Sys.UI.Behavior.prototype = {
_name: null,
get_element: Sys
UIBehavior
get_id,
get_name: Sys
UIBehavior
set_name,
initialize: Sys
UIBehavior
dispose
}
Sys.UI.Behavior.registerClass('Sys.UI.Behavior', Sys.Component);
Sys.UI.Behavior.getBehaviorByName = function Sys
UIBehavior
getBehaviors(element) {
<summary locid="M:J#Sys.UI.Behavior.getBehaviors" />
<param name="element" domElement="true">
</param>
<returns type="Array" elementType="Sys.UI.Behavior">
</returns>
var e = Function._validateParams(arguments, [
{name: "element", domElement: true}
]);
if (e) throw e;
if (!element._behaviors) return [];
return Array.clone(element._behaviors);
}
Sys.UI.Behavior.getBehaviorsByType = function Sys
UIBehavior
get_element() {
<value domElement="true" locid="P:J#Sys.UI.Control.element">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._element;
}
function Sys
UIControl
set_id(value) {
var e = Function._validateParams(arguments, [{name: "value", type: String}]);
if (e) throw e;
throw Error.invalidOperation(Sys.Res.cantSetId);
}
function Sys
UIControl
set_parent(value) {
var e = Function._validateParams(arguments, [{name: "value", type: Sys.UI.Control}]);
if (e) throw e;
if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
var parents = [this];
var current = value;
while (current) {
if (Array.contains(parents, current)) throw Error.invalidOperation(Sys.Res.circularParentChain);
parents[parents.length] = current;
current = current.get_parent();
}
this._parent = value;
}
function Sys
UIControl
get_visibilityMode() {
<value type="Sys.UI.VisibilityMode" locid="P:J#Sys.UI.Control.visibilityMode">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
return Sys.UI.DomElement.getVisibilityMode(this._element);
}
function Sys
UIControl
get_visible() {
<value type="Boolean" locid="P:J#Sys.UI.Control.visible">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
return Sys.UI.DomElement.getVisible(this._element);
}
function Sys
UIControl
addCssClass(className) {
<summary locid="M:J#Sys.UI.Control.addCssClass" />
<param name="className" type="String">
</param>
var e = Function._validateParams(arguments, [
{name: "className", type: String}
]);
if (e) throw e;
if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
Sys.UI.DomElement.addCssClass(this._element, className);
}
function Sys
UIControl
onBubbleEvent(source, args) {
<summary locid="M:J#Sys.UI.Control.onBubbleEvent" />
<param name="source">
</param>
<param name="args" type="Sys.EventArgs">
</param>
<returns type="Boolean">
</returns>
var e = Function._validateParams(arguments, [
{name: "source"},
{name: "args", type: Sys.EventArgs}
]);
if (e) throw e;
return false;
}
function Sys
UIControl
_raiseBubbleEvent(source, args) {
var currentTarget = this.get_parent();
while (currentTarget) {
if (currentTarget.onBubbleEvent(source, args)) {
return;
}
currentTarget = currentTarget.get_parent();
}
}
function Sys
UIControl
toggleCssClass(className) {
<summary locid="M:J#Sys.UI.Control.toggleCssClass" />
<param name="className" type="String">
</param>
var e = Function._validateParams(arguments, [
{name: "className", type: String}
]);
if (e) throw e;
if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
Sys.UI.DomElement.toggleCssClass(this._element, className);
}
Sys.UI.Control.prototype = {
_parent: null,
_visibilityMode: Sys.UI.VisibilityMode.hide,
get_element: Sys
UIControl
get_id,
set_id: Sys
UIControl
get_parent,
set_parent: Sys
UIControl
get_role,
get_visibilityMode: Sys
UIControl
set_visibilityMode,
get_visible: Sys
UIControl
set_visible,
addCssClass: Sys
UIControl
dispose,
onBubbleEvent: Sys
UIControl
raiseBubbleEvent,
_raiseBubbleEvent: Sys
UIControl
removeCssClass,
toggleCssClass: Sys
UIControl
HistoryEventArgs(state) {
<summary locid="M:J#Sys.HistoryEventArgs.#ctor" />
<param name="state" type="Object">
</param>
var e = Function._validateParams(arguments, [
{name: "state", type: Object}
]);
if (e) throw e;
Sys.HistoryEventArgs.initializeBase(this);
this._state = state;
}
function Sys
HistoryEventArgsget_state() {
<value type="Object" locid="P:J#Sys.HistoryEventArgs.state">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._state;
}
Sys.HistoryEventArgs.prototype = {
get_state: Sys
HistoryEventArgsget_state
}
Sys.HistoryEventArgs.registerClass('Sys.HistoryEventArgs', Sys.EventArgs);
Sys.Application._appLoadHandler = null;
Sys.Application._beginRequestHandler = null;
Sys.Application._clientId = null;
Sys.Application._currentEntry = '';
Sys.Application._endRequestHandler = null;
Sys.Application._history = null;
Sys.Application._enableHistory = false;
Sys.Application._historyEnabledInScriptManager = false;
Sys.Application._historyFrame = null;
Sys.Application._historyInitialized = false;
Sys.Application._historyPointIsNew = false;
Sys.Application._ignoreTimer = false;
Sys.Application._initialState = null;
Sys.Application._state = {};
Sys.Application._timerCookie = 0;
Sys.Application._timerHandler = null;
Sys.Application._uniqueId = null;
Sys._Application.prototype.get_stateString = function Sys
get_stateString() {
<summary locid="M:J#Sys._Application.get_stateString" />
if (arguments.length !== 0) throw Error.parameterCount();
var hash = null;
if (Sys.Browser.agent === Sys.Browser.Firefox) {
var href = window.location.href;
var hashIndex = href.indexOf('#');
if (hashIndex !== -1) {
hash = href.substring(hashIndex + 1);
}
else {
hash = "";
}
return hash;
}
else {
hash = window.location.hash;
}
if ((hash.length > 0) && (hash.charAt(0) === '#')) {
hash = hash.substring(1);
}
return hash;
};
Sys._Application.prototype.get_enableHistory = function Sys
get_enableHistory() {
<summary locid="M:J#Sys._Application.get_enableHistory" />
if (arguments.length !== 0) throw Error.parameterCount();
return this._enableHistory;
};
Sys._Application.prototype.set_enableHistory = function Sys
set_enableHistory(value) {
if (this._initialized && !this._initializing) {
throw Error.invalidOperation(Sys.Res.historyCannotEnableHistory);
}
else if (this._historyEnabledInScriptManager && !value) {
throw Error.invalidOperation(Sys.Res.invalidHistorySettingCombination);
}
this._enableHistory = value;
};
Sys._Application.prototype.add_navigate = function Sys
add_navigate(handler) {
<summary locid="E:J#Sys.Application.navigate" />
<param name="handler" type="Function">
</param>
var e = Function._validateParams(arguments, [
{name: "handler", type: Function}
]);
if (e) throw e;
this.get_events().addHandler("navigate", handler);
};
Sys._Application.prototype.remove_navigate = function Sys
remove_navigate(handler) {
<summary locid="M:J#Sys._Application.remove_navigate" />
<param name="handler" type="Function">
</param>
var e = Function._validateParams(arguments, [
{name: "handler", type: Function}
]);
if (e) throw e;
this.get_events().removeHandler("navigate", handler);
};
Sys._Application.prototype.addHistoryPoint = function Sys
addHistoryPoint(state, title) {
<summary locid="M:J#Sys.Application.addHistoryPoint" />
<param name="state" type="Object">
</param>
<param name="title" type="String" optional="true" mayBeNull="true">
</param>
var e = Function._validateParams(arguments, [
{name: "state", type: Object},
{name: "title", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
if (!this._enableHistory) throw Error.invalidOperation(Sys.Res.historyCannotAddHistoryPointWithHistoryDisabled);
for (var n in state) {
var v = state[n];
var t = typeof(v);
if ((v !== null) && ((t === 'object') || (t === 'function') || (t === 'undefined'))) {
throw Error.argument('state', Sys.Res.stateMustBeStringDictionary);
}
}
this._ensureHistory();
var initialState = this._state;
for (var key in state) {
var value = state[key];
if (value === null) {
if (typeof(initialState[key]) !== 'undefined') {
delete initialState[key];
}
}
else {
initialState[key] = value;
}
}
var entry = this._serializeState(initialState);
this._historyPointIsNew = true;
this._setState(entry, title);
this._raiseNavigate();
};
Sys._Application.prototype.setServerId = function Sys
setServerId(clientId, uniqueId) {
<summary locid="M:J#Sys.Application.setServerId" />
<param name="clientId" type="String">
</param>
<param name="uniqueId" type="String">
</param>
var e = Function._validateParams(arguments, [
{name: "clientId", type: String},
{name: "uniqueId", type: String}
]);
if (e) throw e;
this._clientId = clientId;
this._uniqueId = uniqueId;
};
Sys._Application.prototype.setServerState = function Sys
setServerState(value) {
<summary locid="M:J#Sys.Application.setServerState" />
<param name="value" type="String">
</param>
var e = Function._validateParams(arguments, [
{name: "value", type: String}
]);
if (e) throw e;
this._ensureHistory();
this._state.__s = value;
this._updateHiddenField(value);
};
Sys._Application.prototype._deserializeState = function Sys
_deserializeState(entry) {
var result = {};
entry = entry || '';
var
serverSeparator = entry.indexOf('&&');
if ((
serverSeparator !== -1) && (
serverSeparator + 2 < entry.length)) {
result.__s = entry.substr(
serverSeparator + 2);
entry = entry.substr(0,
serverSeparator);
}
var tokens = entry.split('&');
for (var i = 0, l = tokens.length; i < l; i++) {
var token = tokens[i];
var equal = token.indexOf('=');
if ((equal !== -1) && (equal + 1 < token.length)) {
var name = token.substr(0, equal);
var value = token.substr(equal + 1);
result[name] = decodeURIComponent(value);
}
}
return result;
};
Sys._Application.prototype._enableHistoryInScriptManager = function Sys
_enableHistoryInScriptManager() {
this._enableHistory = true;
this._historyEnabledInScriptManager = true;
};
Sys._Application.prototype._ensureHistory = function Sys
_ensureHistory() {
if (!this._historyInitialized && this._enableHistory) {
if ((Sys.Browser.agent === Sys.Browser.InternetExplorer) && (Sys.Browser.documentMode < 8)) {
this._historyFrame = document.getElementById('__historyFrame');
if (!this._historyFrame) throw Error.invalidOperation(Sys.Res.historyMissingFrame);
this._ignoreIFrame = true;
}
this._timerHandler = Function.createDelegate(this, this._onIdle);
this._timerCookie = window.setTimeout(this._timerHandler, 100);
try {
this._initialState = this._deserializeState(this.get_stateString());
} catch(e) {}
this._historyInitialized = true;
}
};
Sys._Application.prototype._navigate = function Sys
_navigate(entry) {
this._ensureHistory();
var state = this._deserializeState(entry);
if (this._uniqueId) {
var oldServerEntry = this._state.__s || '';
var newServerEntry = state.__s || '';
if (newServerEntry !== oldServerEntry) {
this._updateHiddenField(newServerEntry);
__doPostBack(this._uniqueId, newServerEntry);
this._state = state;
return;
}
}
this._setState(entry);
this._state = state;
this._raiseNavigate();
};
Sys._Application.prototype._onIdle = function Sys
_onIdle() {
delete this._timerCookie;
var entry = this.get_stateString();
if (entry !== this._currentEntry) {
if (!this._ignoreTimer) {
this._historyPointIsNew = false;
this._navigate(entry);
}
}
else {
this._ignoreTimer = false;
}
this._timerCookie = window.setTimeout(this._timerHandler, 100);
};
Sys._Application.prototype._onIFrameLoad = function Sys
_onIFrameLoad(entry) {
this._ensureHistory();
if (!this._ignoreIFrame) {
this._historyPointIsNew = false;
this._navigate(entry);
}
this._ignoreIFrame = false;
};
Sys._Application.prototype._onPageRequestManagerBeginRequest = function Sys
_onPageRequestManagerBeginRequest(sender, args) {
this._ignoreTimer = true;
};
Sys._Application.prototype._onPageRequestManagerEndRequest = function Sys
_onPageRequestManagerEndRequest(sender, args) {
var dataItem = args.get_dataItems()[this._clientId];
var eventTarget = document.getElementById("__EVENTTARGET");
if (eventTarget && eventTarget.value === this._uniqueId) {
eventTarget.value = '';
}
if (typeof(dataItem) !== 'undefined') {
this.setServerState(dataItem);
this._historyPointIsNew = true;
}
else {
this._ignoreTimer = false;
}
var entry = this._serializeState(this._state);
if (entry !== this._currentEntry) {
this._ignoreTimer = true;
this._setState(entry);
this._raiseNavigate();
}
};
Sys._Application.prototype._raiseNavigate = function Sys
_raiseNavigate() {
var h = this.get_events().getHandler("navigate");
var stateClone = {};
for (var key in this._state) {
if (key !== '__s') {
stateClone[key] = this._state[key];
}
}
var args = new Sys.HistoryEventArgs(stateClone);
if (h) {
h(this, args);
}
var err;
try {
if ((Sys.Browser.agent === Sys.Browser.Firefox) && window.location.hash &&
(!window.frameElement || window.top.location.hash)) {
window.history.go(0);
}
}
catch(err) {
}
};
Sys._Application.prototype._serializeState = function Sys
_serializeState(state) {
var serialized = [];
for (var key in state) {
var value = state[key];
if (key === '__s') {
var
serverState = value;
}
else {
if (key.indexOf('=') !== -1) throw Error.argument('state', Sys.Res.stateFieldNameInvalid);
serialized[serialized.length] = key + '=' + encodeURIComponent(value);
}
}
return serialized.join('&') + (
serverState ? '&&' +
serverState : '');
};
Sys._Application.prototype._setState = function Sys
_setState(entry, title) {
if (this._enableHistory) {
entry = entry || '';
if (entry !== this._currentEntry) {
if (window.theForm) {
var action = window.theForm.action;
var hashIndex = action.indexOf('#');
window.theForm.action = ((hashIndex !== -1) ? action.substring(0, hashIndex) : action) + '#' + entry;
}
if (this._historyFrame && this._historyPointIsNew) {
this._ignoreIFrame = true;
var frameDoc = this._historyFrame.contentWindow.document;
frameDoc.open("javascript:'
<html></html>'");
frameDoc.write("
<html><head><title>" + (title || document.title) +
"
</title><scri" + "pt type=\"text/javascript\">parent.Sys.Application._onIFrameLoad(" +
Sys.Serialization.JavaScriptSerializer.serialize(entry) +
");
</scri" + "pt>
</head><body></body></html>");
frameDoc.close();
}
this._ignoreTimer = false;
this._currentEntry = entry;
if (this._historyFrame || this._historyPointIsNew) {
var currentHash = this.get_stateString();
if (entry !== currentHash) {
var loc = document.location;
if (loc.href.length - loc.hash.length + entry.length > 1024) {
throw Error.invalidOperation(Sys.Res.urlMustBeLessThan1024chars);
}
window.location.hash = entry;
this._currentEntry = this.get_stateString();
if ((typeof(title) !== 'undefined') && (title !== null)) {
document.title = title;
}
}
}
this._historyPointIsNew = false;
}
}
};
Sys._Application.prototype._updateHiddenField = function Sys
_updateHiddenField(value) {
if (this._clientId) {
var
serverStateField = document.getElementById(this._clientId);
if (
serverStateField) {
serverStateField.value = value;
}
}
};
if (!window.XMLHttpRequest) {
window.XMLHttpRequest = function window
get_webRequest() {
<value type="Sys.Net.WebRequest" locid="P:J#Sys.Net.WebRequestExecutor.webRequest">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._webRequest;
}
function Sys
NetWebRequestExecutor
get_started() {
<value type="Boolean" locid="P:J#Sys.Net.WebRequestExecutor.started">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
function Sys
NetWebRequestExecutor
get_timedOut() {
<value type="Boolean" locid="P:J#Sys.Net.WebRequestExecutor.timedOut">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
function Sys
NetWebRequestExecutor
get_responseData() {
<value type="String" locid="P:J#Sys.Net.WebRequestExecutor.responseData">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
function Sys
NetWebRequestExecutor
get_status
Text() {
<value type="String" locid="P:J#Sys.Net.WebRequestExecutor.statusText">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
function Sys
NetWebRequestExecutor
get_object() {
<value locid="P:J#Sys.Net.WebRequestExecutor.object">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
if (!this._resultObject) {
this._resultObject = Sys.Serialization.JavaScriptSerializer.deserialize(this.get_responseData());
}
return this._resultObject;
}
function Sys
NetWebRequestExecutor
abort() {
<summary locid="M:J#Sys.Net.WebRequestExecutor.abort" />
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
function Sys
NetWebRequestExecutor
getAllResponseHeaders() {
<summary locid="M:J#Sys.Net.WebRequestExecutor.getAllResponseHeaders" />
if (arguments.length !== 0) throw Error.parameterCount();
throw Error.notImplemented();
}
Sys.Net.WebRequestExecutor.prototype = {
get_webRequest: Sys
NetWebRequestExecutor
_set_webRequest,
get_started: Sys
NetWebRequestExecutor
get_responseAvailable,
get_timedOut: Sys
NetWebRequestExecutor
get_aborted,
get_responseData: Sys
NetWebRequestExecutor
get_statusCode,
get_status
Text: Sys
NetWebRequestExecutor
get_xml,
get_object: Sys
NetWebRequestExecutor
executeRequest,
abort: Sys
NetWebRequestExecutor
getResponseHeader,
getAllResponseHeaders: Sys
NetWebRequestExecutor
get_timedOut() {
<value type="Boolean" locid="P:J#Sys.Net.XMLHttpExecutor.timedOut">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._timedOut;
}
function Sys
NetXMLHttpExecutor
get_responseAvailable() {
<value type="Boolean" locid="P:J#Sys.Net.XMLHttpExecutor.responseAvailable">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._responseAvailable;
}
function Sys
NetXMLHttpExecutor
executeRequest() {
<summary locid="M:J#Sys.Net.XMLHttpExecutor.executeRequest" />
if (arguments.length !== 0) throw Error.parameterCount();
this._webRequest = this.get_webRequest();
if (this._started) {
throw Error.invalidOperation(String.format(Sys.Res.cannotCallOnceStarted, 'executeRequest'));
}
if (this._webRequest === null) {
throw Error.invalidOperation(Sys.Res.nullWebRequest);
}
var body = this._webRequest.get_body();
var headers = this._webRequest.get_headers();
this._xmlHttpRequest = new XMLHttpRequest();
this._xmlHttpRequest.onreadystatechange = this._onReadyStateChange;
var verb = this._webRequest.get_httpVerb();
this._xmlHttpRequest.open(verb, this._webRequest.getResolvedUrl(), true );
this._xmlHttpRequest.setRequestHeader("X-Requested-With", "XMLHttpRequest");
if (headers) {
for (var header in headers) {
var val = headers[header];
if (typeof(val) !== "function")
this._xmlHttpRequest.setRequestHeader(header, val);
}
}
if (verb.toLowerCase() === "post") {
if ((headers === null) || !headers['Content-Type']) {
this._xmlHttpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8');
}
if (!body) {
body = "";
}
}
var timeout = this._webRequest.get_timeout();
if (timeout > 0) {
this._timer = window.setTimeout(Function.createDelegate(this, this._onTimeout), timeout);
}
this._xmlHttpRequest.send(body);
this._started = true;
}
function Sys
NetXMLHttpExecutor
getAllResponseHeaders() {
<summary locid="M:J#Sys.Net.XMLHttpExecutor.getAllResponseHeaders" />
<returns type="String">
</returns>
if (arguments.length !== 0) throw Error.parameterCount();
if (!this._responseAvailable) {
throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'getAllResponseHeaders'));
}
if (!this._xmlHttpRequest) {
throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'getAllResponseHeaders'));
}
return this._xmlHttpRequest.getAllResponseHeaders();
}
function Sys
NetXMLHttpExecutor
get_statusCode() {
<value type="Number" locid="P:J#Sys.Net.XMLHttpExecutor.statusCode">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
if (!this._responseAvailable) {
throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_statusCode'));
}
if (!this._xmlHttpRequest) {
throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_statusCode'));
}
var result = 0;
try {
result = this._xmlHttpRequest.status;
}
catch(ex) {
}
return result;
}
function Sys
NetXMLHttpExecutor
get_xml() {
<value locid="P:J#Sys.Net.XMLHttpExecutor.xml">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
if (!this._responseAvailable) {
throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_xml'));
}
if (!this._xmlHttpRequest) {
throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_xml'));
}
var xml = this._xmlHttpRequest.responseXML;
if (!xml || !xml.documentElement) {
xml = Sys.Net.XMLDOM(this._xmlHttpRequest.responseText);
if (!xml || !xml.documentElement)
return null;
}
else if (navigator.userAgent.indexOf('MSIE') !== -1) {
xml.setProperty('SelectionLanguage', 'XPath');
}
if (xml.documentElement.namespaceURI === "
http://www.mozilla.org/newlayout/xml/parsererror.xml" &&
xml.documentElement.tagName === "parsererror") {
return null;
}
if (xml.documentElement.firstChild && xml.documentElement.firstChild.tagName === "parsererror") {
return null;
}
return xml;
}
function Sys
NetXMLHttpExecutor
get_timedOut,
get_started: Sys
NetXMLHttpExecutor
get_responseAvailable,
get_aborted: Sys
NetXMLHttpExecutor
executeRequest,
getResponseHeader: Sys
NetXMLHttpExecutor
getAllResponseHeaders,
get_responseData: Sys
NetXMLHttpExecutor
get_statusCode,
get_status
Text: Sys
NetXMLHttpExecutor
get_xml,
abort: Sys
NetXMLHttpExecutor
add_invokingRequest(handler) {
<summary locid="E:J#Sys.Net.WebRequestManager.invokingRequest" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this._get_eventHandlerList().addHandler("invokingRequest", handler);
}
function Sys
Net_WebRequestManager
add_completedRequest(handler) {
<summary locid="E:J#Sys.Net.WebRequestManager.completedRequest" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this._get_eventHandlerList().addHandler("completedRequest", handler);
}
function Sys
Net_WebRequestManager
_get_eventHandlerList() {
if (!this._events) {
this._events = new Sys.EventHandlerList();
}
return this._events;
}
function Sys
Net_WebRequestManager
set_defaultTimeout(value) {
var e = Function._validateParams(arguments, [{name: "value", type: Number}]);
if (e) throw e;
if (value < 0) {
throw Error.argumentOutOfRange("value", value, Sys.Res.invalidTimeout);
}
this._defaultTimeout = value;
}
function Sys
Net_WebRequestManager
set_defaultExecutorType(value) {
var e = Function._validateParams(arguments, [{name: "value", type: String}]);
if (e) throw e;
this._defaultExecutorType = value;
}
function Sys
Net_WebRequestManager
add_invokingRequest,
remove_invokingRequest: Sys
Net_WebRequestManager
add_completedRequest,
remove_completedRequest: Sys
Net_WebRequestManager
_get_eventHandlerList,
get_defaultTimeout: Sys
Net_WebRequestManager
set_defaultTimeout,
get_defaultExecutorType: Sys
Net_WebRequestManager
set_defaultExecutorType,
executeRequest: Sys
Net_WebRequestManager
get_webRequest() {
<value type="Sys.Net.WebRequest" locid="P:J#Sys.Net.NetworkRequestEventArgs.webRequest">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._webRequest;
}
Sys.Net.NetworkRequestEventArgs.prototype = {
get_webRequest: Sys
NetNetworkRequestEventArgs
add_completed(handler) {
<summary locid="E:J#Sys.Net.WebRequest.completed" />
var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
if (e) throw e;
this._get_eventHandlerList().addHandler("completed", handler);
}
function Sys
NetWebRequest
completed(eventArgs) {
<summary locid="M:J#Sys.Net.WebRequest.completed" />
<param name="eventArgs" type="Sys.EventArgs">
</param>
var e = Function._validateParams(arguments, [
{name: "eventArgs", type: Sys.EventArgs}
]);
if (e) throw e;
var handler = Sys.Net.WebRequestManager._get_eventHandlerList().getHandler("completedRequest");
if (handler) {
handler(this._executor, eventArgs);
}
handler = this._get_eventHandlerList().getHandler("completed");
if (handler) {
handler(this._executor, eventArgs);
}
}
function Sys
NetWebRequest
get_url() {
<value type="String" locid="P:J#Sys.Net.WebRequest.url">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._url;
}
function Sys
NetWebRequest
get_headers() {
<value locid="P:J#Sys.Net.WebRequest.headers">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._headers;
}
function Sys
NetWebRequest
set_httpVerb(value) {
var e = Function._validateParams(arguments, [{name: "value", type: String}]);
if (e) throw e;
if (value.length === 0) {
throw Error.argument('value', Sys.Res.invalidHttpVerb);
}
this._httpVerb = value;
}
function Sys
NetWebRequest
set_body(value) {
var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
if (e) throw e;
this._body = value;
}
function Sys
NetWebRequest
set_userContext(value) {
var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
if (e) throw e;
this._userContext = value;
}
function Sys
NetWebRequest
set_executor(value) {
var e = Function._validateParams(arguments, [{name: "value", type: Sys.Net.WebRequestExecutor}]);
if (e) throw e;
if (this._executor !== null && this._executor.get_started()) {
throw Error.invalidOperation(Sys.Res.setExecutorAfterActive);
}
this._executor = value;
this._executor._set_webRequest(this);
}
function Sys
NetWebRequest
set_timeout(value) {
var e = Function._validateParams(arguments, [{name: "value", type: Number}]);
if (e) throw e;
if (value < 0) {
throw Error.argumentOutOfRange("value", value, Sys.Res.invalidTimeout);
}
this._timeout = value;
}
function Sys
NetWebRequest
invoke() {
<summary locid="M:J#Sys.Net.WebRequest.invoke" />
if (arguments.length !== 0) throw Error.parameterCount();
if (this._invokeCalled) {
throw Error.invalidOperation(Sys.Res.invokeCalledTwice);
}
Sys.Net.WebRequestManager.executeRequest(this);
this._invokeCalled = true;
}
Sys.Net.WebRequest.prototype = {
add_completed: Sys
NetWebRequest
remove_completed,
completed: Sys
NetWebRequest
_get_eventHandlerList,
get_url: Sys
NetWebRequest
set_url,
get_headers: Sys
NetWebRequest
get_httpVerb,
set_httpVerb: Sys
NetWebRequest
get_body,
set_body: Sys
NetWebRequest
get_userContext,
set_userContext: Sys
NetWebRequest
get_executor,
set_executor: Sys
NetWebRequest
get_timeout,
set_timeout: Sys
NetWebRequest
getResolvedUrl,
invoke: Sys
NetWebRequest
_resolveUrl(url, baseUrl) {
if (url && url.indexOf('://') !== -1) {
return url;
}
if (!baseUrl || baseUrl.length === 0) {
var baseElement = document.getElementsByTagName('base')[0];
if (baseElement && baseElement.href && baseElement.href.length > 0) {
baseUrl = baseElement.href;
}
else {
baseUrl = document.URL;
}
}
var qsStart = baseUrl.indexOf('?');
if (qsStart !== -1) {
baseUrl = baseUrl.substr(0, qsStart);
}
qsStart = baseUrl.indexOf('#');
if (qsStart !== -1) {
baseUrl = baseUrl.substr(0, qsStart);
}
baseUrl = baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1);
if (!url || url.length === 0) {
return baseUrl;
}
if (url.charAt(0) === '/') {
var slashslash = baseUrl.indexOf('://');
if (slashslash === -1) {
throw Error.argument("baseUrl", Sys.Res.badBaseUrl1);
}
var nextSlash = baseUrl.indexOf('/', slashslash + 3);
if (nextSlash === -1) {
throw Error.argument("baseUrl", Sys.Res.badBaseUrl2);
}
return baseUrl.substr(0, nextSlash) + url;
}
else {
var lastSlash = baseUrl.lastIndexOf('/');
if (lastSlash === -1) {
throw Error.argument("baseUrl", Sys.Res.badBaseUrl3);
}
return baseUrl.substr(0, lastSlash+1) + url;
}
}
Sys.Net.WebRequest._createQueryString = function Sys
NetWebRequest
_createUrl(url, queryString, addParams) {
if (!queryString && !addParams) {
return url;
}
var qs = Sys.Net.WebRequest._createQueryString(queryString, null, addParams);
return qs.length
? url + ((url && url.indexOf('?') >= 0) ? "&" : "?") + qs
: url;
}
Sys.Net.WebRequest.registerClass('Sys.Net.WebRequest');
Sys._ScriptLoaderTask = function Sys
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
addHandler(this._scriptElement, 'load', this._scriptLoadDelegate);
}
else {
_ScriptLoaderTask
removeHandler(scriptElement, 'load', this._scriptLoadDelegate);
}
else {
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
_ScriptLoaderTask
get_timeout() {
<value type="Number" locid="P:J#Sys.Net.WebServiceProxy.timeout">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._timeout || 0;
}
function Sys
NetWebServiceProxy
get_defaultUserContext() {
<value mayBeNull="true" locid="P:J#Sys.Net.WebServiceProxy.defaultUserContext">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return (typeof(this._userContext) === "undefined") ? null : this._userContext;
}
function Sys
NetWebServiceProxy
get_defaultSucceededCallback() {
<value type="Function" mayBeNull="true" locid="P:J#Sys.Net.WebServiceProxy.defaultSucceededCallback">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._succeeded || null;
}
function Sys
NetWebServiceProxy
get_defaultFailedCallback() {
<value type="Function" mayBeNull="true" locid="P:J#Sys.Net.WebServiceProxy.defaultFailedCallback">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._failed || null;
}
function Sys
NetWebServiceProxy
get_enableJsonp() {
<value type="Boolean" locid="P:J#Sys.Net.WebServiceProxy.enableJsonp">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return !!this._jsonp;
}
function Sys
NetWebServiceProxy
get_path() {
<value type="String" locid="P:J#Sys.Net.WebServiceProxy.path">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._path || null;
}
function Sys
NetWebServiceProxy
get_jsonpCallbackParameter() {
<value type="String" locid="P:J#Sys.Net.WebServiceProxy.jsonpCallbackParameter">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._callbackParameter || "callback";
}
function Sys
NetWebServiceProxy
_invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext) {
<summary locid="M:J#Sys.Net.WebServiceProxy._invoke" />
<param name="servicePath" type="String">
</param>
<param name="methodName" type="String">
</param>
<param name="useGet" type="Boolean">
</param>
<param name="params">
</param>
<param name="onSuccess" type="Function" mayBeNull="true" optional="true">
</param>
<param name="onFailure" type="Function" mayBeNull="true" optional="true">
</param>
<param name="userContext" mayBeNull="true" optional="true">
</param>
<returns type="Sys.Net.WebRequest" mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "servicePath", type: String},
{name: "methodName", type: String},
{name: "useGet", type: Boolean},
{name: "params"},
{name: "onSuccess", type: Function, mayBeNull: true, optional: true},
{name: "onFailure", type: Function, mayBeNull: true, optional: true},
{name: "userContext", mayBeNull: true, optional: true}
]);
if (e) throw e;
onSuccess = onSuccess || this.get_defaultSucceededCallback();
onFailure = onFailure || this.get_defaultFailedCallback();
if (userContext === null || typeof userContext === 'undefined') userContext = this.get_defaultUserContext();
return Sys.Net.WebServiceProxy.invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext, this.get_timeout(), this.get_enableJsonp(), this.get_jsonpCallbackParameter());
}
Sys.Net.WebServiceProxy.prototype = {
get_timeout: Sys
NetWebServiceProxy
set_timeout,
get_defaultUserContext: Sys
NetWebServiceProxy
set_defaultUserContext,
get_defaultSucceededCallback: Sys
NetWebServiceProxy
set_defaultSucceededCallback,
get_defaultFailedCallback: Sys
NetWebServiceProxy
set_defaultFailedCallback,
get_enableJsonp: Sys
NetWebServiceProxy
set_enableJsonp,
get_path: Sys
NetWebServiceProxy
set_path,
get_jsonpCallbackParameter: Sys
NetWebServiceProxy
set_jsonpCallbackParameter,
_invoke: Sys
NetWebServiceProxy
invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext, timeout, enableJsonp, jsonpCallbackParameter) {
<summary locid="M:J#Sys.Net.WebServiceProxy.invoke" />
<param name="servicePath" type="String">
</param>
<param name="methodName" type="String" mayBeNull="true" optional="true">
</param>
<param name="useGet" type="Boolean" optional="true">
</param>
<param name="params" mayBeNull="true" optional="true">
</param>
<param name="onSuccess" type="Function" mayBeNull="true" optional="true">
</param>
<param name="onFailure" type="Function" mayBeNull="true" optional="true">
</param>
<param name="userContext" mayBeNull="true" optional="true">
</param>
<param name="timeout" type="Number" optional="true">
</param>
<param name="enableJsonp" type="Boolean" optional="true" mayBeNull="true">
</param>
<param name="jsonpCallbackParameter" type="String" optional="true" mayBeNull="true">
</param>
<returns type="Sys.Net.WebRequest" mayBeNull="true">
</returns>
var e = Function._validateParams(arguments, [
{name: "servicePath", type: String},
{name: "methodName", type: String, mayBeNull: true, optional: true},
{name: "useGet", type: Boolean, optional: true},
{name: "params", mayBeNull: true, optional: true},
{name: "onSuccess", type: Function, mayBeNull: true, optional: true},
{name: "onFailure", type: Function, mayBeNull: true, optional: true},
{name: "userContext", mayBeNull: true, optional: true},
{name: "timeout", type: Number, optional: true},
{name: "enableJsonp", type: Boolean, mayBeNull: true, optional: true},
{name: "jsonpCallbackParameter", type: String, mayBeNull: true, optional: true}
]);
if (e) throw e;
var schemeHost = (enableJsonp !== false) ? Sys.Net.WebServiceProxy._xdomain.exec(servicePath) : null,
tempCallback, jsonp = schemeHost && (schemeHost.length === 3) &&
((schemeHost[1] !== location.protocol) || (schemeHost[2] !== location.host));
useGet = jsonp || useGet;
if (jsonp) {
jsonpCallbackParameter = jsonpCallbackParameter || "callback";
tempCallback = "_jsonp" + Sys._jsonp++;
}
if (!params) params = {};
var urlParams = params;
if (!useGet || !urlParams) urlParams = {};
var script, error, timeoutcookie = null, loader, body = null,
url = Sys.Net.WebRequest._createUrl(methodName
? (servicePath+"/"+encodeURIComponent(methodName))
: servicePath, urlParams, jsonp ? (jsonpCallbackParameter + "=Sys." + tempCallback) : null);
if (jsonp) {
script = document.createElement("script");
script.src = url;
loader = new Sys._ScriptLoaderTask(script, function(script, loaded) {
if (!loaded || tempCallback) {
jsonpComplete({ Message: String.format(Sys.Res.webServiceFailedNoMsg, methodName) }, -1);
}
});
function jsonpComplete(data, statusCode) {
if (timeoutcookie !== null) {
window.clearTimeout(timeoutcookie);
timeoutcookie = null;
}
loader.dispose();
delete Sys
[tempCallback];
tempCallback = null;
if ((typeof(statusCode) !== "undefined") && (statusCode !== 200)) {
if (onFailure) {
error = new Sys.Net.WebServiceError(false,
data.Message || String.format(Sys.Res.webServiceFailedNoMsg, methodName),
data.StackTrace || null,
data.ExceptionType || null,
data);
error._statusCode = statusCode;
onFailure(error, userContext, methodName);
}
else {
if (data.StackTrace && data.Message) {
error = data.StackTrace + "-- " + data.Message;
}
else {
error = data.StackTrace || data.Message;
}
error = String.format(error ? Sys.Res.webServiceFailed : Sys.Res.webServiceFailedNoMsg, methodName, error);
throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));
}
}
else if (onSuccess) {
onSuccess(data, userContext, methodName);
}
}
Sys
[tempCallback] = jsonpComplete;
loader.execute();
return null;
}
var request = new Sys.Net.WebRequest();
request.set_url(url);
request.get_headers()['Content-Type'] = 'application/json; charset=utf-8';
if (!useGet) {
body = Sys.Serialization.JavaScriptSerializer.serialize(params);
if (body === "{}") body = "";
}
request.set_body(body);
request.add_completed(onComplete);
if (timeout && timeout > 0) request.set_timeout(timeout);
request.invoke();
function onComplete(response, eventArgs) {
if (response.get_responseAvailable()) {
var statusCode = response.get_statusCode();
var result = null;
try {
var contentType = response.getResponseHeader("Content-Type");
if (contentType.startsWith("application/json")) {
result = response.get_object();
}
else if (contentType.startsWith("text/xml")) {
result = response.get_xml();
}
else {
result = response.get_responseData();
}
} catch (ex) {
}
var error = response.getResponseHeader("jsonerror");
var errorObj = (error === "true");
if (errorObj) {
if (result) {
result = new Sys.Net.WebServiceError(false, result.Message, result.StackTrace, result.ExceptionType, result);
}
}
else if (contentType.startsWith("application/json")) {
result = (!result || (typeof(result.d) === "undefined")) ? result : result.d;
}
if (((statusCode < 200) || (statusCode >= 300)) || errorObj) {
if (onFailure) {
if (!result || !errorObj) {
result = new Sys.Net.WebServiceError(false , String.format(Sys.Res.webServiceFailedNoMsg, methodName));
}
result._statusCode = statusCode;
onFailure(result, userContext, methodName);
}
else {
if (result && errorObj) {
error = result.get_exceptionType() + "-- " + result.get_message();
}
else {
error = response.get_responseData();
}
throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));
}
}
else if (onSuccess) {
onSuccess(result, userContext, methodName);
}
}
else {
var msg;
if (response.get_timedOut()) {
msg = String.format(Sys.Res.webServiceTimedOut, methodName);
}
else {
msg = String.format(Sys.Res.webServiceFailedNoMsg, methodName)
}
if (onFailure) {
onFailure(new Sys.Net.WebServiceError(response.get_timedOut(), msg, "", ""), userContext, methodName);
}
else {
throw Sys.Net.WebServiceProxy._createFailedError(methodName, msg);
}
}
}
return request;
}
Sys.Net.WebServiceProxy._createFailedError = function Sys
NetWebServiceProxy
_defaultFailedCallback(err, methodName) {
var error = err.get_exceptionType() + "-- " + err.get_message();
throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));
}
Sys.Net.WebServiceProxy._generateTypedConstructor = function Sys
NetWebServiceProxy
get_timedOut() {
<value type="Boolean" locid="P:J#Sys.Net.WebServiceError.timedOut">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._timedOut;
}
function Sys
NetWebServiceError
get_message() {
<value type="String" locid="P:J#Sys.Net.WebServiceError.message">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._message;
}
function Sys
NetWebServiceError
get_exceptionType() {
<value type="String" locid="P:J#Sys.Net.WebServiceError.exceptionType">
</value>
if (arguments.length !== 0) throw Error.parameterCount();
return this._exceptionType || "";
}
function Sys
NetWebServiceError
get_timedOut,
get_statusCode: Sys
NetWebServiceError
get_message,
get_stackTrace: Sys
NetWebServiceError
get_exceptionType,
get_errorObject: Sys
NetWebServiceError
