diff --git a/.gitea/workflows/pipeline.yml b/.gitea/workflows/pipeline.yml
new file mode 100644
index 0000000..604cfc2
--- /dev/null
+++ b/.gitea/workflows/pipeline.yml
@@ -0,0 +1,106 @@
+# .gitea/workflows/cicd.yaml
+name: Build and Deploy Angular App (Artifacts, Gitea-safe)
+on:
+ push:
+ branches: [ main ]
+jobs:
+ # ---------- TEST ----------
+ test:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+ - name: Set up Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: '20'
+ - name: Install dependencies
+ run: npm ci
+ - name: Run tests
+ run: npx ng test --watch=false
+ # ---------- BUILD ----------
+ build:
+ needs: test
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+ - name: Build Docker image
+ run: docker build -t niayesh-hospital:latest .
+ - name: Save Docker image to tar
+ run: docker save niayesh-hospital:latest > niayesh-hospital.tar
+ # IMPORTANT: use v3 on Gitea
+ - name: Upload image artifact
+ uses: actions/upload-artifact@v3
+ with:
+ name: app-image
+ path: niayesh-hospital.tar
+ if-no-files-found: error
+ # ---------- SCAN ----------
+ scan:
+ needs: build
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+ # IMPORTANT: use v3 on Gitea
+ - name: Download image artifact
+ uses: actions/download-artifact@v3
+ with:
+ name: app-image
+ path: . # place niayesh-hospital.tar in the workspace root
+ - name: Load Docker image from artifact
+ run: docker load -i niayesh-hospital.tar
+ - name: Scan image with Trivy
+ run: |
+ docker run --rm \
+ -v /var/run/docker.sock:/var/run/docker.sock \
+ aquasec/trivy:latest \
+ image --exit-code 1 --severity CRITICAL,HIGH --no-progress niayesh-hospital:latest
+ # ---------- DEPLOY ----------
+ deploy:
+ needs: [build, scan]
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+ # IMPORTANT: use v3 on Gitea
+ - name: Download image artifact
+ uses: actions/download-artifact@v3
+ with:
+ name: app-image
+ path: .
+ - name: Set up SSH
+ run: |
+ apt update && apt install -y openssh-client
+ mkdir -p ~/.ssh
+ echo "${{ secrets.SSH_PRIVATE_KEY }}" > ~/.ssh/id_ed25519
+ chmod 600 ~/.ssh/id_ed25519
+ eval "$(ssh-agent -s)"
+ ssh-add ~/.ssh/id_ed25519
+ ssh-keyscan -p ${{ secrets.SERVER_PORT }} ${{ secrets.SERVER_HOST }} >> ~/.ssh/known_hosts
+ - name: Copy files to server
+ run: |
+ scp -o StrictHostKeyChecking=no -P ${{ secrets.SERVER_PORT }} \
+ niayesh-hospital.tar \
+ ${{ secrets.SERVER_USER }}@${{ secrets.SERVER_HOST }}:"${{ secrets.DEPLOY_PATH }}/niayesh-hospital.tar"
+ scp -o StrictHostKeyChecking=no -P ${{ secrets.SERVER_PORT }} \
+ docker-compose.yml \
+ ${{ secrets.SERVER_USER }}@${{ secrets.SERVER_HOST }}:"${{ secrets.DEPLOY_PATH }}/docker-compose.yml"
+ - name: Deploy on server
+ run: |
+ ssh -o StrictHostKeyChecking=no -p ${{ secrets.SERVER_PORT }} \
+ ${{ secrets.SERVER_USER }}@${{ secrets.SERVER_HOST }} << 'EOF'
+ set -e
+ cd "${{ secrets.DEPLOY_PATH }}"
+ # Load image and restart stack
+ docker load -i niayesh-hospital.tar
+ if [ ! -f docker-compose.yml ]; then
+ echo "ERROR: docker-compose.yml not found in $(pwd)" >&2
+ ls -la
+ exit 1
+ fi
+ docker compose -f docker-compose.yml down
+ docker compose -f docker-compose.yml up -d --remove-orphans
+ rm -f niayesh-hospital.tar
+ EOF
\ No newline at end of file
diff --git a/angular.json b/angular.json
index e46206b..1152050 100644
--- a/angular.json
+++ b/angular.json
@@ -24,10 +24,8 @@
"tsConfig": "tsconfig.app.json",
"inlineStyleLanguage": "scss",
"assets": [
- {
- "glob": "**/*",
- "input": "public"
- }
+ "src/favicon.ico",
+ "src/assets"
],
"styles": [
"src/styles.scss"
@@ -94,5 +92,8 @@
}
}
}
+ },
+ "cli": {
+ "analytics": false
}
}
diff --git a/niayesh/1_sanagoo.jpg b/niayesh/1_sanagoo.jpg
new file mode 100644
index 0000000..ed9b6d7
Binary files /dev/null and b/niayesh/1_sanagoo.jpg differ
diff --git a/niayesh/1doctor-discussing-with-patient-guide-min.png b/niayesh/1doctor-discussing-with-patient-guide-min.png
new file mode 100644
index 0000000..c9180e4
Binary files /dev/null and b/niayesh/1doctor-discussing-with-patient-guide-min.png differ
diff --git a/niayesh/2_Your paragraph text (11).png b/niayesh/2_Your paragraph text (11).png
new file mode 100644
index 0000000..b5b96ed
Binary files /dev/null and b/niayesh/2_Your paragraph text (11).png differ
diff --git a/niayesh/3_Your paragraph text (11).png b/niayesh/3_Your paragraph text (11).png
new file mode 100644
index 0000000..edb1cc6
Binary files /dev/null and b/niayesh/3_Your paragraph text (11).png differ
diff --git a/niayesh/51574(1).png b/niayesh/51574(1).png
new file mode 100644
index 0000000..96b82d5
Binary files /dev/null and b/niayesh/51574(1).png differ
diff --git a/niayesh/51574(2).png b/niayesh/51574(2).png
new file mode 100644
index 0000000..09c4666
Binary files /dev/null and b/niayesh/51574(2).png differ
diff --git a/niayesh/51574(3).png b/niayesh/51574(3).png
new file mode 100644
index 0000000..63fac0f
Binary files /dev/null and b/niayesh/51574(3).png differ
diff --git a/niayesh/51574(4).png b/niayesh/51574(4).png
new file mode 100644
index 0000000..028e61c
Binary files /dev/null and b/niayesh/51574(4).png differ
diff --git a/niayesh/51574(5).png b/niayesh/51574(5).png
new file mode 100644
index 0000000..41f1a8c
Binary files /dev/null and b/niayesh/51574(5).png differ
diff --git a/niayesh/51574.png b/niayesh/51574.png
new file mode 100644
index 0000000..2c1777b
Binary files /dev/null and b/niayesh/51574.png differ
diff --git a/niayesh/51575(1).png b/niayesh/51575(1).png
new file mode 100644
index 0000000..83139eb
Binary files /dev/null and b/niayesh/51575(1).png differ
diff --git a/niayesh/51575(2).png b/niayesh/51575(2).png
new file mode 100644
index 0000000..d4adb30
Binary files /dev/null and b/niayesh/51575(2).png differ
diff --git a/niayesh/51575(3).png b/niayesh/51575(3).png
new file mode 100644
index 0000000..61ae557
Binary files /dev/null and b/niayesh/51575(3).png differ
diff --git a/niayesh/51575(4).png b/niayesh/51575(4).png
new file mode 100644
index 0000000..960d308
Binary files /dev/null and b/niayesh/51575(4).png differ
diff --git a/niayesh/51575(5).png b/niayesh/51575(5).png
new file mode 100644
index 0000000..4e85ad1
Binary files /dev/null and b/niayesh/51575(5).png differ
diff --git a/niayesh/51575.png b/niayesh/51575.png
new file mode 100644
index 0000000..0077551
Binary files /dev/null and b/niayesh/51575.png differ
diff --git a/niayesh/51576(1).png b/niayesh/51576(1).png
new file mode 100644
index 0000000..26bd45d
Binary files /dev/null and b/niayesh/51576(1).png differ
diff --git a/niayesh/51576(2).png b/niayesh/51576(2).png
new file mode 100644
index 0000000..4d4115c
Binary files /dev/null and b/niayesh/51576(2).png differ
diff --git a/niayesh/51576(3).png b/niayesh/51576(3).png
new file mode 100644
index 0000000..ac1e8e4
Binary files /dev/null and b/niayesh/51576(3).png differ
diff --git a/niayesh/51576(4).png b/niayesh/51576(4).png
new file mode 100644
index 0000000..f04967c
Binary files /dev/null and b/niayesh/51576(4).png differ
diff --git a/niayesh/51576(5).png b/niayesh/51576(5).png
new file mode 100644
index 0000000..fd83aa0
Binary files /dev/null and b/niayesh/51576(5).png differ
diff --git a/niayesh/51576.png b/niayesh/51576.png
new file mode 100644
index 0000000..b56021f
Binary files /dev/null and b/niayesh/51576.png differ
diff --git a/niayesh/9034005-546912-m.jpg b/niayesh/9034005-546912-m.jpg
new file mode 100644
index 0000000..ec7a28b
Binary files /dev/null and b/niayesh/9034005-546912-m.jpg differ
diff --git a/niayesh/Baz-aks-site1.jpg b/niayesh/Baz-aks-site1.jpg
new file mode 100644
index 0000000..49e2435
Binary files /dev/null and b/niayesh/Baz-aks-site1.jpg differ
diff --git a/niayesh/CCTA2.jpg b/niayesh/CCTA2.jpg
new file mode 100644
index 0000000..b7da5d2
Binary files /dev/null and b/niayesh/CCTA2.jpg differ
diff --git a/niayesh/LOGOERFANGROUPS.png b/niayesh/LOGOERFANGROUPS.png
new file mode 100644
index 0000000..15d2c1f
Binary files /dev/null and b/niayesh/LOGOERFANGROUPS.png differ
diff --git a/niayesh/LOGOUP6.png b/niayesh/LOGOUP6.png
new file mode 100644
index 0000000..ac2dc25
Binary files /dev/null and b/niayesh/LOGOUP6.png differ
diff --git a/niayesh/Parastar-2.jpg b/niayesh/Parastar-2.jpg
new file mode 100644
index 0000000..67fcfd3
Binary files /dev/null and b/niayesh/Parastar-2.jpg differ
diff --git a/niayesh/ScriptResource(1).axd b/niayesh/ScriptResource(1).axd
new file mode 100644
index 0000000..b295a68
--- /dev/null
+++ b/niayesh/ScriptResource(1).axd
@@ -0,0 +1,2056 @@
+// Name: MicrosoftAjaxWebForms.debug.js
+// Assembly: System.Web.Extensions
+// Version: 4.0.0.0
+// FileVersion: 4.8.4676.0
+//-----------------------------------------------------------------------
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------
+// MicrosoftAjaxWebForms.js
+// Microsoft AJAX ASP.NET WebForms Framework.
+Type._registerScript("MicrosoftAjaxWebForms.js", [
+ "MicrosoftAjaxCore.js",
+ "MicrosoftAjaxSerialization.js",
+ "MicrosoftAjaxNetwork.js",
+ "MicrosoftAjaxComponentModel.js"]);
+Type.registerNamespace('Sys.WebForms');
+Sys.WebForms.BeginRequestEventArgs = function Sys$WebForms$BeginRequestEventArgs(request, postBackElement, updatePanelsToUpdate) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "request", type: Sys.Net.WebRequest},
+ {name: "postBackElement", mayBeNull: true, domElement: true},
+ {name: "updatePanelsToUpdate", type: Array, mayBeNull: true, optional: true, elementType: String}
+ ]);
+ if (e) throw e;
+ Sys.WebForms.BeginRequestEventArgs.initializeBase(this);
+ this._request = request;
+ this._postBackElement = postBackElement;
+ this._updatePanelsToUpdate = updatePanelsToUpdate;
+}
+ function Sys$WebForms$BeginRequestEventArgs$get_postBackElement() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._postBackElement;
+ }
+ function Sys$WebForms$BeginRequestEventArgs$get_request() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._request;
+ }
+ function Sys$WebForms$BeginRequestEventArgs$get_updatePanelsToUpdate() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._updatePanelsToUpdate ? Array.clone(this._updatePanelsToUpdate) : [];
+ }
+Sys.WebForms.BeginRequestEventArgs.prototype = {
+ get_postBackElement: Sys$WebForms$BeginRequestEventArgs$get_postBackElement,
+ get_request: Sys$WebForms$BeginRequestEventArgs$get_request,
+ get_updatePanelsToUpdate: Sys$WebForms$BeginRequestEventArgs$get_updatePanelsToUpdate
+}
+Sys.WebForms.BeginRequestEventArgs.registerClass('Sys.WebForms.BeginRequestEventArgs', Sys.EventArgs);
+
+Sys.WebForms.EndRequestEventArgs = function Sys$WebForms$EndRequestEventArgs(error, dataItems, response) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "error", type: Error, mayBeNull: true},
+ {name: "dataItems", type: Object, mayBeNull: true},
+ {name: "response", type: Sys.Net.WebRequestExecutor}
+ ]);
+ if (e) throw e;
+ Sys.WebForms.EndRequestEventArgs.initializeBase(this);
+ this._errorHandled = false;
+ this._error = error;
+ this._dataItems = dataItems || new Object();
+ this._response = response;
+}
+ function Sys$WebForms$EndRequestEventArgs$get_dataItems() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._dataItems;
+ }
+ function Sys$WebForms$EndRequestEventArgs$get_error() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._error;
+ }
+ function Sys$WebForms$EndRequestEventArgs$get_errorHandled() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._errorHandled;
+ }
+ function Sys$WebForms$EndRequestEventArgs$set_errorHandled(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
+ if (e) throw e;
+ this._errorHandled = value;
+ }
+ function Sys$WebForms$EndRequestEventArgs$get_response() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._response;
+ }
+Sys.WebForms.EndRequestEventArgs.prototype = {
+ get_dataItems: Sys$WebForms$EndRequestEventArgs$get_dataItems,
+ get_error: Sys$WebForms$EndRequestEventArgs$get_error,
+ get_errorHandled: Sys$WebForms$EndRequestEventArgs$get_errorHandled,
+ set_errorHandled: Sys$WebForms$EndRequestEventArgs$set_errorHandled,
+ get_response: Sys$WebForms$EndRequestEventArgs$get_response
+}
+Sys.WebForms.EndRequestEventArgs.registerClass('Sys.WebForms.EndRequestEventArgs', Sys.EventArgs);
+Sys.WebForms.InitializeRequestEventArgs = function Sys$WebForms$InitializeRequestEventArgs(request, postBackElement, updatePanelsToUpdate) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "request", type: Sys.Net.WebRequest},
+ {name: "postBackElement", mayBeNull: true, domElement: true},
+ {name: "updatePanelsToUpdate", type: Array, mayBeNull: true, optional: true, elementType: String}
+ ]);
+ if (e) throw e;
+ Sys.WebForms.InitializeRequestEventArgs.initializeBase(this);
+ this._request = request;
+ this._postBackElement = postBackElement;
+ this._updatePanelsToUpdate = updatePanelsToUpdate;
+}
+ function Sys$WebForms$InitializeRequestEventArgs$get_postBackElement() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._postBackElement;
+ }
+ function Sys$WebForms$InitializeRequestEventArgs$get_request() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._request;
+ }
+ function Sys$WebForms$InitializeRequestEventArgs$get_updatePanelsToUpdate() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._updatePanelsToUpdate ? Array.clone(this._updatePanelsToUpdate) : [];
+ }
+ function Sys$WebForms$InitializeRequestEventArgs$set_updatePanelsToUpdate(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Array, elementType: String}]);
+ if (e) throw e;
+ this._updated = true;
+ this._updatePanelsToUpdate = value;
+ }
+Sys.WebForms.InitializeRequestEventArgs.prototype = {
+ get_postBackElement: Sys$WebForms$InitializeRequestEventArgs$get_postBackElement,
+ get_request: Sys$WebForms$InitializeRequestEventArgs$get_request,
+ get_updatePanelsToUpdate: Sys$WebForms$InitializeRequestEventArgs$get_updatePanelsToUpdate,
+ set_updatePanelsToUpdate: Sys$WebForms$InitializeRequestEventArgs$set_updatePanelsToUpdate
+}
+Sys.WebForms.InitializeRequestEventArgs.registerClass('Sys.WebForms.InitializeRequestEventArgs', Sys.CancelEventArgs);
+
+Sys.WebForms.PageLoadedEventArgs = function Sys$WebForms$PageLoadedEventArgs(panelsUpdated, panelsCreated, dataItems) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "panelsUpdated", type: Array},
+ {name: "panelsCreated", type: Array},
+ {name: "dataItems", type: Object, mayBeNull: true}
+ ]);
+ if (e) throw e;
+ Sys.WebForms.PageLoadedEventArgs.initializeBase(this);
+ this._panelsUpdated = panelsUpdated;
+ this._panelsCreated = panelsCreated;
+ this._dataItems = dataItems || new Object();
+}
+ function Sys$WebForms$PageLoadedEventArgs$get_dataItems() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._dataItems;
+ }
+ function Sys$WebForms$PageLoadedEventArgs$get_panelsCreated() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._panelsCreated;
+ }
+ function Sys$WebForms$PageLoadedEventArgs$get_panelsUpdated() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._panelsUpdated;
+ }
+Sys.WebForms.PageLoadedEventArgs.prototype = {
+ get_dataItems: Sys$WebForms$PageLoadedEventArgs$get_dataItems,
+ get_panelsCreated: Sys$WebForms$PageLoadedEventArgs$get_panelsCreated,
+ get_panelsUpdated: Sys$WebForms$PageLoadedEventArgs$get_panelsUpdated
+}
+Sys.WebForms.PageLoadedEventArgs.registerClass('Sys.WebForms.PageLoadedEventArgs', Sys.EventArgs);
+Sys.WebForms.PageLoadingEventArgs = function Sys$WebForms$PageLoadingEventArgs(panelsUpdating, panelsDeleting, dataItems) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "panelsUpdating", type: Array},
+ {name: "panelsDeleting", type: Array},
+ {name: "dataItems", type: Object, mayBeNull: true}
+ ]);
+ if (e) throw e;
+ Sys.WebForms.PageLoadingEventArgs.initializeBase(this);
+ this._panelsUpdating = panelsUpdating;
+ this._panelsDeleting = panelsDeleting;
+ this._dataItems = dataItems || new Object();
+}
+ function Sys$WebForms$PageLoadingEventArgs$get_dataItems() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._dataItems;
+ }
+ function Sys$WebForms$PageLoadingEventArgs$get_panelsDeleting() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._panelsDeleting;
+ }
+ function Sys$WebForms$PageLoadingEventArgs$get_panelsUpdating() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._panelsUpdating;
+ }
+Sys.WebForms.PageLoadingEventArgs.prototype = {
+ get_dataItems: Sys$WebForms$PageLoadingEventArgs$get_dataItems,
+ get_panelsDeleting: Sys$WebForms$PageLoadingEventArgs$get_panelsDeleting,
+ get_panelsUpdating: Sys$WebForms$PageLoadingEventArgs$get_panelsUpdating
+}
+Sys.WebForms.PageLoadingEventArgs.registerClass('Sys.WebForms.PageLoadingEventArgs', Sys.EventArgs);
+
+Sys._ScriptLoader = function Sys$_ScriptLoader() {
+ this._scriptsToLoad = null;
+ this._sessions = [];
+ this._scriptLoadedDelegate = Function.createDelegate(this, this._scriptLoadedHandler);
+}
+ function Sys$_ScriptLoader$dispose() {
+ this._stopSession();
+ this._loading = false;
+ if(this._events) {
+ delete this._events;
+ }
+ this._sessions = null;
+ this._currentSession = null;
+ this._scriptLoadedDelegate = null;
+ }
+ function Sys$_ScriptLoader$loadScripts(scriptTimeout, allScriptsLoadedCallback, scriptLoadFailedCallback, scriptLoadTimeoutCallback) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "scriptTimeout", type: Number, integer: true},
+ {name: "allScriptsLoadedCallback", type: Function, mayBeNull: true},
+ {name: "scriptLoadFailedCallback", type: Function, mayBeNull: true},
+ {name: "scriptLoadTimeoutCallback", type: Function, mayBeNull: true}
+ ]);
+ if (e) throw e;
+ var session = {
+ allScriptsLoadedCallback: allScriptsLoadedCallback,
+ scriptLoadFailedCallback: scriptLoadFailedCallback,
+ scriptLoadTimeoutCallback: scriptLoadTimeoutCallback,
+ scriptsToLoad: this._scriptsToLoad,
+ scriptTimeout: scriptTimeout };
+ this._scriptsToLoad = null;
+ this._sessions[this._sessions.length] = session;
+
+ if (!this._loading) {
+ this._nextSession();
+ }
+ }
+ function Sys$_ScriptLoader$queueCustomScriptTag(scriptAttributes) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "scriptAttributes"}
+ ]);
+ if (e) throw e;
+ if(!this._scriptsToLoad) {
+ this._scriptsToLoad = [];
+ }
+ Array.add(this._scriptsToLoad, scriptAttributes);
+ }
+ function Sys$_ScriptLoader$queueScriptBlock(scriptContent) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "scriptContent", type: String}
+ ]);
+ if (e) throw e;
+ if(!this._scriptsToLoad) {
+ this._scriptsToLoad = [];
+ }
+ Array.add(this._scriptsToLoad, {text: scriptContent});
+ }
+ function Sys$_ScriptLoader$queueScriptReference(scriptUrl, fallback) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "scriptUrl", type: String},
+ {name: "fallback", mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ if(!this._scriptsToLoad) {
+ this._scriptsToLoad = [];
+ }
+ Array.add(this._scriptsToLoad, {src: scriptUrl, fallback: fallback});
+ }
+ function Sys$_ScriptLoader$_createScriptElement(queuedScript) {
+ var scriptElement = document.createElement('script');
+ scriptElement.type = 'text/javascript';
+ for (var attr in queuedScript) {
+ scriptElement[attr] = queuedScript[attr];
+ }
+
+ return scriptElement;
+ }
+ function Sys$_ScriptLoader$_loadScriptsInternal() {
+ var session = this._currentSession;
+ if (session.scriptsToLoad && session.scriptsToLoad.length > 0) {
+ var nextScript = Array.dequeue(session.scriptsToLoad);
+ var onLoad = this._scriptLoadedDelegate;
+ if (nextScript.fallback) {
+ var fallback = nextScript.fallback;
+ delete nextScript.fallback;
+
+ var self = this;
+ onLoad = function(scriptElement, loaded) {
+ loaded || (function() {
+ var fallbackScriptElement = self._createScriptElement({src: fallback});
+ self._currentTask = new Sys._ScriptLoaderTask(fallbackScriptElement, self._scriptLoadedDelegate);
+ self._currentTask.execute();
+ })();
+ };
+ }
+ var scriptElement = this._createScriptElement(nextScript);
+
+ if (scriptElement.text && Sys.Browser.agent === Sys.Browser.Safari) {
+ scriptElement.innerHTML = scriptElement.text;
+ delete scriptElement.text;
+ }
+ if (typeof(nextScript.src) === "string") {
+ this._currentTask = new Sys._ScriptLoaderTask(scriptElement, onLoad);
+ this._currentTask.execute();
+ }
+ else {
+ var headElements = document.getElementsByTagName('head');
+ if (headElements.length === 0) {
+ throw new Error.invalidOperation(Sys.Res.scriptLoadFailedNoHead);
+ }
+ else {
+ headElements[0].appendChild(scriptElement);
+ }
+
+
+ Sys._ScriptLoaderTask._clearScript(scriptElement);
+ this._loadScriptsInternal();
+ }
+ }
+ else {
+ this._stopSession();
+ var callback = session.allScriptsLoadedCallback;
+ if(callback) {
+ callback(this);
+ }
+ this._nextSession();
+ }
+ }
+ function Sys$_ScriptLoader$_nextSession() {
+ if (this._sessions.length === 0) {
+ this._loading = false;
+ this._currentSession = null;
+ return;
+ }
+ this._loading = true;
+
+ var session = Array.dequeue(this._sessions);
+ this._currentSession = session;
+ this._loadScriptsInternal();
+ }
+ function Sys$_ScriptLoader$_raiseError() {
+ var callback = this._currentSession.scriptLoadFailedCallback;
+ var scriptElement = this._currentTask.get_scriptElement();
+ this._stopSession();
+
+ if(callback) {
+ callback(this, scriptElement);
+ this._nextSession();
+ }
+ else {
+ this._loading = false;
+ throw Sys._ScriptLoader._errorScriptLoadFailed(scriptElement.src);
+ }
+ }
+ function Sys$_ScriptLoader$_scriptLoadedHandler(scriptElement, loaded) {
+ if (loaded) {
+ Array.add(Sys._ScriptLoader._getLoadedScripts(), scriptElement.src);
+ this._currentTask.dispose();
+ this._currentTask = null;
+ this._loadScriptsInternal();
+ }
+ else {
+ this._raiseError();
+ }
+ }
+ function Sys$_ScriptLoader$_stopSession() {
+ if(this._currentTask) {
+ this._currentTask.dispose();
+ this._currentTask = null;
+ }
+ }
+Sys._ScriptLoader.prototype = {
+ dispose: Sys$_ScriptLoader$dispose,
+ loadScripts: Sys$_ScriptLoader$loadScripts,
+ queueCustomScriptTag: Sys$_ScriptLoader$queueCustomScriptTag,
+ queueScriptBlock: Sys$_ScriptLoader$queueScriptBlock,
+ queueScriptReference: Sys$_ScriptLoader$queueScriptReference,
+ _createScriptElement: Sys$_ScriptLoader$_createScriptElement,
+ _loadScriptsInternal: Sys$_ScriptLoader$_loadScriptsInternal,
+ _nextSession: Sys$_ScriptLoader$_nextSession,
+ _raiseError: Sys$_ScriptLoader$_raiseError,
+ _scriptLoadedHandler: Sys$_ScriptLoader$_scriptLoadedHandler,
+ _stopSession: Sys$_ScriptLoader$_stopSession
+}
+Sys._ScriptLoader.registerClass('Sys._ScriptLoader', null, Sys.IDisposable);
+Sys._ScriptLoader.getInstance = function Sys$_ScriptLoader$getInstance() {
+ var sl = Sys._ScriptLoader._activeInstance;
+ if(!sl) {
+ sl = Sys._ScriptLoader._activeInstance = new Sys._ScriptLoader();
+ }
+ return sl;
+}
+Sys._ScriptLoader.isScriptLoaded = function Sys$_ScriptLoader$isScriptLoaded(scriptSrc) {
+ var dummyScript = document.createElement('script');
+ dummyScript.src = scriptSrc;
+ return Array.contains(Sys._ScriptLoader._getLoadedScripts(), dummyScript.src);
+}
+Sys._ScriptLoader.readLoadedScripts = function Sys$_ScriptLoader$readLoadedScripts() {
+ if(!Sys._ScriptLoader._referencedScripts) {
+ var referencedScripts = Sys._ScriptLoader._referencedScripts = [];
+ var existingScripts = document.getElementsByTagName('script');
+ for (var i = existingScripts.length - 1; i >= 0; i--) {
+ var scriptNode = existingScripts[i];
+ var scriptSrc = scriptNode.src;
+ if (scriptSrc.length) {
+ if (!Array.contains(referencedScripts, scriptSrc)) {
+ Array.add(referencedScripts, scriptSrc);
+ }
+ }
+ }
+ }
+}
+Sys._ScriptLoader._errorScriptLoadFailed = function Sys$_ScriptLoader$_errorScriptLoadFailed(scriptUrl) {
+ var errorMessage;
+ errorMessage = Sys.Res.scriptLoadFailedDebug;
+ var displayMessage = "Sys.ScriptLoadFailedException: " + String.format(errorMessage, scriptUrl);
+ var e = Error.create(displayMessage, {name: 'Sys.ScriptLoadFailedException', 'scriptUrl': scriptUrl });
+ e.popStackFrame();
+ return e;
+}
+Sys._ScriptLoader._getLoadedScripts = function Sys$_ScriptLoader$_getLoadedScripts() {
+ if(!Sys._ScriptLoader._referencedScripts) {
+ Sys._ScriptLoader._referencedScripts = [];
+ Sys._ScriptLoader.readLoadedScripts();
+ }
+ return Sys._ScriptLoader._referencedScripts;
+}
+
+Sys.WebForms.PageRequestManager = function Sys$WebForms$PageRequestManager() {
+ this._form = null;
+ this._activeDefaultButton = null;
+ this._activeDefaultButtonClicked = false;
+ this._updatePanelIDs = null;
+ this._updatePanelClientIDs = null;
+ this._updatePanelHasChildrenAsTriggers = null;
+ this._asyncPostBackControlIDs = null;
+ this._asyncPostBackControlClientIDs = null;
+ this._postBackControlIDs = null;
+ this._postBackControlClientIDs = null;
+ this._scriptManagerID = null;
+ this._pageLoadedHandler = null;
+ this._additionalInput = null;
+ this._onsubmit = null;
+ this._onSubmitStatements = [];
+ this._originalDoPostBack = null;
+ this._originalDoPostBackWithOptions = null;
+ this._originalFireDefaultButton = null;
+ this._originalDoCallback = null;
+ this._isCrossPost = false;
+ this._postBackSettings = null;
+ this._request = null;
+ this._onFormSubmitHandler = null;
+ this._onFormElementClickHandler = null;
+ this._onWindowUnloadHandler = null;
+ this._asyncPostBackTimeout = null;
+ this._controlIDToFocus = null;
+ this._scrollPosition = null;
+ this._processingRequest = false;
+ this._scriptDisposes = {};
+
+ this._transientFields = ["__VIEWSTATEENCRYPTED", "__VIEWSTATEFIELDCOUNT"];
+ this._textTypes = /^(text|password|hidden|search|tel|url|email|number|range|color|datetime|date|month|week|time|datetime-local)$/i;
+}
+ function Sys$WebForms$PageRequestManager$_get_eventHandlerList() {
+ if (!this._events) {
+ this._events = new Sys.EventHandlerList();
+ }
+ return this._events;
+ }
+ function Sys$WebForms$PageRequestManager$get_isInAsyncPostBack() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._request !== null;
+ }
+ function Sys$WebForms$PageRequestManager$add_beginRequest(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("beginRequest", handler);
+ }
+ function Sys$WebForms$PageRequestManager$remove_beginRequest(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("beginRequest", handler);
+ }
+ function Sys$WebForms$PageRequestManager$add_endRequest(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("endRequest", handler);
+ }
+ function Sys$WebForms$PageRequestManager$remove_endRequest(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("endRequest", handler);
+ }
+ function Sys$WebForms$PageRequestManager$add_initializeRequest(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("initializeRequest", handler);
+ }
+ function Sys$WebForms$PageRequestManager$remove_initializeRequest(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("initializeRequest", handler);
+ }
+ function Sys$WebForms$PageRequestManager$add_pageLoaded(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("pageLoaded", handler);
+ }
+ function Sys$WebForms$PageRequestManager$remove_pageLoaded(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("pageLoaded", handler);
+ }
+ function Sys$WebForms$PageRequestManager$add_pageLoading(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("pageLoading", handler);
+ }
+ function Sys$WebForms$PageRequestManager$remove_pageLoading(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("pageLoading", handler);
+ }
+ function Sys$WebForms$PageRequestManager$abortPostBack() {
+ if (!this._processingRequest && this._request) {
+ this._request.get_executor().abort();
+ this._request = null;
+ }
+ }
+ function Sys$WebForms$PageRequestManager$beginAsyncPostBack(updatePanelsToUpdate, eventTarget, eventArgument, causesValidation, validationGroup) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "updatePanelsToUpdate", type: Array, mayBeNull: true, optional: true, elementType: String},
+ {name: "eventTarget", type: String, mayBeNull: true, optional: true},
+ {name: "eventArgument", type: String, mayBeNull: true, optional: true},
+ {name: "causesValidation", type: Boolean, mayBeNull: true, optional: true},
+ {name: "validationGroup", type: String, mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ if (causesValidation && (typeof(Page_ClientValidate) === 'function') && !Page_ClientValidate(validationGroup || null)) {
+ return;
+ }
+ this._postBackSettings = this._createPostBackSettings(true, updatePanelsToUpdate, eventTarget);
+ var form = this._form;
+ form.__EVENTTARGET.value = (eventTarget || "");
+ form.__EVENTARGUMENT.value = (eventArgument || "");
+ this._isCrossPost = false;
+ this._additionalInput = null;
+ this._onFormSubmit();
+ }
+ function Sys$WebForms$PageRequestManager$_cancelPendingCallbacks() {
+ for (var i = 0, l = window.__pendingCallbacks.length; i < l; i++) {
+ var callback = window.__pendingCallbacks[i];
+ if (callback) {
+ if (!callback.async) {
+ window.__synchronousCallBackIndex = -1;
+ }
+ window.__pendingCallbacks[i] = null;
+ var callbackFrameID = "__CALLBACKFRAME" + i;
+ var xmlRequestFrame = document.getElementById(callbackFrameID);
+ if (xmlRequestFrame) {
+ xmlRequestFrame.parentNode.removeChild(xmlRequestFrame);
+ }
+ }
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_commitControls(updatePanelData, asyncPostBackTimeout) {
+ if (updatePanelData) {
+ this._updatePanelIDs = updatePanelData.updatePanelIDs;
+ this._updatePanelClientIDs = updatePanelData.updatePanelClientIDs;
+ this._updatePanelHasChildrenAsTriggers = updatePanelData.updatePanelHasChildrenAsTriggers;
+ this._asyncPostBackControlIDs = updatePanelData.asyncPostBackControlIDs;
+ this._asyncPostBackControlClientIDs = updatePanelData.asyncPostBackControlClientIDs;
+ this._postBackControlIDs = updatePanelData.postBackControlIDs;
+ this._postBackControlClientIDs = updatePanelData.postBackControlClientIDs;
+ }
+ if (typeof(asyncPostBackTimeout) !== 'undefined' && asyncPostBackTimeout !== null) {
+ this._asyncPostBackTimeout = asyncPostBackTimeout * 1000;
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_createHiddenField(id, value) {
+ var container, field = document.getElementById(id);
+ if (field) {
+ if (!field._isContained) {
+ field.parentNode.removeChild(field);
+ }
+ else {
+ container = field.parentNode;
+ }
+ }
+ if (!container) {
+ container = document.createElement('span');
+ container.style.cssText = "display:none !important";
+ this._form.appendChild(container);
+ }
+ container.innerHTML = "";
+ field = container.childNodes[0];
+ field._isContained = true;
+ field.id = field.name = id;
+ field.value = value;
+ }
+ function Sys$WebForms$PageRequestManager$_createPageRequestManagerTimeoutError() {
+ var displayMessage = "Sys.WebForms.PageRequestManagerTimeoutException: " + Sys.WebForms.Res.PRM_TimeoutError;
+ var e = Error.create(displayMessage, {name: 'Sys.WebForms.PageRequestManagerTimeoutException'});
+ e.popStackFrame();
+ return e;
+ }
+ function Sys$WebForms$PageRequestManager$_createPageRequestManagerServerError(httpStatusCode, message) {
+ var displayMessage = "Sys.WebForms.PageRequestManagerServerErrorException: " +
+ (message || String.format(Sys.WebForms.Res.PRM_ServerError, httpStatusCode));
+ var e = Error.create(displayMessage, {
+ name: 'Sys.WebForms.PageRequestManagerServerErrorException',
+ httpStatusCode: httpStatusCode
+ });
+ e.popStackFrame();
+ return e;
+ }
+ function Sys$WebForms$PageRequestManager$_createPageRequestManagerParserError(parserErrorMessage) {
+ var displayMessage = "Sys.WebForms.PageRequestManagerParserErrorException: " + String.format(Sys.WebForms.Res.PRM_ParserError, parserErrorMessage);
+ var e = Error.create(displayMessage, {name: 'Sys.WebForms.PageRequestManagerParserErrorException'});
+ e.popStackFrame();
+ return e;
+ }
+ function Sys$WebForms$PageRequestManager$_createPanelID(panelsToUpdate, postBackSettings) {
+ var asyncTarget = postBackSettings.asyncTarget,
+ toUpdate = this._ensureUniqueIds(panelsToUpdate || postBackSettings.panelsToUpdate),
+ panelArg = (toUpdate instanceof Array)
+ ? toUpdate.join(',')
+ : (toUpdate || this._scriptManagerID);
+ if (asyncTarget) {
+ panelArg += "|" + asyncTarget;
+ }
+ return encodeURIComponent(this._scriptManagerID) + '=' + encodeURIComponent(panelArg) + '&';
+ }
+ function Sys$WebForms$PageRequestManager$_createPostBackSettings(async, panelsToUpdate, asyncTarget, sourceElement) {
+ return { async:async, asyncTarget: asyncTarget, panelsToUpdate: panelsToUpdate, sourceElement: sourceElement };
+ }
+ function Sys$WebForms$PageRequestManager$_convertToClientIDs(source, destinationIDs, destinationClientIDs, version4) {
+ if (source) {
+ for (var i = 0, l = source.length; i < l; i += (version4 ? 2 : 1)) {
+ var uniqueID = source[i],
+ clientID = (version4 ? source[i+1] : "") || this._uniqueIDToClientID(uniqueID);
+ Array.add(destinationIDs, uniqueID);
+ Array.add(destinationClientIDs, clientID);
+ }
+ }
+ }
+ function Sys$WebForms$PageRequestManager$dispose() {
+ if (this._form) {
+ Sys.UI.DomEvent.removeHandler(this._form, 'submit', this._onFormSubmitHandler);
+ Sys.UI.DomEvent.removeHandler(this._form, 'click', this._onFormElementClickHandler);
+ Sys.UI.DomEvent.removeHandler(window, 'unload', this._onWindowUnloadHandler);
+ Sys.UI.DomEvent.removeHandler(window, 'load', this._pageLoadedHandler);
+ }
+ if (this._originalDoPostBack) {
+ window.__doPostBack = this._originalDoPostBack;
+ this._originalDoPostBack = null;
+ }
+ if (this._originalDoPostBackWithOptions) {
+ window.WebForm_DoPostBackWithOptions = this._originalDoPostBackWithOptions;
+ this._originalDoPostBackWithOptions = null;
+ }
+ if (this._originalFireDefaultButton) {
+ window.WebForm_FireDefaultButton = this._originalFireDefaultButton;
+ this._originalFireDefaultButton = null;
+ }
+ if (this._originalDoCallback) {
+ window.WebForm_DoCallback = this._originalDoCallback;
+ this._originalDoCallback = null;
+ }
+ this._form = null;
+ this._updatePanelIDs = null;
+ this._updatePanelClientIDs = null;
+ this._asyncPostBackControlIDs = null;
+ this._asyncPostBackControlClientIDs = null;
+ this._postBackControlIDs = null;
+ this._postBackControlClientIDs = null;
+ this._asyncPostBackTimeout = null;
+ this._scrollPosition = null;
+ this._activeElement = null;
+ }
+ function Sys$WebForms$PageRequestManager$_doCallback(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync) {
+ if (!this.get_isInAsyncPostBack()) {
+ this._originalDoCallback(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync);
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_doPostBack(eventTarget, eventArgument) {
+ var event = window.event;
+ if (!event) {
+ var caller = arguments.callee ? arguments.callee.caller : null;
+ if (caller) {
+ var recursionLimit = 30;
+ while (caller.arguments.callee.caller && --recursionLimit) {
+ caller = caller.arguments.callee.caller;
+ }
+ event = (recursionLimit && caller.arguments.length) ? caller.arguments[0] : null;
+ }
+ }
+ this._additionalInput = null;
+ var form = this._form;
+ if ((eventTarget === null) || (typeof(eventTarget) === "undefined") || (this._isCrossPost)) {
+ this._postBackSettings = this._createPostBackSettings(false);
+ this._isCrossPost = false;
+ }
+ else {
+ var mpUniqueID = this._masterPageUniqueID;
+ var clientID = this._uniqueIDToClientID(eventTarget);
+ var postBackElement = document.getElementById(clientID);
+ if (!postBackElement && mpUniqueID) {
+ if (eventTarget.indexOf(mpUniqueID + "$") === 0) {
+ postBackElement = document.getElementById(clientID.substr(mpUniqueID.length + 1));
+ }
+ }
+ if (!postBackElement) {
+ if (Array.contains(this._asyncPostBackControlIDs, eventTarget)) {
+ this._postBackSettings = this._createPostBackSettings(true, null, eventTarget);
+ }
+ else {
+ if (Array.contains(this._postBackControlIDs, eventTarget)) {
+ this._postBackSettings = this._createPostBackSettings(false);
+ }
+ else {
+ var nearestUniqueIDMatch = this._findNearestElement(eventTarget);
+ if (nearestUniqueIDMatch) {
+ this._postBackSettings = this._getPostBackSettings(nearestUniqueIDMatch, eventTarget);
+ }
+ else {
+ if (mpUniqueID) {
+ mpUniqueID += "$";
+ if (eventTarget.indexOf(mpUniqueID) === 0) {
+ nearestUniqueIDMatch = this._findNearestElement(eventTarget.substr(mpUniqueID.length));
+ }
+ }
+ if (nearestUniqueIDMatch) {
+ this._postBackSettings = this._getPostBackSettings(nearestUniqueIDMatch, eventTarget);
+ }
+ else {
+ var activeElement;
+ try {
+ activeElement = event ? (event.target || event.srcElement) : null;
+ }
+ catch(ex) {
+ }
+ activeElement = activeElement || this._activeElement;
+ var causesPostback = /__doPostBack\(|WebForm_DoPostBackWithOptions\(/;
+ function testCausesPostBack(attr) {
+ attr = attr ? attr.toString() : "";
+ return (causesPostback.test(attr) &&
+ (attr.indexOf("'" + eventTarget + "'") !== -1) || (attr.indexOf('"' + eventTarget + '"') !== -1));
+ }
+ if (activeElement && (
+ (activeElement.name === eventTarget) ||
+ testCausesPostBack(activeElement.href) ||
+ testCausesPostBack(activeElement.onclick) ||
+ testCausesPostBack(activeElement.onchange)
+ )) {
+ this._postBackSettings = this._getPostBackSettings(activeElement, eventTarget);
+ }
+ else {
+ this._postBackSettings = this._createPostBackSettings(false);
+ }
+ }
+ }
+ }
+ }
+ }
+ else {
+ this._postBackSettings = this._getPostBackSettings(postBackElement, eventTarget);
+ }
+ }
+ if (!this._postBackSettings.async) {
+ form.onsubmit = this._onsubmit;
+ this._originalDoPostBack(eventTarget, eventArgument);
+ form.onsubmit = null;
+ return;
+ }
+ form.__EVENTTARGET.value = eventTarget;
+ form.__EVENTARGUMENT.value = eventArgument;
+ this._onFormSubmit();
+ }
+ function Sys$WebForms$PageRequestManager$_doPostBackWithOptions(options) {
+ this._isCrossPost = options && options.actionUrl;
+ var validationResult = true;
+ if (options.validation) {
+ if (typeof(Page_ClientValidate) == 'function') {
+ validationResult = Page_ClientValidate(options.validationGroup);
+ }
+ }
+ if (validationResult) {
+ if ((typeof(options.actionUrl) != "undefined") && (options.actionUrl != null) && (options.actionUrl.length > 0)) {
+ theForm.action = options.actionUrl;
+ }
+ if (options.trackFocus) {
+ var lastFocus = theForm.elements["__LASTFOCUS"];
+ if ((typeof(lastFocus) != "undefined") && (lastFocus != null)) {
+ if (typeof(document.activeElement) == "undefined") {
+ lastFocus.value = options.eventTarget;
+ }
+ else {
+ var active = document.activeElement;
+ if ((typeof(active) != "undefined") && (active != null)) {
+ if ((typeof(active.id) != "undefined") && (active.id != null) && (active.id.length > 0)) {
+ lastFocus.value = active.id;
+ }
+ else if (typeof(active.name) != "undefined") {
+ lastFocus.value = active.name;
+ }
+ }
+ }
+ }
+ }
+ }
+ if (options.clientSubmit) {
+ this._doPostBack(options.eventTarget, options.eventArgument);
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_elementContains(container, element) {
+ while (element) {
+ if (element === container) {
+ return true;
+ }
+ element = element.parentNode;
+ }
+ return false;
+ }
+ function Sys$WebForms$PageRequestManager$_endPostBack(error, executor, data) {
+ if (this._request === executor.get_webRequest()) {
+ this._processingRequest = false;
+ this._additionalInput = null;
+ this._request = null;
+ }
+ var handler = this._get_eventHandlerList().getHandler("endRequest");
+ var errorHandled = false;
+ if (handler) {
+ var eventArgs = new Sys.WebForms.EndRequestEventArgs(error, data ? data.dataItems : {}, executor);
+ handler(this, eventArgs);
+ errorHandled = eventArgs.get_errorHandled();
+ }
+ if (error && !errorHandled) {
+ throw error;
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_ensureUniqueIds(ids) {
+ if (!ids) return ids;
+ ids = ids instanceof Array ? ids : [ids];
+ var uniqueIds = [];
+ for (var i = 0, l = ids.length; i < l; i++) {
+ var id = ids[i], index = Array.indexOf(this._updatePanelClientIDs, id);
+ uniqueIds.push(index > -1 ? this._updatePanelIDs[index] : id);
+ }
+ return uniqueIds;
+ }
+ function Sys$WebForms$PageRequestManager$_findNearestElement(uniqueID) {
+ while (uniqueID.length > 0) {
+ var clientID = this._uniqueIDToClientID(uniqueID);
+ var element = document.getElementById(clientID);
+ if (element) {
+ return element;
+ }
+ var indexOfLastDollar = uniqueID.lastIndexOf('$');
+ if (indexOfLastDollar === -1) {
+ return null;
+ }
+ uniqueID = uniqueID.substring(0, indexOfLastDollar);
+ }
+ return null;
+ }
+ function Sys$WebForms$PageRequestManager$_findText(text, location) {
+ var startIndex = Math.max(0, location - 20);
+ var endIndex = Math.min(text.length, location + 20);
+ return text.substring(startIndex, endIndex);
+ }
+ function Sys$WebForms$PageRequestManager$_fireDefaultButton(event, target) {
+ if (event.keyCode === 13) {
+ var src = event.srcElement || event.target;
+ if (!src || (src.tagName.toLowerCase() !== "textarea")) {
+ var defaultButton = document.getElementById(target);
+ if (defaultButton && (typeof(defaultButton.click) !== "undefined")) {
+
+
+ this._activeDefaultButton = defaultButton;
+ this._activeDefaultButtonClicked = false;
+ try {
+ defaultButton.click();
+ }
+ finally {
+ this._activeDefaultButton = null;
+ }
+
+
+ event.cancelBubble = true;
+ if (typeof(event.stopPropagation) === "function") {
+ event.stopPropagation();
+ }
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ function Sys$WebForms$PageRequestManager$_getPageLoadedEventArgs(initialLoad, data) {
+ var updated = [];
+ var created = [];
+ var version4 = data ? data.version4 : false;
+ var upData = data ? data.updatePanelData : null;
+ var newIDs, newClientIDs, childIDs, refreshedIDs;
+ if (!upData) {
+ newIDs = this._updatePanelIDs;
+ newClientIDs = this._updatePanelClientIDs;
+ childIDs = null;
+ refreshedIDs = null;
+ }
+ else {
+ newIDs = upData.updatePanelIDs;
+ newClientIDs = upData.updatePanelClientIDs;
+ childIDs = upData.childUpdatePanelIDs;
+ refreshedIDs = upData.panelsToRefreshIDs;
+ }
+ var i, l, uniqueID, clientID;
+ if (refreshedIDs) {
+ for (i = 0, l = refreshedIDs.length; i < l; i += (version4 ? 2 : 1)) {
+ uniqueID = refreshedIDs[i];
+ clientID = (version4 ? refreshedIDs[i+1] : "") || this._uniqueIDToClientID(uniqueID);
+ Array.add(updated, document.getElementById(clientID));
+ }
+ }
+ for (i = 0, l = newIDs.length; i < l; i++) {
+ if (initialLoad || Array.indexOf(childIDs, newIDs[i]) !== -1) {
+ Array.add(created, document.getElementById(newClientIDs[i]));
+ }
+ }
+ return new Sys.WebForms.PageLoadedEventArgs(updated, created, data ? data.dataItems : {});
+ }
+ function Sys$WebForms$PageRequestManager$_getPageLoadingEventArgs(data) {
+ var updated = [],
+ deleted = [],
+ upData = data.updatePanelData,
+ oldIDs = upData.oldUpdatePanelIDs,
+ oldClientIDs = upData.oldUpdatePanelClientIDs,
+ newIDs = upData.updatePanelIDs,
+ childIDs = upData.childUpdatePanelIDs,
+ refreshedIDs = upData.panelsToRefreshIDs,
+ i, l, uniqueID, clientID,
+ version4 = data.version4;
+ for (i = 0, l = refreshedIDs.length; i < l; i += (version4 ? 2 : 1)) {
+ uniqueID = refreshedIDs[i];
+ clientID = (version4 ? refreshedIDs[i+1] : "") || this._uniqueIDToClientID(uniqueID);
+ Array.add(updated, document.getElementById(clientID));
+ }
+ for (i = 0, l = oldIDs.length; i < l; i++) {
+ uniqueID = oldIDs[i];
+ if (Array.indexOf(refreshedIDs, uniqueID) === -1 &&
+ (Array.indexOf(newIDs, uniqueID) === -1 || Array.indexOf(childIDs, uniqueID) > -1)) {
+ Array.add(deleted, document.getElementById(oldClientIDs[i]));
+ }
+ }
+ return new Sys.WebForms.PageLoadingEventArgs(updated, deleted, data.dataItems);
+ }
+ function Sys$WebForms$PageRequestManager$_getPostBackSettings(element, elementUniqueID) {
+ var originalElement = element;
+ var proposedSettings = null;
+ while (element) {
+ if (element.id) {
+ if (!proposedSettings && Array.contains(this._asyncPostBackControlClientIDs, element.id)) {
+ proposedSettings = this._createPostBackSettings(true, null, elementUniqueID, originalElement);
+ }
+ else {
+ if (!proposedSettings && Array.contains(this._postBackControlClientIDs, element.id)) {
+ return this._createPostBackSettings(false);
+ }
+ else {
+ var indexOfPanel = Array.indexOf(this._updatePanelClientIDs, element.id);
+ if (indexOfPanel !== -1) {
+ if (this._updatePanelHasChildrenAsTriggers[indexOfPanel]) {
+ return this._createPostBackSettings(true, [this._updatePanelIDs[indexOfPanel]], elementUniqueID, originalElement);
+ }
+ else {
+ return this._createPostBackSettings(true, null, elementUniqueID, originalElement);
+ }
+ }
+ }
+ }
+ if (!proposedSettings && this._matchesParentIDInList(element.id, this._asyncPostBackControlClientIDs)) {
+ proposedSettings = this._createPostBackSettings(true, null, elementUniqueID, originalElement);
+ }
+ else {
+ if (!proposedSettings && this._matchesParentIDInList(element.id, this._postBackControlClientIDs)) {
+ return this._createPostBackSettings(false);
+ }
+ }
+ }
+ element = element.parentNode;
+ }
+ if (!proposedSettings) {
+ return this._createPostBackSettings(false);
+ }
+ else {
+ return proposedSettings;
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_getScrollPosition() {
+ var d = document.documentElement;
+ if (d && (this._validPosition(d.scrollLeft) || this._validPosition(d.scrollTop))) {
+ return {
+ x: d.scrollLeft,
+ y: d.scrollTop
+ };
+ }
+ else {
+ d = document.body;
+ if (d && (this._validPosition(d.scrollLeft) || this._validPosition(d.scrollTop))) {
+ return {
+ x: d.scrollLeft,
+ y: d.scrollTop
+ };
+ }
+ else {
+ if (this._validPosition(window.pageXOffset) || this._validPosition(window.pageYOffset)) {
+ return {
+ x: window.pageXOffset,
+ y: window.pageYOffset
+ };
+ }
+ else {
+ return {
+ x: 0,
+ y: 0
+ };
+ }
+ }
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_initializeInternal(scriptManagerID, formElement, updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, asyncPostBackTimeout, masterPageUniqueID) {
+ if (this._prmInitialized) {
+ throw Error.invalidOperation(Sys.WebForms.Res.PRM_CannotRegisterTwice);
+ }
+ this._prmInitialized = true;
+ this._masterPageUniqueID = masterPageUniqueID;
+ this._scriptManagerID = scriptManagerID;
+ this._form = Sys.UI.DomElement.resolveElement(formElement);
+ this._onsubmit = this._form.onsubmit;
+ this._form.onsubmit = null;
+ this._onFormSubmitHandler = Function.createDelegate(this, this._onFormSubmit);
+ this._onFormElementClickHandler = Function.createDelegate(this, this._onFormElementClick);
+ this._onWindowUnloadHandler = Function.createDelegate(this, this._onWindowUnload);
+ Sys.UI.DomEvent.addHandler(this._form, 'submit', this._onFormSubmitHandler);
+ Sys.UI.DomEvent.addHandler(this._form, 'click', this._onFormElementClickHandler);
+ Sys.UI.DomEvent.addHandler(window, 'unload', this._onWindowUnloadHandler);
+ this._originalDoPostBack = window.__doPostBack;
+ if (this._originalDoPostBack) {
+ window.__doPostBack = Function.createDelegate(this, this._doPostBack);
+ }
+ this._originalDoPostBackWithOptions = window.WebForm_DoPostBackWithOptions;
+ if (this._originalDoPostBackWithOptions) {
+ window.WebForm_DoPostBackWithOptions = Function.createDelegate(this, this._doPostBackWithOptions);
+ }
+ this._originalFireDefaultButton = window.WebForm_FireDefaultButton;
+ if (this._originalFireDefaultButton) {
+ window.WebForm_FireDefaultButton = Function.createDelegate(this, this._fireDefaultButton);
+ }
+ this._originalDoCallback = window.WebForm_DoCallback;
+ if (this._originalDoCallback) {
+ window.WebForm_DoCallback = Function.createDelegate(this, this._doCallback);
+ }
+ this._pageLoadedHandler = Function.createDelegate(this, this._pageLoadedInitialLoad);
+ Sys.UI.DomEvent.addHandler(window, 'load', this._pageLoadedHandler);
+ if (updatePanelIDs) {
+ this._updateControls(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, asyncPostBackTimeout, true);
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_matchesParentIDInList(clientID, parentIDList) {
+ for (var i = 0, l = parentIDList.length; i < l; i++) {
+ if (clientID.startsWith(parentIDList[i] + "_")) {
+ return true;
+ }
+ }
+ return false;
+ }
+ function Sys$WebForms$PageRequestManager$_onFormElementActive(element, offsetX, offsetY) {
+ if (element.disabled) {
+ return;
+ }
+ this._activeElement = element;
+ this._postBackSettings = this._getPostBackSettings(element, element.name);
+ if (element.name) {
+ var tagName = element.tagName.toUpperCase();
+ if (tagName === 'INPUT') {
+ var type = element.type;
+ if (type === 'submit') {
+ this._additionalInput = encodeURIComponent(element.name) + '=' + encodeURIComponent(element.value);
+ }
+ else if (type === 'image') {
+ this._additionalInput = encodeURIComponent(element.name) + '.x=' + offsetX + '&' + encodeURIComponent(element.name) + '.y=' + offsetY;
+ }
+ }
+ else if ((tagName === 'BUTTON') && (element.name.length !== 0) && (element.type === 'submit')) {
+ this._additionalInput = encodeURIComponent(element.name) + '=' + encodeURIComponent(element.value);
+ }
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_onFormElementClick(evt) {
+ this._activeDefaultButtonClicked = (evt.target === this._activeDefaultButton);
+ this._onFormElementActive(evt.target, evt.offsetX, evt.offsetY);
+ }
+ function Sys$WebForms$PageRequestManager$_onFormSubmit(evt) {
+ var i, l, continueSubmit = true,
+ isCrossPost = this._isCrossPost;
+ this._isCrossPost = false;
+ if (this._onsubmit) {
+ continueSubmit = this._onsubmit();
+ }
+ if (continueSubmit) {
+ for (i = 0, l = this._onSubmitStatements.length; i < l; i++) {
+ if (!this._onSubmitStatements[i]()) {
+ continueSubmit = false;
+ break;
+ }
+ }
+ }
+ if (!continueSubmit) {
+ if (evt) {
+ evt.preventDefault();
+ }
+ return;
+ }
+ var form = this._form;
+ if (isCrossPost) {
+ return;
+ }
+ if (this._activeDefaultButton && !this._activeDefaultButtonClicked) {
+ this._onFormElementActive(this._activeDefaultButton, 0, 0);
+ }
+ if (!this._postBackSettings || !this._postBackSettings.async) {
+ return;
+ }
+ var formBody = new Sys.StringBuilder(),
+ formElements = form.elements,
+ count = formElements.length,
+ panelID = this._createPanelID(null, this._postBackSettings);
+ formBody.append(panelID);
+ for (i = 0; i < count; i++) {
+ var element = formElements[i];
+ var name = element.name;
+ if (typeof(name) === "undefined" || (name === null) || (name.length === 0) || (name === this._scriptManagerID)) {
+ continue;
+ }
+ var tagName = element.tagName.toUpperCase();
+ if (tagName === 'INPUT') {
+ var type = element.type;
+ if (this._textTypes.test(type)
+ || ((type === 'checkbox' || type === 'radio') && element.checked)) {
+ formBody.append(encodeURIComponent(name));
+ formBody.append('=');
+ formBody.append(encodeURIComponent(element.value));
+ formBody.append('&');
+ }
+ }
+ else if (tagName === 'SELECT') {
+ var optionCount = element.options.length;
+ for (var j = 0; j < optionCount; j++) {
+ var option = element.options[j];
+ if (option.selected) {
+ formBody.append(encodeURIComponent(name));
+ formBody.append('=');
+ formBody.append(encodeURIComponent(option.value));
+ formBody.append('&');
+ }
+ }
+ }
+ else if (tagName === 'TEXTAREA') {
+ formBody.append(encodeURIComponent(name));
+ formBody.append('=');
+ formBody.append(encodeURIComponent(element.value));
+ formBody.append('&');
+ }
+ }
+ formBody.append("__ASYNCPOST=true&");
+ if (this._additionalInput) {
+ formBody.append(this._additionalInput);
+ this._additionalInput = null;
+ }
+
+ var request = new Sys.Net.WebRequest();
+ var action = form.action;
+ if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {
+ var fragmentIndex = action.indexOf('#');
+ if (fragmentIndex !== -1) {
+ action = action.substr(0, fragmentIndex);
+ }
+ var domain = "", query = "", queryIndex = action.indexOf('?');
+ if (queryIndex !== -1) {
+ query = action.substr(queryIndex);
+ action = action.substr(0, queryIndex);
+ }
+ if (/^https?\:\/\/.*$/gi.test(action)) {
+ var domainPartIndex = action.indexOf("//") + 2,
+ slashAfterDomain = action.indexOf("/", domainPartIndex);
+ if (slashAfterDomain === -1) {
+ domain = action;
+ action = "";
+ }
+ else {
+ domain = action.substr(0, slashAfterDomain);
+ action = action.substr(slashAfterDomain);
+ }
+ }
+ action = domain + encodeURI(decodeURI(action)) + query;
+ }
+ request.set_url(action);
+ request.get_headers()['X-MicrosoftAjax'] = 'Delta=true';
+ request.get_headers()['Cache-Control'] = 'no-cache';
+ request.set_timeout(this._asyncPostBackTimeout);
+ request.add_completed(Function.createDelegate(this, this._onFormSubmitCompleted));
+ request.set_body(formBody.toString());
+ var panelsToUpdate, eventArgs, handler = this._get_eventHandlerList().getHandler("initializeRequest");
+ if (handler) {
+ panelsToUpdate = this._postBackSettings.panelsToUpdate;
+ eventArgs = new Sys.WebForms.InitializeRequestEventArgs(request, this._postBackSettings.sourceElement, panelsToUpdate);
+ handler(this, eventArgs);
+ continueSubmit = !eventArgs.get_cancel();
+ }
+ if (!continueSubmit) {
+ if (evt) {
+ evt.preventDefault();
+ }
+ return;
+ }
+
+ if (eventArgs && eventArgs._updated) {
+ panelsToUpdate = eventArgs.get_updatePanelsToUpdate();
+ request.set_body(request.get_body().replace(panelID, this._createPanelID(panelsToUpdate, this._postBackSettings)));
+ }
+ this._scrollPosition = this._getScrollPosition();
+ this.abortPostBack();
+ handler = this._get_eventHandlerList().getHandler("beginRequest");
+ if (handler) {
+ eventArgs = new Sys.WebForms.BeginRequestEventArgs(request, this._postBackSettings.sourceElement,
+ panelsToUpdate || this._postBackSettings.panelsToUpdate);
+ handler(this, eventArgs);
+ }
+
+ if (this._originalDoCallback) {
+ this._cancelPendingCallbacks();
+ }
+ this._request = request;
+ this._processingRequest = false;
+ request.invoke();
+ if (evt) {
+ evt.preventDefault();
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_onFormSubmitCompleted(sender, eventArgs) {
+ this._processingRequest = true;
+ if (sender.get_timedOut()) {
+ this._endPostBack(this._createPageRequestManagerTimeoutError(), sender, null);
+ return;
+ }
+ if (sender.get_aborted()) {
+ this._endPostBack(null, sender, null);
+ return;
+ }
+ if (!this._request || (sender.get_webRequest() !== this._request)) {
+ return;
+ }
+ if (sender.get_statusCode() !== 200) {
+ this._endPostBack(this._createPageRequestManagerServerError(sender.get_statusCode()), sender, null);
+ return;
+ }
+ var data = this._parseDelta(sender);
+ if (!data) return;
+
+ var i, l;
+ if (data.asyncPostBackControlIDsNode && data.postBackControlIDsNode &&
+ data.updatePanelIDsNode && data.panelsToRefreshNode && data.childUpdatePanelIDsNode) {
+
+ var oldUpdatePanelIDs = this._updatePanelIDs,
+ oldUpdatePanelClientIDs = this._updatePanelClientIDs;
+ var childUpdatePanelIDsString = data.childUpdatePanelIDsNode.content;
+ var childUpdatePanelIDs = childUpdatePanelIDsString.length ? childUpdatePanelIDsString.split(',') : [];
+ var asyncPostBackControlIDsArray = this._splitNodeIntoArray(data.asyncPostBackControlIDsNode);
+ var postBackControlIDsArray = this._splitNodeIntoArray(data.postBackControlIDsNode);
+ var updatePanelIDsArray = this._splitNodeIntoArray(data.updatePanelIDsNode);
+ var panelsToRefreshIDs = this._splitNodeIntoArray(data.panelsToRefreshNode);
+ var v4 = data.version4;
+ for (i = 0, l = panelsToRefreshIDs.length; i < l; i+= (v4 ? 2 : 1)) {
+ var panelClientID = (v4 ? panelsToRefreshIDs[i+1] : "") || this._uniqueIDToClientID(panelsToRefreshIDs[i]);
+ if (!document.getElementById(panelClientID)) {
+ this._endPostBack(Error.invalidOperation(String.format(Sys.WebForms.Res.PRM_MissingPanel, panelClientID)), sender, data);
+ return;
+ }
+ }
+
+ var updatePanelData = this._processUpdatePanelArrays(
+ updatePanelIDsArray,
+ asyncPostBackControlIDsArray,
+ postBackControlIDsArray, v4);
+ updatePanelData.oldUpdatePanelIDs = oldUpdatePanelIDs;
+ updatePanelData.oldUpdatePanelClientIDs = oldUpdatePanelClientIDs;
+ updatePanelData.childUpdatePanelIDs = childUpdatePanelIDs;
+ updatePanelData.panelsToRefreshIDs = panelsToRefreshIDs;
+ data.updatePanelData = updatePanelData;
+ }
+ data.dataItems = {};
+ var node;
+ for (i = 0, l = data.dataItemNodes.length; i < l; i++) {
+ node = data.dataItemNodes[i];
+ data.dataItems[node.id] = node.content;
+ }
+ for (i = 0, l = data.dataItemJsonNodes.length; i < l; i++) {
+ node = data.dataItemJsonNodes[i];
+ data.dataItems[node.id] = Sys.Serialization.JavaScriptSerializer.deserialize(node.content);
+ }
+ var handler = this._get_eventHandlerList().getHandler("pageLoading");
+ if (handler) {
+ handler(this, this._getPageLoadingEventArgs(data));
+ }
+
+ Sys._ScriptLoader.readLoadedScripts();
+ Sys.Application.beginCreateComponents();
+ var scriptLoader = Sys._ScriptLoader.getInstance();
+ this._queueScripts(scriptLoader, data.scriptBlockNodes, true, false);
+
+ this._processingRequest = true;
+ scriptLoader.loadScripts(0,
+ Function.createDelegate(this, Function.createCallback(this._scriptIncludesLoadComplete, data)),
+ Function.createDelegate(this, Function.createCallback(this._scriptIncludesLoadFailed, data)),
+ null);
+ }
+ function Sys$WebForms$PageRequestManager$_onWindowUnload(evt) {
+ this.dispose();
+ }
+ function Sys$WebForms$PageRequestManager$_pageLoaded(initialLoad, data) {
+ var handler = this._get_eventHandlerList().getHandler("pageLoaded");
+ if (handler) {
+ handler(this, this._getPageLoadedEventArgs(initialLoad, data));
+ }
+ if (!initialLoad) {
+ Sys.Application.raiseLoad();
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_pageLoadedInitialLoad(evt) {
+ this._pageLoaded(true, null);
+ }
+ function Sys$WebForms$PageRequestManager$_parseDelta(executor) {
+ var reply = executor.get_responseData();
+ var delimiterIndex, len, type, id, content;
+ var replyIndex = 0;
+ var parserErrorDetails = null;
+ var delta = [];
+ while (replyIndex < reply.length) {
+ delimiterIndex = reply.indexOf('|', replyIndex);
+ if (delimiterIndex === -1) {
+ parserErrorDetails = this._findText(reply, replyIndex);
+ break;
+ }
+ len = parseInt(reply.substring(replyIndex, delimiterIndex), 10);
+ if ((len % 1) !== 0) {
+ parserErrorDetails = this._findText(reply, replyIndex);
+ break;
+ }
+ replyIndex = delimiterIndex + 1;
+ delimiterIndex = reply.indexOf('|', replyIndex);
+ if (delimiterIndex === -1) {
+ parserErrorDetails = this._findText(reply, replyIndex);
+ break;
+ }
+ type = reply.substring(replyIndex, delimiterIndex);
+ replyIndex = delimiterIndex + 1;
+ delimiterIndex = reply.indexOf('|', replyIndex);
+ if (delimiterIndex === -1) {
+ parserErrorDetails = this._findText(reply, replyIndex);
+ break;
+ }
+ id = reply.substring(replyIndex, delimiterIndex);
+ replyIndex = delimiterIndex + 1;
+ if ((replyIndex + len) >= reply.length) {
+ parserErrorDetails = this._findText(reply, reply.length);
+ break;
+ }
+ content = reply.substr(replyIndex, len);
+ replyIndex += len;
+ if (reply.charAt(replyIndex) !== '|') {
+ parserErrorDetails = this._findText(reply, replyIndex);
+ break;
+ }
+ replyIndex++;
+ Array.add(delta, {type: type, id: id, content: content});
+ }
+ if (parserErrorDetails) {
+ this._endPostBack(this._createPageRequestManagerParserError(String.format(Sys.WebForms.Res.PRM_ParserErrorDetails, parserErrorDetails)), executor, null);
+ return null;
+ }
+ var updatePanelNodes = [];
+ var hiddenFieldNodes = [];
+ var arrayDeclarationNodes = [];
+ var scriptBlockNodes = [];
+ var scriptStartupNodes = [];
+ var expandoNodes = [];
+ var onSubmitNodes = [];
+ var dataItemNodes = [];
+ var dataItemJsonNodes = [];
+ var scriptDisposeNodes = [];
+ var asyncPostBackControlIDsNode, postBackControlIDsNode,
+ updatePanelIDsNode, asyncPostBackTimeoutNode,
+ childUpdatePanelIDsNode, panelsToRefreshNode, formActionNode,
+ versionNode;
+ for (var i = 0, l = delta.length; i < l; i++) {
+ var deltaNode = delta[i];
+ switch (deltaNode.type) {
+ case "#":
+ versionNode = deltaNode;
+ break;
+ case "updatePanel":
+ Array.add(updatePanelNodes, deltaNode);
+ break;
+ case "hiddenField":
+ Array.add(hiddenFieldNodes, deltaNode);
+ break;
+ case "arrayDeclaration":
+ Array.add(arrayDeclarationNodes, deltaNode);
+ break;
+ case "scriptBlock":
+ Array.add(scriptBlockNodes, deltaNode);
+ break;
+ case "fallbackScript":
+ scriptBlockNodes[scriptBlockNodes.length - 1].fallback = deltaNode.id;
+ case "scriptStartupBlock":
+ Array.add(scriptStartupNodes, deltaNode);
+ break;
+ case "expando":
+ Array.add(expandoNodes, deltaNode);
+ break;
+ case "onSubmit":
+ Array.add(onSubmitNodes, deltaNode);
+ break;
+ case "asyncPostBackControlIDs":
+ asyncPostBackControlIDsNode = deltaNode;
+ break;
+ case "postBackControlIDs":
+ postBackControlIDsNode = deltaNode;
+ break;
+ case "updatePanelIDs":
+ updatePanelIDsNode = deltaNode;
+ break;
+ case "asyncPostBackTimeout":
+ asyncPostBackTimeoutNode = deltaNode;
+ break;
+ case "childUpdatePanelIDs":
+ childUpdatePanelIDsNode = deltaNode;
+ break;
+ case "panelsToRefreshIDs":
+ panelsToRefreshNode = deltaNode;
+ break;
+ case "formAction":
+ formActionNode = deltaNode;
+ break;
+ case "dataItem":
+ Array.add(dataItemNodes, deltaNode);
+ break;
+ case "dataItemJson":
+ Array.add(dataItemJsonNodes, deltaNode);
+ break;
+ case "scriptDispose":
+ Array.add(scriptDisposeNodes, deltaNode);
+ break;
+ case "pageRedirect":
+ if (versionNode && parseFloat(versionNode.content) >= 4) {
+ deltaNode.content = unescape(deltaNode.content);
+ }
+ if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {
+ var anchor = document.createElement("a");
+ anchor.style.display = 'none';
+ anchor.attachEvent("onclick", cancelBubble);
+ anchor.href = deltaNode.content;
+ this._form.parentNode.insertBefore(anchor, this._form);
+ anchor.click();
+ anchor.detachEvent("onclick", cancelBubble);
+ this._form.parentNode.removeChild(anchor);
+
+ function cancelBubble(e) {
+ e.cancelBubble = true;
+ }
+ }
+ else {
+ window.location.href = deltaNode.content;
+ }
+ return null;
+ case "error":
+ this._endPostBack(this._createPageRequestManagerServerError(Number.parseInvariant(deltaNode.id), deltaNode.content), executor, null);
+ return null;
+ case "pageTitle":
+ document.title = deltaNode.content;
+ break;
+ case "focus":
+ this._controlIDToFocus = deltaNode.content;
+ break;
+ default:
+ this._endPostBack(this._createPageRequestManagerParserError(String.format(Sys.WebForms.Res.PRM_UnknownToken, deltaNode.type)), executor, null);
+ return null;
+ }
+ }
+ return {
+ version4: versionNode ? (parseFloat(versionNode.content) >= 4) : false,
+ executor: executor,
+ updatePanelNodes: updatePanelNodes,
+ hiddenFieldNodes: hiddenFieldNodes,
+ arrayDeclarationNodes: arrayDeclarationNodes,
+ scriptBlockNodes: scriptBlockNodes,
+ scriptStartupNodes: scriptStartupNodes,
+ expandoNodes: expandoNodes,
+ onSubmitNodes: onSubmitNodes,
+ dataItemNodes: dataItemNodes,
+ dataItemJsonNodes: dataItemJsonNodes,
+ scriptDisposeNodes: scriptDisposeNodes,
+ asyncPostBackControlIDsNode: asyncPostBackControlIDsNode,
+ postBackControlIDsNode: postBackControlIDsNode,
+ updatePanelIDsNode: updatePanelIDsNode,
+ asyncPostBackTimeoutNode: asyncPostBackTimeoutNode,
+ childUpdatePanelIDsNode: childUpdatePanelIDsNode,
+ panelsToRefreshNode: panelsToRefreshNode,
+ formActionNode: formActionNode };
+ }
+ function Sys$WebForms$PageRequestManager$_processUpdatePanelArrays(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, version4) {
+ var newUpdatePanelIDs, newUpdatePanelClientIDs, newUpdatePanelHasChildrenAsTriggers;
+
+ if (updatePanelIDs) {
+ var l = updatePanelIDs.length,
+ m = version4 ? 2 : 1;
+ newUpdatePanelIDs = new Array(l/m);
+ newUpdatePanelClientIDs = new Array(l/m);
+ newUpdatePanelHasChildrenAsTriggers = new Array(l/m);
+
+ for (var i = 0, j = 0; i < l; i += m, j++) {
+ var ct,
+ uniqueID = updatePanelIDs[i],
+ clientID = version4 ? updatePanelIDs[i+1] : "";
+ ct = (uniqueID.charAt(0) === 't');
+ uniqueID = uniqueID.substr(1);
+ if (!clientID) {
+ clientID = this._uniqueIDToClientID(uniqueID);
+ }
+ newUpdatePanelHasChildrenAsTriggers[j] = ct;
+ newUpdatePanelIDs[j] = uniqueID;
+ newUpdatePanelClientIDs[j] = clientID;
+ }
+ }
+ else {
+ newUpdatePanelIDs = [];
+ newUpdatePanelClientIDs = [];
+ newUpdatePanelHasChildrenAsTriggers = [];
+ }
+ var newAsyncPostBackControlIDs = [];
+ var newAsyncPostBackControlClientIDs = [];
+ this._convertToClientIDs(asyncPostBackControlIDs, newAsyncPostBackControlIDs, newAsyncPostBackControlClientIDs, version4);
+ var newPostBackControlIDs = [];
+ var newPostBackControlClientIDs = [];
+ this._convertToClientIDs(postBackControlIDs, newPostBackControlIDs, newPostBackControlClientIDs, version4);
+
+ return {
+ updatePanelIDs: newUpdatePanelIDs,
+ updatePanelClientIDs: newUpdatePanelClientIDs,
+ updatePanelHasChildrenAsTriggers: newUpdatePanelHasChildrenAsTriggers,
+ asyncPostBackControlIDs: newAsyncPostBackControlIDs,
+ asyncPostBackControlClientIDs: newAsyncPostBackControlClientIDs,
+ postBackControlIDs: newPostBackControlIDs,
+ postBackControlClientIDs: newPostBackControlClientIDs
+ };
+ }
+ function Sys$WebForms$PageRequestManager$_queueScripts(scriptLoader, scriptBlockNodes, queueIncludes, queueBlocks) {
+
+ for (var i = 0, l = scriptBlockNodes.length; i < l; i++) {
+ var scriptBlockType = scriptBlockNodes[i].id;
+ switch (scriptBlockType) {
+ case "ScriptContentNoTags":
+ if (!queueBlocks) {
+ continue;
+ }
+ scriptLoader.queueScriptBlock(scriptBlockNodes[i].content);
+ break;
+ case "ScriptContentWithTags":
+ var scriptTagAttributes;
+ eval("scriptTagAttributes = " + scriptBlockNodes[i].content);
+ if (scriptTagAttributes.src) {
+ if (!queueIncludes || Sys._ScriptLoader.isScriptLoaded(scriptTagAttributes.src)) {
+ continue;
+ }
+ }
+ else if (!queueBlocks) {
+ continue;
+ }
+ scriptLoader.queueCustomScriptTag(scriptTagAttributes);
+ break;
+ case "ScriptPath":
+ var script = scriptBlockNodes[i];
+ if (!queueIncludes || Sys._ScriptLoader.isScriptLoaded(script.content)) {
+ continue;
+ }
+ scriptLoader.queueScriptReference(script.content, script.fallback);
+ break;
+ }
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_registerDisposeScript(panelID, disposeScript) {
+ if (!this._scriptDisposes[panelID]) {
+ this._scriptDisposes[panelID] = [disposeScript];
+ }
+ else {
+ Array.add(this._scriptDisposes[panelID], disposeScript);
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_scriptIncludesLoadComplete(scriptLoader, data) {
+
+
+ if (data.executor.get_webRequest() !== this._request) {
+ return;
+ }
+
+ this._commitControls(data.updatePanelData,
+ data.asyncPostBackTimeoutNode ? data.asyncPostBackTimeoutNode.content : null);
+ if (data.formActionNode) {
+ this._form.action = data.formActionNode.content;
+ }
+
+ var i, l, node;
+ for (i = 0, l = data.updatePanelNodes.length; i < l; i++) {
+ node = data.updatePanelNodes[i];
+ var updatePanelElement = document.getElementById(node.id);
+ if (!updatePanelElement) {
+ this._endPostBack(Error.invalidOperation(String.format(Sys.WebForms.Res.PRM_MissingPanel, node.id)), data.executor, data);
+ return;
+ }
+ this._updatePanel(updatePanelElement, node.content);
+ }
+ for (i = 0, l = data.scriptDisposeNodes.length; i < l; i++) {
+ node = data.scriptDisposeNodes[i];
+ this._registerDisposeScript(node.id, node.content);
+ }
+ for (i = 0, l = this._transientFields.length; i < l; i++) {
+ var field = document.getElementById(this._transientFields[i]);
+ if (field) {
+ var toRemove = field._isContained ? field.parentNode : field;
+ toRemove.parentNode.removeChild(toRemove);
+ }
+ }
+ for (i = 0, l = data.hiddenFieldNodes.length; i < l; i++) {
+ node = data.hiddenFieldNodes[i];
+ this._createHiddenField(node.id, node.content);
+ }
+
+ if (data.scriptsFailed) {
+ throw Sys._ScriptLoader._errorScriptLoadFailed(data.scriptsFailed.src, data.scriptsFailed.multipleCallbacks);
+ }
+
+ this._queueScripts(scriptLoader, data.scriptBlockNodes, false, true);
+ var arrayScript = '';
+ for (i = 0, l = data.arrayDeclarationNodes.length; i < l; i++) {
+ node = data.arrayDeclarationNodes[i];
+ arrayScript += "Sys.WebForms.PageRequestManager._addArrayElement('" + node.id + "', " + node.content + ");\r\n";
+ }
+ var expandoScript = '';
+ for (i = 0, l = data.expandoNodes.length; i < l; i++) {
+ node = data.expandoNodes[i];
+ expandoScript += node.id + " = " + node.content + "\r\n";
+ }
+ if (arrayScript.length) {
+ scriptLoader.queueScriptBlock(arrayScript);
+ }
+ if (expandoScript.length) {
+ scriptLoader.queueScriptBlock(expandoScript);
+ }
+
+ this._queueScripts(scriptLoader, data.scriptStartupNodes, true, true);
+ var onSubmitStatementScript = '';
+ for (i = 0, l = data.onSubmitNodes.length; i < l; i++) {
+ if (i === 0) {
+ onSubmitStatementScript = 'Array.add(Sys.WebForms.PageRequestManager.getInstance()._onSubmitStatements, function() {\r\n';
+ }
+ onSubmitStatementScript += data.onSubmitNodes[i].content + "\r\n";
+ }
+ if (onSubmitStatementScript.length) {
+ onSubmitStatementScript += "\r\nreturn true;\r\n});\r\n";
+ scriptLoader.queueScriptBlock(onSubmitStatementScript);
+ }
+ scriptLoader.loadScripts(0,
+ Function.createDelegate(this, Function.createCallback(this._scriptsLoadComplete, data)), null, null);
+ }
+ function Sys$WebForms$PageRequestManager$_scriptIncludesLoadFailed(scriptLoader, scriptElement, multipleCallbacks, data) {
+ data.scriptsFailed = { src: scriptElement.src, multipleCallbacks: multipleCallbacks };
+ this._scriptIncludesLoadComplete(scriptLoader, data);
+ }
+ function Sys$WebForms$PageRequestManager$_scriptsLoadComplete(scriptLoader, data) {
+
+
+ var response = data.executor;
+ if (window.__theFormPostData) {
+ window.__theFormPostData = "";
+ }
+ if (window.__theFormPostCollection) {
+ window.__theFormPostCollection = [];
+ }
+ if (window.WebForm_InitCallback) {
+ window.WebForm_InitCallback();
+ }
+ if (this._scrollPosition) {
+ if (window.scrollTo) {
+ window.scrollTo(this._scrollPosition.x, this._scrollPosition.y);
+ }
+ this._scrollPosition = null;
+ }
+ Sys.Application.endCreateComponents();
+ this._pageLoaded(false, data);
+ this._endPostBack(null, response, data);
+ if (this._controlIDToFocus) {
+ var focusTarget;
+ var oldContentEditableSetting;
+ if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {
+ var targetControl = $get(this._controlIDToFocus);
+ focusTarget = targetControl;
+ if (targetControl && (!WebForm_CanFocus(targetControl))) {
+ focusTarget = WebForm_FindFirstFocusableChild(targetControl);
+ }
+ if (focusTarget && (typeof(focusTarget.contentEditable) !== "undefined")) {
+ oldContentEditableSetting = focusTarget.contentEditable;
+ focusTarget.contentEditable = false;
+ }
+ else {
+ focusTarget = null;
+ }
+ }
+ WebForm_AutoFocus(this._controlIDToFocus);
+ if (focusTarget) {
+ focusTarget.contentEditable = oldContentEditableSetting;
+ }
+ this._controlIDToFocus = null;
+ }
+ }
+ function Sys$WebForms$PageRequestManager$_splitNodeIntoArray(node) {
+ var str = node.content;
+ var arr = str.length ? str.split(',') : [];
+ return arr;
+ }
+ function Sys$WebForms$PageRequestManager$_uniqueIDToClientID(uniqueID) {
+ return uniqueID.replace(/\$/g, '_');
+ }
+ function Sys$WebForms$PageRequestManager$_updateControls(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, asyncPostBackTimeout, version4) {
+ this._commitControls(
+ this._processUpdatePanelArrays(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, version4),
+ asyncPostBackTimeout);
+ }
+ function Sys$WebForms$PageRequestManager$_updatePanel(updatePanelElement, rendering) {
+ for (var updatePanelID in this._scriptDisposes) {
+ if (this._elementContains(updatePanelElement, document.getElementById(updatePanelID))) {
+ var disposeScripts = this._scriptDisposes[updatePanelID];
+ for (var i = 0, l = disposeScripts.length; i < l; i++) {
+ eval(disposeScripts[i]);
+ }
+ delete this._scriptDisposes[updatePanelID];
+ }
+ }
+ Sys.Application.disposeElement(updatePanelElement, true);
+ updatePanelElement.innerHTML = rendering;
+ }
+ function Sys$WebForms$PageRequestManager$_validPosition(position) {
+ return (typeof(position) !== "undefined") && (position !== null) && (position !== 0);
+ }
+Sys.WebForms.PageRequestManager.prototype = {
+ _get_eventHandlerList: Sys$WebForms$PageRequestManager$_get_eventHandlerList,
+ get_isInAsyncPostBack: Sys$WebForms$PageRequestManager$get_isInAsyncPostBack,
+ add_beginRequest: Sys$WebForms$PageRequestManager$add_beginRequest,
+ remove_beginRequest: Sys$WebForms$PageRequestManager$remove_beginRequest,
+ add_endRequest: Sys$WebForms$PageRequestManager$add_endRequest,
+ remove_endRequest: Sys$WebForms$PageRequestManager$remove_endRequest,
+ add_initializeRequest: Sys$WebForms$PageRequestManager$add_initializeRequest,
+ remove_initializeRequest: Sys$WebForms$PageRequestManager$remove_initializeRequest,
+ add_pageLoaded: Sys$WebForms$PageRequestManager$add_pageLoaded,
+ remove_pageLoaded: Sys$WebForms$PageRequestManager$remove_pageLoaded,
+ add_pageLoading: Sys$WebForms$PageRequestManager$add_pageLoading,
+ remove_pageLoading: Sys$WebForms$PageRequestManager$remove_pageLoading,
+ abortPostBack: Sys$WebForms$PageRequestManager$abortPostBack,
+ beginAsyncPostBack: Sys$WebForms$PageRequestManager$beginAsyncPostBack,
+ _cancelPendingCallbacks: Sys$WebForms$PageRequestManager$_cancelPendingCallbacks,
+ _commitControls: Sys$WebForms$PageRequestManager$_commitControls,
+ _createHiddenField: Sys$WebForms$PageRequestManager$_createHiddenField,
+ _createPageRequestManagerTimeoutError: Sys$WebForms$PageRequestManager$_createPageRequestManagerTimeoutError,
+ _createPageRequestManagerServerError: Sys$WebForms$PageRequestManager$_createPageRequestManagerServerError,
+ _createPageRequestManagerParserError: Sys$WebForms$PageRequestManager$_createPageRequestManagerParserError,
+ _createPanelID: Sys$WebForms$PageRequestManager$_createPanelID,
+ _createPostBackSettings: Sys$WebForms$PageRequestManager$_createPostBackSettings,
+ _convertToClientIDs: Sys$WebForms$PageRequestManager$_convertToClientIDs,
+ dispose: Sys$WebForms$PageRequestManager$dispose,
+ _doCallback: Sys$WebForms$PageRequestManager$_doCallback,
+ _doPostBack: Sys$WebForms$PageRequestManager$_doPostBack,
+ _doPostBackWithOptions: Sys$WebForms$PageRequestManager$_doPostBackWithOptions,
+ _elementContains: Sys$WebForms$PageRequestManager$_elementContains,
+ _endPostBack: Sys$WebForms$PageRequestManager$_endPostBack,
+ _ensureUniqueIds: Sys$WebForms$PageRequestManager$_ensureUniqueIds,
+ _findNearestElement: Sys$WebForms$PageRequestManager$_findNearestElement,
+ _findText: Sys$WebForms$PageRequestManager$_findText,
+ _fireDefaultButton: Sys$WebForms$PageRequestManager$_fireDefaultButton,
+ _getPageLoadedEventArgs: Sys$WebForms$PageRequestManager$_getPageLoadedEventArgs,
+ _getPageLoadingEventArgs: Sys$WebForms$PageRequestManager$_getPageLoadingEventArgs,
+ _getPostBackSettings: Sys$WebForms$PageRequestManager$_getPostBackSettings,
+ _getScrollPosition: Sys$WebForms$PageRequestManager$_getScrollPosition,
+ _initializeInternal: Sys$WebForms$PageRequestManager$_initializeInternal,
+ _matchesParentIDInList: Sys$WebForms$PageRequestManager$_matchesParentIDInList,
+ _onFormElementActive: Sys$WebForms$PageRequestManager$_onFormElementActive,
+ _onFormElementClick: Sys$WebForms$PageRequestManager$_onFormElementClick,
+ _onFormSubmit: Sys$WebForms$PageRequestManager$_onFormSubmit,
+ _onFormSubmitCompleted: Sys$WebForms$PageRequestManager$_onFormSubmitCompleted,
+ _onWindowUnload: Sys$WebForms$PageRequestManager$_onWindowUnload,
+ _pageLoaded: Sys$WebForms$PageRequestManager$_pageLoaded,
+ _pageLoadedInitialLoad: Sys$WebForms$PageRequestManager$_pageLoadedInitialLoad,
+ _parseDelta: Sys$WebForms$PageRequestManager$_parseDelta,
+ _processUpdatePanelArrays: Sys$WebForms$PageRequestManager$_processUpdatePanelArrays,
+ _queueScripts: Sys$WebForms$PageRequestManager$_queueScripts,
+ _registerDisposeScript: Sys$WebForms$PageRequestManager$_registerDisposeScript,
+ _scriptIncludesLoadComplete: Sys$WebForms$PageRequestManager$_scriptIncludesLoadComplete,
+ _scriptIncludesLoadFailed: Sys$WebForms$PageRequestManager$_scriptIncludesLoadFailed,
+ _scriptsLoadComplete: Sys$WebForms$PageRequestManager$_scriptsLoadComplete,
+ _splitNodeIntoArray: Sys$WebForms$PageRequestManager$_splitNodeIntoArray,
+ _uniqueIDToClientID: Sys$WebForms$PageRequestManager$_uniqueIDToClientID,
+ _updateControls: Sys$WebForms$PageRequestManager$_updateControls,
+ _updatePanel: Sys$WebForms$PageRequestManager$_updatePanel,
+ _validPosition: Sys$WebForms$PageRequestManager$_validPosition
+}
+Sys.WebForms.PageRequestManager.getInstance = function Sys$WebForms$PageRequestManager$getInstance() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ var prm = Sys.WebForms.PageRequestManager._instance;
+ if (!prm) {
+ prm = Sys.WebForms.PageRequestManager._instance = new Sys.WebForms.PageRequestManager();
+ }
+ return prm;
+}
+Sys.WebForms.PageRequestManager._addArrayElement = function Sys$WebForms$PageRequestManager$_addArrayElement(arrayName) {
+ if (!window[arrayName]) {
+ window[arrayName] = new Array();
+ }
+ for (var i = 1, l = arguments.length; i < l; i++) {
+ Array.add(window[arrayName], arguments[i]);
+ }
+}
+Sys.WebForms.PageRequestManager._initialize = function Sys$WebForms$PageRequestManager$_initialize() {
+ var prm = Sys.WebForms.PageRequestManager.getInstance();
+ prm._initializeInternal.apply(prm, arguments);
+}
+Sys.WebForms.PageRequestManager.registerClass('Sys.WebForms.PageRequestManager');
+
+Sys.UI._UpdateProgress = function Sys$UI$_UpdateProgress(element) {
+ Sys.UI._UpdateProgress.initializeBase(this,[element]);
+ this._displayAfter = 500;
+ this._dynamicLayout = true;
+ this._associatedUpdatePanelId = null;
+ this._beginRequestHandlerDelegate = null;
+ this._startDelegate = null;
+ this._endRequestHandlerDelegate = null;
+ this._pageRequestManager = null;
+ this._timerCookie = null;
+}
+ function Sys$UI$_UpdateProgress$get_displayAfter() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._displayAfter;
+ }
+ function Sys$UI$_UpdateProgress$set_displayAfter(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Number}]);
+ if (e) throw e;
+ this._displayAfter = value;
+ }
+ function Sys$UI$_UpdateProgress$get_dynamicLayout() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._dynamicLayout;
+ }
+ function Sys$UI$_UpdateProgress$set_dynamicLayout(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
+ if (e) throw e;
+ this._dynamicLayout = value;
+ }
+ function Sys$UI$_UpdateProgress$get_associatedUpdatePanelId() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._associatedUpdatePanelId;
+ }
+ function Sys$UI$_UpdateProgress$set_associatedUpdatePanelId(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: String, mayBeNull: true}]);
+ if (e) throw e;
+ this._associatedUpdatePanelId = value;
+ }
+ function Sys$UI$_UpdateProgress$get_role() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return "status";
+ }
+ function Sys$UI$_UpdateProgress$_clearTimeout() {
+ if (this._timerCookie) {
+ window.clearTimeout(this._timerCookie);
+ this._timerCookie = null;
+ }
+ }
+ function Sys$UI$_UpdateProgress$_getUniqueID(clientID) {
+ var i = Array.indexOf(this._pageRequestManager._updatePanelClientIDs, clientID);
+ return i === -1 ? null : this._pageRequestManager._updatePanelIDs[i];
+ }
+ function Sys$UI$_UpdateProgress$_handleBeginRequest(sender, arg) {
+ var curElem = arg.get_postBackElement(),
+ showProgress = true,
+ upID = this._associatedUpdatePanelId;
+ if (this._associatedUpdatePanelId) {
+ var updating = arg.get_updatePanelsToUpdate();
+ if (updating && updating.length) {
+ showProgress = (Array.contains(updating, upID) || Array.contains(updating, this._getUniqueID(upID)))
+ }
+ else {
+ showProgress = false;
+ }
+ }
+ while (!showProgress && curElem) {
+ if (curElem.id && this._associatedUpdatePanelId === curElem.id) {
+ showProgress = true;
+ }
+ curElem = curElem.parentNode;
+ }
+ if (showProgress) {
+ this._timerCookie = window.setTimeout(this._startDelegate, this._displayAfter);
+ }
+ }
+ function Sys$UI$_UpdateProgress$_startRequest() {
+ if (this._pageRequestManager.get_isInAsyncPostBack()) {
+ var element = this.get_element();
+ if (this._dynamicLayout) {
+ element.style.display = 'block';
+ }
+ else {
+ element.style.visibility = 'visible';
+ }
+ if (this.get_role() === "status") {
+ element.setAttribute("aria-hidden", "false");
+ }
+ }
+ this._timerCookie = null;
+ }
+ function Sys$UI$_UpdateProgress$_handleEndRequest(sender, arg) {
+ var element = this.get_element();
+ if (this._dynamicLayout) {
+ element.style.display = 'none';
+ }
+ else {
+ element.style.visibility = 'hidden';
+ }
+ if (this.get_role() === "status") {
+ element.setAttribute("aria-hidden", "true");
+ }
+ this._clearTimeout();
+ }
+ function Sys$UI$_UpdateProgress$dispose() {
+ if (this._beginRequestHandlerDelegate !== null) {
+ this._pageRequestManager.remove_beginRequest(this._beginRequestHandlerDelegate);
+ this._pageRequestManager.remove_endRequest(this._endRequestHandlerDelegate);
+ this._beginRequestHandlerDelegate = null;
+ this._endRequestHandlerDelegate = null;
+ }
+ this._clearTimeout();
+ Sys.UI._UpdateProgress.callBaseMethod(this,"dispose");
+ }
+ function Sys$UI$_UpdateProgress$initialize() {
+ Sys.UI._UpdateProgress.callBaseMethod(this, 'initialize');
+ if (this.get_role() === "status") {
+ this.get_element().setAttribute("aria-hidden", "true");
+ }
+ this._beginRequestHandlerDelegate = Function.createDelegate(this, this._handleBeginRequest);
+ this._endRequestHandlerDelegate = Function.createDelegate(this, this._handleEndRequest);
+ this._startDelegate = Function.createDelegate(this, this._startRequest);
+ if (Sys.WebForms && Sys.WebForms.PageRequestManager) {
+ this._pageRequestManager = Sys.WebForms.PageRequestManager.getInstance();
+ }
+ if (this._pageRequestManager !== null ) {
+ this._pageRequestManager.add_beginRequest(this._beginRequestHandlerDelegate);
+ this._pageRequestManager.add_endRequest(this._endRequestHandlerDelegate);
+ }
+ }
+Sys.UI._UpdateProgress.prototype = {
+ get_displayAfter: Sys$UI$_UpdateProgress$get_displayAfter,
+ set_displayAfter: Sys$UI$_UpdateProgress$set_displayAfter,
+ get_dynamicLayout: Sys$UI$_UpdateProgress$get_dynamicLayout,
+ set_dynamicLayout: Sys$UI$_UpdateProgress$set_dynamicLayout,
+ get_associatedUpdatePanelId: Sys$UI$_UpdateProgress$get_associatedUpdatePanelId,
+ set_associatedUpdatePanelId: Sys$UI$_UpdateProgress$set_associatedUpdatePanelId,
+ get_role: Sys$UI$_UpdateProgress$get_role,
+ _clearTimeout: Sys$UI$_UpdateProgress$_clearTimeout,
+ _getUniqueID: Sys$UI$_UpdateProgress$_getUniqueID,
+ _handleBeginRequest: Sys$UI$_UpdateProgress$_handleBeginRequest,
+ _startRequest: Sys$UI$_UpdateProgress$_startRequest,
+ _handleEndRequest: Sys$UI$_UpdateProgress$_handleEndRequest,
+ dispose: Sys$UI$_UpdateProgress$dispose,
+ initialize: Sys$UI$_UpdateProgress$initialize
+}
+Sys.UI._UpdateProgress.registerClass('Sys.UI._UpdateProgress', Sys.UI.Control);
+
+
+Type.registerNamespace('Sys.WebForms');
+Sys.WebForms.Res={
+"PRM_UnknownToken":"Unknown token: \u0027{0}\u0027.",
+"PRM_MissingPanel":"Could not find UpdatePanel with ID \u0027{0}\u0027. If it is being updated dynamically then it must be inside another UpdatePanel.",
+"PRM_ServerError":"An unknown error occurred while processing the request on the server. The status code returned from the server was: {0}",
+"PRM_ParserError":"The message received from the server could not be parsed.",
+"PRM_TimeoutError":"The server request timed out.",
+"PRM_ParserErrorDetails":"Error parsing near \u0027{0}\u0027.",
+"PRM_CannotRegisterTwice":"The PageRequestManager cannot be initialized more than once."
+};
diff --git a/niayesh/ScriptResource.axd b/niayesh/ScriptResource.axd
new file mode 100644
index 0000000..34874e2
--- /dev/null
+++ b/niayesh/ScriptResource.axd
@@ -0,0 +1,7181 @@
+// Name: MicrosoftAjax.debug.js
+// Assembly: System.Web.Extensions
+// Version: 4.0.0.0
+// FileVersion: 4.8.4676.0
+//-----------------------------------------------------------------------
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------
+// MicrosoftAjax.js
+// Microsoft AJAX Framework.
+
+Function.__typeName = 'Function';
+Function.__class = true;
+Function.createCallback = function Function$createCallback(method, context) {
+ ///
+ ///
+ ///
+ ///
+ 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 Function$createDelegate(instance, method) {
+ ///
+ ///
+ ///
+ ///
+ 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$emptyMethod() {
+ ///
+}
+Function.validateParameters = function Function$validateParameters(parameters, expectedParameters, validateParameterCount) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ 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$_validateParams(params, expectedParams, validateParameterCount) {
+ var e, expectedLength = expectedParams.length;
+ validateParameterCount = validateParameterCount || (typeof(validateParameterCount) === "undefined");
+ e = Function._validateParameterCount(params, expectedParams, validateParameterCount);
+ if (e) {
+ e.popStackFrame();
+ return e;
+ }
+ for (var i = 0, l = params.length; i < l; i++) {
+ var expectedParam = expectedParams[Math.min(i, expectedLength - 1)],
+ paramName = expectedParam.name;
+ if (expectedParam.parameterArray) {
+ paramName += "[" + (i - expectedLength + 1) + "]";
+ }
+ else if (!validateParameterCount && (i >= expectedLength)) {
+ break;
+ }
+ e = Function._validateParameter(params[i], expectedParam, paramName);
+ if (e) {
+ e.popStackFrame();
+ return e;
+ }
+ }
+ return null;
+}
+Function._validateParameterCount = 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$_validateParameter(param, expectedParam, paramName) {
+ var e,
+ expectedType = expectedParam.type,
+ expectedInteger = !!expectedParam.integer,
+ expectedDomElement = !!expectedParam.domElement,
+ mayBeNull = !!expectedParam.mayBeNull;
+ e = Function._validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName);
+ if (e) {
+ e.popStackFrame();
+ return e;
+ }
+ var expectedElementType = expectedParam.elementType,
+ elementMayBeNull = !!expectedParam.elementMayBeNull;
+ if (expectedType === Array && typeof(param) !== "undefined" && param !== null &&
+ (expectedElementType || !elementMayBeNull)) {
+ var expectedElementInteger = !!expectedParam.elementInteger,
+ expectedElementDomElement = !!expectedParam.elementDomElement;
+ for (var i=0; i < param.length; i++) {
+ var elem = param[i];
+ e = Function._validateParameterType(elem, expectedElementType,
+ expectedElementInteger, expectedElementDomElement, elementMayBeNull,
+ paramName + "[" + i + "]");
+ if (e) {
+ e.popStackFrame();
+ return e;
+ }
+ }
+ }
+ return null;
+}
+Function._validateParameterType = 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$create(message, errorInfo) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "message", type: String, mayBeNull: true, optional: true},
+ {name: "errorInfo", mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ var err = new Error(message);
+ err.message = message;
+ if (errorInfo) {
+ for (var v in errorInfo) {
+ err[v] = errorInfo[v];
+ }
+ }
+ err.popStackFrame();
+ return err;
+}
+Error.argument = function Error$argument(paramName, message) {
+ ///
+ ///
+ ///
+ ///
+ 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$argumentNull(paramName, message) {
+ ///
+ ///
+ ///
+ ///
+ 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.ArgumentNullException: " + (message ? message : Sys.Res.argumentNull);
+ if (paramName) {
+ displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);
+ }
+ var err = Error.create(displayMessage, { name: "Sys.ArgumentNullException", paramName: paramName });
+ err.popStackFrame();
+ return err;
+}
+Error.argumentOutOfRange = function Error$argumentOutOfRange(paramName, actualValue, message) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ 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$argumentType(paramName, actualType, expectedType, message) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "paramName", type: String, mayBeNull: true, optional: true},
+ {name: "actualType", type: Type, mayBeNull: true, optional: true},
+ {name: "expectedType", type: Type, mayBeNull: true, optional: true},
+ {name: "message", type: String, mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ var displayMessage = "Sys.ArgumentTypeException: ";
+ if (message) {
+ displayMessage += message;
+ }
+ else if (actualType && expectedType) {
+ displayMessage +=
+ String.format(Sys.Res.argumentTypeWithTypes, actualType.getName(), expectedType.getName());
+ }
+ else {
+ displayMessage += Sys.Res.argumentType;
+ }
+ if (paramName) {
+ displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);
+ }
+ var err = Error.create(displayMessage, {
+ name: "Sys.ArgumentTypeException",
+ paramName: paramName,
+ actualType: actualType,
+ expectedType: expectedType
+ });
+ err.popStackFrame();
+ return err;
+}
+Error.argumentUndefined = function Error$argumentUndefined(paramName, message) {
+ ///
+ ///
+ ///
+ ///
+ 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$format(message) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "message", type: String, mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ var displayMessage = "Sys.FormatException: " + (message ? message : Sys.Res.format);
+ var err = Error.create(displayMessage, {name: 'Sys.FormatException'});
+ err.popStackFrame();
+ return err;
+}
+Error.invalidOperation = function Error$invalidOperation(message) {
+ ///
+ ///
+ ///
+ 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$notImplemented(message) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "message", type: String, mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ var displayMessage = "Sys.NotImplementedException: " + (message ? message : Sys.Res.notImplemented);
+ var err = Error.create(displayMessage, {name: 'Sys.NotImplementedException'});
+ err.popStackFrame();
+ return err;
+}
+Error.parameterCount = function Error$parameterCount(message) {
+ ///
+ ///
+ ///
+ 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$popStackFrame() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (typeof(this.stack) === "undefined" || this.stack === null ||
+ typeof(this.fileName) === "undefined" || this.fileName === null ||
+ typeof(this.lineNumber) === "undefined" || this.lineNumber === null) {
+ return;
+ }
+ var stackFrames = this.stack.split("\n");
+ var currentFrame = stackFrames[0];
+ var pattern = this.fileName + ":" + this.lineNumber;
+ while(typeof(currentFrame) !== "undefined" &&
+ currentFrame !== null &&
+ currentFrame.indexOf(pattern) === -1) {
+ stackFrames.shift();
+ currentFrame = stackFrames[0];
+ }
+ var nextFrame = stackFrames[1];
+ if (typeof(nextFrame) === "undefined" || nextFrame === null) {
+ return;
+ }
+ var nextFrameParts = nextFrame.match(/@(.*):(\d+)$/);
+ 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$getType(instance) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "instance"}
+ ]);
+ if (e) throw e;
+ var ctor = instance.constructor;
+ if (!ctor || (typeof(ctor) !== "function") || !ctor.__typeName || (ctor.__typeName === 'Object')) {
+ return Object;
+ }
+ return ctor;
+}
+Object.getTypeName = function Object$getTypeName(instance) {
+ ///
+ ///
+ ///
+ 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$endsWith(suffix) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "suffix", type: String}
+ ]);
+ if (e) throw e;
+ return (this.substr(this.length - suffix.length) === suffix);
+}
+String.prototype.startsWith = function String$startsWith(prefix) {
+ ///
+ ///
+ ///
+ 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$trim() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this.replace(/^\s+|\s+$/g, '');
+}
+String.prototype.trimEnd = function String$trimEnd() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this.replace(/\s+$/, '');
+}
+String.prototype.trimStart = function String$trimStart() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this.replace(/^\s+/, '');
+}
+String.format = function String$format(format, args) {
+ ///
+ ///
+ ///
+ ///
+ 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$_toFormattedString(useLocale, args) {
+ var result = '';
+ var format = args[0];
+ for (var i=0;;) {
+ var open = format.indexOf('{', i);
+ var close = format.indexOf('}', i);
+ if ((open < 0) && (close < 0)) {
+ result += format.slice(i);
+ break;
+ }
+ if ((close > 0) && ((close < open) || (open < 0))) {
+ if (format.charAt(close + 1) !== '}') {
+ throw Error.argument('format', Sys.Res.stringFormatBraceMismatch);
+ }
+ result += format.slice(i, close + 1);
+ i = close + 2;
+ continue;
+ }
+ result += format.slice(i, open);
+ i = open + 1;
+ if (format.charAt(i) === '{') {
+ result += '{';
+ i++;
+ continue;
+ }
+ if (close < 0) throw Error.argument('format', Sys.Res.stringFormatBraceMismatch);
+ var brace = format.substring(i, close);
+ var colonIndex = brace.indexOf(':');
+ var argNumber = parseInt((colonIndex < 0)? brace : brace.substring(0, colonIndex), 10) + 1;
+ if (isNaN(argNumber)) throw Error.argument('format', Sys.Res.stringFormatInvalid);
+ var argFormat = (colonIndex < 0)? '' : brace.substring(colonIndex + 1);
+ var arg = args[argNumber];
+ if (typeof(arg) === "undefined" || arg === null) {
+ arg = '';
+ }
+ if (arg.toFormattedString) {
+ result += arg.toFormattedString(argFormat);
+ }
+ else if (useLocale && arg.localeFormat) {
+ result += arg.localeFormat(argFormat);
+ }
+ else if (arg.format) {
+ result += arg.format(argFormat);
+ }
+ else
+ result += arg.toString();
+ i = close + 1;
+ }
+ return result;
+}
+
+Boolean.__typeName = 'Boolean';
+Boolean.__class = true;
+Boolean.parse = function Boolean$parse(value) {
+ ///
+ ///
+ ///
+ 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.__identifierRegExp = new RegExp("^[^.0-9 \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\][^. \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]*$", "i");
+Type.prototype.callBaseMethod = function Type$callBaseMethod(instance, name, baseArguments) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "instance"},
+ {name: "name", type: String},
+ {name: "baseArguments", type: Array, mayBeNull: true, optional: true, elementMayBeNull: true}
+ ]);
+ if (e) throw e;
+ var baseMethod = Sys._getBaseMethod(this, instance, name);
+ if (!baseMethod) throw Error.invalidOperation(String.format(Sys.Res.methodNotFound, name));
+ if (!baseArguments) {
+ return baseMethod.apply(instance);
+ }
+ else {
+ return baseMethod.apply(instance, baseArguments);
+ }
+}
+Type.prototype.getBaseMethod = function Type$getBaseMethod(instance, name) {
+ ///
+ ///
+ ///
+ ///
+ 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$getBaseType() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return (typeof(this.__baseType) === "undefined") ? null : this.__baseType;
+}
+Type.prototype.getInterfaces = function Type$getInterfaces() {
+ ///
+ ///
+ 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$getName() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return (typeof(this.__typeName) === "undefined") ? "" : this.__typeName;
+}
+Type.prototype.implementsInterface = function Type$implementsInterface(interfaceType) {
+ ///
+ ///
+ ///
+ 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$inheritsFrom(parentType) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "parentType", type: Type}
+ ]);
+ if (e) throw e;
+ this.resolveInheritance();
+ var baseType = this.__baseType;
+ while (baseType) {
+ if (baseType === parentType) {
+ return true;
+ }
+ baseType = baseType.__baseType;
+ }
+ return false;
+}
+Type.prototype.initializeBase = function Type$initializeBase(instance, baseArguments) {
+ ///
+ ///
+ ///
+ ///
+ 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$isImplementedBy(instance) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "instance", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ if (typeof(instance) === "undefined" || instance === null) return false;
+ var instanceType = Object.getType(instance);
+ return !!(instanceType.implementsInterface && instanceType.implementsInterface(this));
+}
+Type.prototype.isInstanceOfType = function Type$isInstanceOfType(instance) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "instance", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ return Sys._isInstanceOfType(this, instance);
+}
+Type.prototype.registerClass = function Type$registerClass(typeName, baseType, interfaceTypes) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "typeName", type: String},
+ {name: "baseType", type: Type, mayBeNull: true, optional: true},
+ {name: "interfaceTypes", type: Type, parameterArray: true}
+ ]);
+ 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));
+ if ((arguments.length > 1) && (typeof(baseType) === 'undefined')) throw Error.argumentUndefined('baseType');
+ if (baseType && !baseType.__class) throw Error.argument('baseType', Sys.Res.baseNotAClass);
+ this.prototype.constructor = this;
+ this.__typeName = typeName;
+ this.__class = true;
+ if (baseType) {
+ this.__baseType = baseType;
+ this.__basePrototypePending = true;
+ }
+ Sys.__upperCaseTypes[typeName.toUpperCase()] = this;
+ if (interfaceTypes) {
+ this.__interfaces = [];
+ this.resolveInheritance();
+ for (var i = 2, l = arguments.length; i < l; i++) {
+ var interfaceType = arguments[i];
+ if (!interfaceType.__interface) throw Error.argument('interfaceTypes[' + (i - 2) + ']', Sys.Res.notAnInterface);
+ for (var methodName in interfaceType.prototype) {
+ var method = interfaceType.prototype[methodName];
+ if (!this.prototype[methodName]) {
+ this.prototype[methodName] = method;
+ }
+ }
+ this.__interfaces.push(interfaceType);
+ }
+ }
+ Sys.__registeredTypes[typeName] = true;
+ return this;
+}
+Type.prototype.registerInterface = function Type$registerInterface(typeName) {
+ ///
+ ///
+ ///
+ 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$resolveInheritance() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this.__basePrototypePending) {
+ var baseType = this.__baseType;
+ baseType.resolveInheritance();
+ for (var memberName in baseType.prototype) {
+ var memberValue = baseType.prototype[memberName];
+ if (!this.prototype[memberName]) {
+ this.prototype[memberName] = memberValue;
+ }
+ }
+ delete this.__basePrototypePending;
+ }
+}
+Type.getRootNamespaces = function Type$getRootNamespaces() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return Array.clone(Sys.__rootNamespaces);
+}
+Type.isClass = function Type$isClass(type) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "type", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ if ((typeof(type) === 'undefined') || (type === null)) return false;
+ return !!type.__class;
+}
+Type.isInterface = function Type$isInterface(type) {
+ ///
+ ///
+ ///
+ 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$isNamespace(object) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "object", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ if ((typeof(object) === 'undefined') || (object === null)) return false;
+ return !!object.__namespace;
+}
+Type.parse = function Type$parse(typeName, ns) {
+ ///
+ ///
+ ///
+ ///
+ 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) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "namespacePath", type: String}
+ ]);
+ if (e) throw e;
+ Type._registerNamespace(namespacePath);
+}
+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$getName() {return this.__typeName;}
+ }
+ rootObject = ns;
+ }
+}
+Type._checkDependency = function Type$_checkDependency(dependency, featureName) {
+ var scripts = Type._registerScript._scripts, isDependent = (scripts ? (!!scripts[dependency]) : false);
+ if ((typeof(featureName) !== 'undefined') && !isDependent) {
+ throw Error.invalidOperation(String.format(Sys.Res.requiredScriptReferenceNotIncluded,
+ featureName, dependency));
+ }
+ return isDependent;
+}
+Type._registerScript = function Type$_registerScript(scriptName, dependencies) {
+ var scripts = Type._registerScript._scripts;
+ if (!scripts) {
+ Type._registerScript._scripts = scripts = {};
+ }
+ if (scripts[scriptName]) {
+ throw Error.invalidOperation(String.format(Sys.Res.scriptAlreadyLoaded, scriptName));
+ }
+ scripts[scriptName] = true;
+ if (dependencies) {
+ for (var i = 0, l = dependencies.length; i < l; i++) {
+ var dependency = dependencies[i];
+ if (!Type._checkDependency(dependency)) {
+ throw Error.invalidOperation(String.format(Sys.Res.scriptDependencyNotFound, scriptName, dependency));
+ }
+ }
+ }
+}
+Type._registerNamespace("Sys");
+Sys.__upperCaseTypes = {};
+Sys.__rootNamespaces = [Sys];
+Sys.__registeredTypes = {};
+Sys._isInstanceOfType = function Sys$_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$_getBaseMethod(type, instance, name) {
+ if (!Sys._isInstanceOfType(type, instance)) throw Error.argumentType('instance', Object.getType(instance), type);
+ var baseType = type.getBaseType();
+ if (baseType) {
+ var baseMethod = baseType.prototype[name];
+ return (baseMethod instanceof Function) ? baseMethod : null;
+ }
+ return null;
+}
+Sys._isDomElement = 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$enqueue(array, item) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "array", type: Array, elementMayBeNull: true},
+ {name: "item", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ array[array.length] = item;
+}
+Array.addRange = function Array$addRange(array, items) {
+ ///
+ ///
+ ///
+ 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$clear(array) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "array", type: Array, elementMayBeNull: true}
+ ]);
+ if (e) throw e;
+ array.length = 0;
+}
+Array.clone = function Array$clone(array) {
+ ///
+ ///
+ ///
+ 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$contains(array, item) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "array", type: Array, elementMayBeNull: true},
+ {name: "item", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ return (Sys._indexOf(array, item) >= 0);
+}
+Array.dequeue = function Array$dequeue(array) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "array", type: Array, elementMayBeNull: true}
+ ]);
+ if (e) throw e;
+ return array.shift();
+}
+Array.forEach = function Array$forEach(array, method, instance) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "array", type: Array, elementMayBeNull: true},
+ {name: "method", type: Function},
+ {name: "instance", mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ for (var i = 0, l = array.length; i < l; i++) {
+ var elt = array[i];
+ if (typeof(elt) !== 'undefined') method.call(instance, elt, i, array);
+ }
+}
+Array.indexOf = function Array$indexOf(array, item, start) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ 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$insert(array, index, item) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "array", type: Array, elementMayBeNull: true},
+ {name: "index", mayBeNull: true},
+ {name: "item", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ array.splice(index, 0, item);
+}
+Array.parse = function Array$parse(value) {
+ ///
+ ///
+ ///
+ 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$remove(array, item) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "array", type: Array, elementMayBeNull: true},
+ {name: "item", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ var index = Sys._indexOf(array, item);
+ if (index >= 0) {
+ array.splice(index, 1);
+ }
+ return (index >= 0);
+}
+Array.removeAt = function Array$removeAt(array, index) {
+ ///
+ ///
+ ///
+ 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$_indexOf(array, item, start) {
+ if (typeof(item) === "undefined") return -1;
+ var length = array.length;
+ if (length !== 0) {
+ start = start - 0;
+ if (isNaN(start)) {
+ start = 0;
+ }
+ else {
+ if (isFinite(start)) {
+ start = start - (start % 1);
+ }
+ if (start < 0) {
+ start = Math.max(0, length + start);
+ }
+ }
+ for (var i = start; i < length; i++) {
+ if ((typeof(array[i]) !== "undefined") && (array[i] === item)) {
+ return i;
+ }
+ }
+ }
+ return -1;
+}
+Type._registerScript._scripts = {
+ "MicrosoftAjaxCore.js": true,
+ "MicrosoftAjaxGlobalization.js": true,
+ "MicrosoftAjaxSerialization.js": true,
+ "MicrosoftAjaxComponentModel.js": true,
+ "MicrosoftAjaxHistory.js": true,
+ "MicrosoftAjaxNetwork.js" : true,
+ "MicrosoftAjaxWebServices.js": true };
+
+Sys.IDisposable = function Sys$IDisposable() {
+ throw Error.notImplemented();
+}
+ function Sys$IDisposable$dispose() {
+ throw Error.notImplemented();
+ }
+Sys.IDisposable.prototype = {
+ dispose: Sys$IDisposable$dispose
+}
+Sys.IDisposable.registerInterface('Sys.IDisposable');
+
+Sys.StringBuilder = function Sys$StringBuilder(initialText) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "initialText", mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ this._parts = (typeof(initialText) !== 'undefined' && initialText !== null && initialText !== '') ?
+ [initialText.toString()] : [];
+ this._value = {};
+ this._len = 0;
+}
+ function Sys$StringBuilder$append(text) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "text", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ this._parts[this._parts.length] = text;
+ }
+ function Sys$StringBuilder$appendLine(text) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "text", mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ this._parts[this._parts.length] =
+ ((typeof(text) === 'undefined') || (text === null) || (text === '')) ?
+ '\r\n' : text + '\r\n';
+ }
+ function Sys$StringBuilder$clear() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ this._parts = [];
+ this._value = {};
+ this._len = 0;
+ }
+ function Sys$StringBuilder$isEmpty() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this._parts.length === 0) return true;
+ return this.toString() === '';
+ }
+ function Sys$StringBuilder$toString(separator) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "separator", type: String, mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ separator = separator || '';
+ var parts = this._parts;
+ if (this._len !== parts.length) {
+ this._value = {};
+ this._len = parts.length;
+ }
+ var val = this._value;
+ if (typeof(val[separator]) === 'undefined') {
+ if (separator !== '') {
+ for (var i = 0; i < parts.length;) {
+ if ((typeof(parts[i]) === 'undefined') || (parts[i] === '') || (parts[i] === null)) {
+ parts.splice(i, 1);
+ }
+ else {
+ i++;
+ }
+ }
+ }
+ val[separator] = this._parts.join(separator);
+ }
+ return val[separator];
+ }
+Sys.StringBuilder.prototype = {
+ append: Sys$StringBuilder$append,
+ appendLine: Sys$StringBuilder$appendLine,
+ clear: Sys$StringBuilder$clear,
+ isEmpty: Sys$StringBuilder$isEmpty,
+ toString: Sys$StringBuilder$toString
+}
+Sys.StringBuilder.registerClass('Sys.StringBuilder');
+
+Sys.Browser = {};
+Sys.Browser.InternetExplorer = {};
+Sys.Browser.Firefox = {};
+Sys.Browser.Safari = {};
+Sys.Browser.Opera = {};
+Sys.Browser.agent = null;
+Sys.Browser.hasDebuggerStatement = false;
+Sys.Browser.name = navigator.appName;
+Sys.Browser.version = parseFloat(navigator.appVersion);
+Sys.Browser.documentMode = 0;
+if (navigator.userAgent.indexOf(' MSIE ') > -1) {
+ Sys.Browser.agent = Sys.Browser.InternetExplorer;
+ Sys.Browser.version = parseFloat(navigator.userAgent.match(/MSIE (\d+\.\d+)/)[1]);
+ if (Sys.Browser.version >= 8) {
+ if (document.documentMode >= 7) {
+ Sys.Browser.documentMode = document.documentMode;
+ }
+ }
+ Sys.Browser.hasDebuggerStatement = true;
+}
+else if (navigator.userAgent.indexOf(' Firefox/') > -1) {
+ Sys.Browser.agent = Sys.Browser.Firefox;
+ Sys.Browser.version = parseFloat(navigator.userAgent.match(/ Firefox\/(\d+\.\d+)/)[1]);
+ Sys.Browser.name = 'Firefox';
+ Sys.Browser.hasDebuggerStatement = true;
+}
+else if (navigator.userAgent.indexOf(' AppleWebKit/') > -1) {
+ Sys.Browser.agent = Sys.Browser.Safari;
+ Sys.Browser.version = parseFloat(navigator.userAgent.match(/ AppleWebKit\/(\d+(\.\d+)?)/)[1]);
+ Sys.Browser.name = 'Safari';
+}
+else if (navigator.userAgent.indexOf('Opera/') > -1) {
+ Sys.Browser.agent = Sys.Browser.Opera;
+}
+
+Sys.EventArgs = function Sys$EventArgs() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+}
+Sys.EventArgs.registerClass('Sys.EventArgs');
+Sys.EventArgs.Empty = new Sys.EventArgs();
+
+Sys.CancelEventArgs = function Sys$CancelEventArgs() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ Sys.CancelEventArgs.initializeBase(this);
+ this._cancel = false;
+}
+ function Sys$CancelEventArgs$get_cancel() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._cancel;
+ }
+ function Sys$CancelEventArgs$set_cancel(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
+ if (e) throw e;
+ this._cancel = value;
+ }
+Sys.CancelEventArgs.prototype = {
+ get_cancel: Sys$CancelEventArgs$get_cancel,
+ set_cancel: Sys$CancelEventArgs$set_cancel
+}
+Sys.CancelEventArgs.registerClass('Sys.CancelEventArgs', Sys.EventArgs);
+Type.registerNamespace('Sys.UI');
+
+Sys._Debug = function Sys$_Debug() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+}
+ function Sys$_Debug$_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$_Debug$_appendTrace(text) {
+ var traceElement = document.getElementById('TraceConsole');
+ if (traceElement && (traceElement.tagName.toUpperCase() === 'TEXTAREA')) {
+ traceElement.value += text + '\n';
+ }
+ }
+ function Sys$_Debug$assert(condition, message, displayCaller) {
+ ///
+ ///
+ ///
+ ///
+ 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$_Debug$clearTrace() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ var traceElement = document.getElementById('TraceConsole');
+ if (traceElement && (traceElement.tagName.toUpperCase() === 'TEXTAREA')) {
+ traceElement.value = '';
+ }
+ }
+ function Sys$_Debug$fail(message) {
+ ///
+ ///
+ 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$_Debug$trace(text) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "text"}
+ ]);
+ if (e) throw e;
+ this._appendConsole(text);
+ this._appendTrace(text);
+ }
+ function Sys$_Debug$traceDump(object, name) {
+ ///
+ ///
+ ///
+ 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$_Debug$_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$_Debug$_appendConsole,
+ _appendTrace: Sys$_Debug$_appendTrace,
+ assert: Sys$_Debug$assert,
+ clearTrace: Sys$_Debug$clearTrace,
+ fail: Sys$_Debug$fail,
+ trace: Sys$_Debug$trace,
+ traceDump: Sys$_Debug$traceDump,
+ _traceDump: Sys$_Debug$_traceDump
+}
+Sys._Debug.registerClass('Sys._Debug');
+Sys.Debug = new Sys._Debug();
+ Sys.Debug.isDebug = true;
+
+function Sys$Enum$parse(value, ignoreCase) {
+ ///
+ ///
+ ///
+ ///
+ 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$Enum$toString(value) {
+ ///
+ ///
+ ///
+ 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$registerEnum(name, flags) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "name", type: String},
+ {name: "flags", type: Boolean, optional: true}
+ ]);
+ if (e) throw e;
+ if (!Type.__fullyQualifiedIdentifierRegExp.test(name)) throw Error.argument('name', Sys.Res.notATypeName);
+ var parsedName;
+ try {
+ parsedName = eval(name);
+ }
+ catch(e) {
+ throw Error.argument('name', Sys.Res.argumentTypeName);
+ }
+ if (parsedName !== this) throw Error.argument('name', Sys.Res.badTypeName);
+ if (Sys.__registeredTypes[name]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, name));
+ for (var j in this.prototype) {
+ var val = this.prototype[j];
+ if (!Type.__identifierRegExp.test(j)) throw Error.invalidOperation(String.format(Sys.Res.enumInvalidValueName, j));
+ if (typeof(val) !== 'number' || (val % 1) !== 0) throw Error.invalidOperation(Sys.Res.enumValueNotInteger);
+ if (typeof(this[j]) !== 'undefined') throw Error.invalidOperation(String.format(Sys.Res.enumReservedName, j));
+ }
+ Sys.__upperCaseTypes[name.toUpperCase()] = this;
+ for (var i in this.prototype) {
+ this[i] = this.prototype[i];
+ }
+ this.__typeName = name;
+ this.parse = Sys$Enum$parse;
+ this.__string = this.toString();
+ this.toString = Sys$Enum$toString;
+ this.__flags = flags;
+ this.__enum = true;
+ Sys.__registeredTypes[name] = true;
+}
+Type.isEnum = function Type$isEnum(type) {
+ ///
+ ///
+ ///
+ 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$isFlags(type) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "type", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ if ((typeof(type) === 'undefined') || (type === null)) return false;
+ return !!type.__flags;
+}
+Sys.CollectionChange = function Sys$CollectionChange(action, newItems, newStartingIndex, oldItems, oldStartingIndex) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ 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$NotifyCollectionChangedAction() {
+ ///
+ ///
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+}
+Sys.NotifyCollectionChangedAction.prototype = {
+ add: 0,
+ remove: 1,
+ reset: 2
+}
+Sys.NotifyCollectionChangedAction.registerEnum('Sys.NotifyCollectionChangedAction');
+Sys.NotifyCollectionChangedEventArgs = function Sys$NotifyCollectionChangedEventArgs(changes) {
+ ///
+ ///
+ 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$NotifyCollectionChangedEventArgs$get_changes() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._changes || [];
+ }
+Sys.NotifyCollectionChangedEventArgs.prototype = {
+ get_changes: Sys$NotifyCollectionChangedEventArgs$get_changes
+}
+Sys.NotifyCollectionChangedEventArgs.registerClass("Sys.NotifyCollectionChangedEventArgs", Sys.EventArgs);
+Sys.Observer = function Sys$Observer() {
+ throw Error.invalidOperation();
+}
+Sys.Observer.registerClass("Sys.Observer");
+Sys.Observer.makeObservable = function Sys$Observer$makeObservable(target) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"}
+ ]);
+ if (e) throw e;
+ var isArray = target instanceof Array,
+ o = Sys.Observer;
+ Sys.Observer._ensureObservable(target);
+ if (target.setValue === o._observeMethods.setValue) return target;
+ o._addMethods(target, o._observeMethods);
+ if (isArray) {
+ o._addMethods(target, o._arrayMethods);
+ }
+ return target;
+}
+Sys.Observer._ensureObservable = function Sys$Observer$_ensureObservable(target) {
+ var type = typeof target;
+ if ((type === "string") || (type === "number") || (type === "boolean") || (type === "date")) {
+ throw Error.invalidOperation(String.format(Sys.Res.notObservable, type));
+ }
+}
+Sys.Observer._addMethods = function Sys$Observer$_addMethods(target, methods) {
+ for (var m in methods) {
+ if (target[m] && (target[m] !== methods[m])) {
+ throw Error.invalidOperation(String.format(Sys.Res.observableConflict, m));
+ }
+ target[m] = methods[m];
+ }
+}
+Sys.Observer._addEventHandler = function Sys$Observer$_addEventHandler(target, eventName, handler) {
+ Sys.Observer._getContext(target, true).events._addHandler(eventName, handler);
+}
+Sys.Observer.addEventHandler = function Sys$Observer$addEventHandler(target, eventName, handler) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"},
+ {name: "eventName", type: String},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ Sys.Observer._addEventHandler(target, eventName, handler);
+}
+Sys.Observer._removeEventHandler = function Sys$Observer$_removeEventHandler(target, eventName, handler) {
+ Sys.Observer._getContext(target, true).events._removeHandler(eventName, handler);
+}
+Sys.Observer.removeEventHandler = function Sys$Observer$removeEventHandler(target, eventName, handler) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"},
+ {name: "eventName", type: String},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ Sys.Observer._removeEventHandler(target, eventName, handler);
+}
+Sys.Observer.raiseEvent = function Sys$Observer$raiseEvent(target, eventName, eventArgs) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"},
+ {name: "eventName", type: String},
+ {name: "eventArgs", type: Sys.EventArgs}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ var ctx = Sys.Observer._getContext(target);
+ if (!ctx) return;
+ var handler = ctx.events.getHandler(eventName);
+ if (handler) {
+ handler(target, eventArgs);
+ }
+}
+Sys.Observer.addPropertyChanged = function Sys$Observer$addPropertyChanged(target, handler) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ Sys.Observer._addEventHandler(target, "propertyChanged", handler);
+}
+Sys.Observer.removePropertyChanged = function Sys$Observer$removePropertyChanged(target, handler) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ Sys.Observer._removeEventHandler(target, "propertyChanged", handler);
+}
+Sys.Observer.beginUpdate = function Sys$Observer$beginUpdate(target) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ Sys.Observer._getContext(target, true).updating = true;
+}
+Sys.Observer.endUpdate = function Sys$Observer$endUpdate(target) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ var ctx = Sys.Observer._getContext(target);
+ if (!ctx || !ctx.updating) return;
+ ctx.updating = false;
+ var dirty = ctx.dirty;
+ ctx.dirty = false;
+ if (dirty) {
+ if (target instanceof Array) {
+ var changes = ctx.changes;
+ ctx.changes = null;
+ Sys.Observer.raiseCollectionChanged(target, changes);
+ }
+ Sys.Observer.raisePropertyChanged(target, "");
+ }
+}
+Sys.Observer.isUpdating = function Sys$Observer$isUpdating(target) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ var ctx = Sys.Observer._getContext(target);
+ return ctx ? ctx.updating : false;
+}
+Sys.Observer._setValue = function Sys$Observer$_setValue(target, propertyName, value) {
+ var getter, setter, mainTarget = target, path = propertyName.split('.');
+ for (var i = 0, l = (path.length - 1); i < l ; i++) {
+ var name = path[i];
+ getter = target["get_" + name];
+ if (typeof (getter) === "function") {
+ target = getter.call(target);
+ }
+ else {
+ target = target[name];
+ }
+ var type = typeof (target);
+ if ((target === null) || (type === "undefined")) {
+ throw Error.invalidOperation(String.format(Sys.Res.nullReferenceInPath, propertyName));
+ }
+ }
+ var currentValue, lastPath = path[l];
+ getter = target["get_" + lastPath];
+ setter = target["set_" + lastPath];
+ if (typeof(getter) === 'function') {
+ currentValue = getter.call(target);
+ }
+ else {
+ currentValue = target[lastPath];
+ }
+ if (typeof(setter) === 'function') {
+ setter.call(target, value);
+ }
+ else {
+ target[lastPath] = value;
+ }
+ if (currentValue !== value) {
+ var ctx = Sys.Observer._getContext(mainTarget);
+ if (ctx && ctx.updating) {
+ ctx.dirty = true;
+ return;
+ };
+ Sys.Observer.raisePropertyChanged(mainTarget, path[0]);
+ }
+}
+Sys.Observer.setValue = function Sys$Observer$setValue(target, propertyName, value) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"},
+ {name: "propertyName", type: String},
+ {name: "value", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ Sys.Observer._ensureObservable(target);
+ Sys.Observer._setValue(target, propertyName, value);
+}
+Sys.Observer.raisePropertyChanged = function Sys$Observer$raisePropertyChanged(target, propertyName) {
+ ///
+ ///
+ ///
+ Sys.Observer.raiseEvent(target, "propertyChanged", new Sys.PropertyChangedEventArgs(propertyName));
+}
+Sys.Observer.addCollectionChanged = function Sys$Observer$addCollectionChanged(target, handler) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._addEventHandler(target, "collectionChanged", handler);
+}
+Sys.Observer.removeCollectionChanged = function Sys$Observer$removeCollectionChanged(target, handler) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._removeEventHandler(target, "collectionChanged", handler);
+}
+Sys.Observer._collectionChange = function Sys$Observer$_collectionChange(target, change) {
+ var ctx = Sys.Observer._getContext(target);
+ if (ctx && ctx.updating) {
+ ctx.dirty = true;
+ var changes = ctx.changes;
+ if (!changes) {
+ ctx.changes = changes = [change];
+ }
+ else {
+ changes.push(change);
+ }
+ }
+ else {
+ Sys.Observer.raiseCollectionChanged(target, [change]);
+ Sys.Observer.raisePropertyChanged(target, 'length');
+ }
+}
+Sys.Observer.add = function Sys$Observer$add(target, item) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true},
+ {name: "item", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ var change = new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, [item], target.length);
+ Array.add(target, item);
+ Sys.Observer._collectionChange(target, change);
+}
+Sys.Observer.addRange = function Sys$Observer$addRange(target, items) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true},
+ {name: "items", type: Array, elementMayBeNull: true}
+ ]);
+ if (e) throw e;
+ var change = new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, items, target.length);
+ Array.addRange(target, items);
+ Sys.Observer._collectionChange(target, change);
+}
+Sys.Observer.clear = function Sys$Observer$clear(target) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true}
+ ]);
+ if (e) throw e;
+ var oldItems = Array.clone(target);
+ Array.clear(target);
+ Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.reset, null, -1, oldItems, 0));
+}
+Sys.Observer.insert = function Sys$Observer$insert(target, index, item) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true},
+ {name: "index", type: Number, integer: true},
+ {name: "item", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ Array.insert(target, index, item);
+ Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, [item], index));
+}
+Sys.Observer.remove = function Sys$Observer$remove(target, item) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true},
+ {name: "item", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ var index = Array.indexOf(target, item);
+ if (index !== -1) {
+ Array.remove(target, item);
+ Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.remove, null, -1, [item], index));
+ return true;
+ }
+ return false;
+}
+Sys.Observer.removeAt = function Sys$Observer$removeAt(target, index) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target", type: Array, elementMayBeNull: true},
+ {name: "index", type: Number, integer: true}
+ ]);
+ if (e) throw e;
+ if ((index > -1) && (index < target.length)) {
+ var item = target[index];
+ Array.removeAt(target, index);
+ Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.remove, null, -1, [item], index));
+ }
+}
+Sys.Observer.raiseCollectionChanged = function Sys$Observer$raiseCollectionChanged(target, changes) {
+ ///
+ ///
+ ///
+ Sys.Observer.raiseEvent(target, "collectionChanged", new Sys.NotifyCollectionChangedEventArgs(changes));
+}
+Sys.Observer._observeMethods = {
+ add_propertyChanged: function(handler) {
+ Sys.Observer._addEventHandler(this, "propertyChanged", handler);
+ },
+ remove_propertyChanged: function(handler) {
+ Sys.Observer._removeEventHandler(this, "propertyChanged", handler);
+ },
+ addEventHandler: function(eventName, handler) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "eventName", type: String},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._addEventHandler(this, eventName, handler);
+ },
+ removeEventHandler: function(eventName, handler) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "eventName", type: String},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.Observer._removeEventHandler(this, eventName, handler);
+ },
+ get_isUpdating: function() {
+ ///
+ ///
+ return Sys.Observer.isUpdating(this);
+ },
+ beginUpdate: function() {
+ ///
+ Sys.Observer.beginUpdate(this);
+ },
+ endUpdate: function() {
+ ///
+ Sys.Observer.endUpdate(this);
+ },
+ setValue: function(name, value) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "name", type: String},
+ {name: "value", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ Sys.Observer._setValue(this, name, value);
+ },
+ raiseEvent: function(eventName, eventArgs) {
+ ///
+ ///
+ ///
+ Sys.Observer.raiseEvent(this, eventName, eventArgs);
+ },
+ raisePropertyChanged: function(name) {
+ ///
+ ///
+ Sys.Observer.raiseEvent(this, "propertyChanged", new Sys.PropertyChangedEventArgs(name));
+ }
+}
+Sys.Observer._arrayMethods = {
+ add_collectionChanged: function(handler) {
+ Sys.Observer._addEventHandler(this, "collectionChanged", handler);
+ },
+ remove_collectionChanged: function(handler) {
+ Sys.Observer._removeEventHandler(this, "collectionChanged", handler);
+ },
+ add: function(item) {
+ ///
+ ///
+ Sys.Observer.add(this, item);
+ },
+ addRange: function(items) {
+ ///
+ ///
+ Sys.Observer.addRange(this, items);
+ },
+ clear: function() {
+ ///
+ Sys.Observer.clear(this);
+ },
+ insert: function(index, item) {
+ ///
+ ///
+ ///
+ Sys.Observer.insert(this, index, item);
+ },
+ remove: function(item) {
+ ///
+ ///
+ ///
+ return Sys.Observer.remove(this, item);
+ },
+ removeAt: function(index) {
+ ///
+ ///
+ Sys.Observer.removeAt(this, index);
+ },
+ raiseCollectionChanged: function(changes) {
+ ///
+ ///
+ Sys.Observer.raiseEvent(this, "collectionChanged", new Sys.NotifyCollectionChangedEventArgs(changes));
+ }
+}
+Sys.Observer._getContext = function Sys$Observer$_getContext(obj, create) {
+ var ctx = obj._observerContext;
+ if (ctx) return ctx();
+ if (create) {
+ return (obj._observerContext = Sys.Observer._createContext())();
+ }
+ return null;
+}
+Sys.Observer._createContext = function Sys$Observer$_createContext() {
+ var ctx = {
+ events: new Sys.EventHandlerList()
+ };
+ return function() {
+ return ctx;
+ }
+}
+Date._appendPreOrPostMatch = function Date$_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$_expandFormat(dtf, format) {
+ if (!format) {
+ format = "F";
+ }
+ var len = format.length;
+ if (len === 1) {
+ switch (format) {
+ case "d":
+ return dtf.ShortDatePattern;
+ case "D":
+ return dtf.LongDatePattern;
+ case "t":
+ return dtf.ShortTimePattern;
+ case "T":
+ return dtf.LongTimePattern;
+ case "f":
+ return dtf.LongDatePattern + " " + dtf.ShortTimePattern;
+ case "F":
+ return dtf.FullDateTimePattern;
+ case "M": case "m":
+ return dtf.MonthDayPattern;
+ case "s":
+ return dtf.SortableDateTimePattern;
+ case "Y": case "y":
+ return dtf.YearMonthPattern;
+ default:
+ throw Error.format(Sys.Res.formatInvalidString);
+ }
+ }
+ else if ((len === 2) && (format.charAt(0) === "%")) {
+ format = format.charAt(1);
+ }
+ return format;
+}
+Date._expandYear = 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$_getEra(date, eras) {
+ if (!eras) return 0;
+ var start, ticks = date.getTime();
+ for (var i = 0, l = eras.length; i < l; i += 4) {
+ start = eras[i+2];
+ if ((start === null) || (ticks >= start)) {
+ return i;
+ }
+ }
+ return 0;
+}
+Date._getEraYear = 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$_getParseRegExp(dtf, format) {
+ if (!dtf._parseRegExp) {
+ dtf._parseRegExp = {};
+ }
+ else if (dtf._parseRegExp[format]) {
+ return dtf._parseRegExp[format];
+ }
+ var expFormat = Date._expandFormat(dtf, format);
+ expFormat = expFormat.replace(/([\^\$\.\*\+\?\|\[\]\(\)\{\}])/g, "\\\\$1");
+ var regexp = new Sys.StringBuilder("^");
+ var groups = [];
+ var index = 0;
+ var quoteCount = 0;
+ var tokenRegExp = Date._getTokenRegExp();
+ var match;
+ while ((match = tokenRegExp.exec(expFormat)) !== null) {
+ var preMatch = expFormat.slice(index, match.index);
+ index = tokenRegExp.lastIndex;
+ quoteCount += Date._appendPreOrPostMatch(preMatch, regexp);
+ if ((quoteCount%2) === 1) {
+ regexp.append(match[0]);
+ continue;
+ }
+ switch (match[0]) {
+ case 'dddd': case 'ddd':
+ case 'MMMM': case 'MMM':
+ case 'gg': case 'g':
+ regexp.append("(\\D+)");
+ break;
+ case 'tt': case 't':
+ regexp.append("(\\D*)");
+ break;
+ case 'yyyy':
+ regexp.append("(\\d{4})");
+ break;
+ case 'fff':
+ regexp.append("(\\d{3})");
+ break;
+ case 'ff':
+ regexp.append("(\\d{2})");
+ break;
+ case 'f':
+ regexp.append("(\\d)");
+ break;
+ case 'dd': case 'd':
+ case 'MM': case 'M':
+ case 'yy': case 'y':
+ case 'HH': case 'H':
+ case 'hh': case 'h':
+ case 'mm': case 'm':
+ case 'ss': case 's':
+ regexp.append("(\\d\\d?)");
+ break;
+ case 'zzz':
+ regexp.append("([+-]?\\d\\d?:\\d{2})");
+ break;
+ case 'zz': case 'z':
+ regexp.append("([+-]?\\d\\d?)");
+ break;
+ case '/':
+ regexp.append("(\\" + dtf.DateSeparator + ")");
+ break;
+ }
+ Array.add(groups, match[0]);
+ }
+ Date._appendPreOrPostMatch(expFormat.slice(index), regexp);
+ regexp.append("$");
+ var regexpStr = regexp.toString().replace(/\s+/g, "\\s+");
+ var parseRegExp = {'regExp': regexpStr, 'groups': groups};
+ dtf._parseRegExp[format] = parseRegExp;
+ return parseRegExp;
+}
+Date._getTokenRegExp = function Date$_getTokenRegExp() {
+ return /\/|dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z|gg|g/g;
+}
+Date.parseLocale = function Date$parseLocale(value, formats) {
+ ///
+ ///
+ ///
+ ///
+ 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$parseInvariant(value, formats) {
+ ///
+ ///
+ ///
+ ///
+ 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.InvariantCulture, arguments);
+}
+Date._parse = 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$_parseExact(value, format, cultureInfo) {
+ value = value.trim();
+ var dtf = cultureInfo.dateTimeFormat,
+ parseInfo = Date._getParseRegExp(dtf, format),
+ match = new RegExp(parseInfo.regExp).exec(value);
+ if (match === null) return null;
+
+ var groups = parseInfo.groups,
+ era = null, year = null, month = null, date = null, weekDay = null,
+ hour = 0, hourOffset, min = 0, sec = 0, msec = 0, tzMinOffset = null,
+ pmHour = false;
+ for (var j = 0, jl = groups.length; j < jl; j++) {
+ var matchGroup = match[j+1];
+ if (matchGroup) {
+ switch (groups[j]) {
+ case 'dd': case 'd':
+ date = parseInt(matchGroup, 10);
+ if ((date < 1) || (date > 31)) return null;
+ break;
+ case 'MMMM':
+ month = cultureInfo._getMonthIndex(matchGroup);
+ if ((month < 0) || (month > 11)) return null;
+ break;
+ case 'MMM':
+ month = cultureInfo._getAbbrMonthIndex(matchGroup);
+ if ((month < 0) || (month > 11)) return null;
+ break;
+ case 'M': case 'MM':
+ month = parseInt(matchGroup, 10) - 1;
+ if ((month < 0) || (month > 11)) return null;
+ break;
+ case 'y': case 'yy':
+ year = Date._expandYear(dtf,parseInt(matchGroup, 10));
+ if ((year < 0) || (year > 9999)) return null;
+ break;
+ case 'yyyy':
+ year = parseInt(matchGroup, 10);
+ if ((year < 0) || (year > 9999)) return null;
+ break;
+ case 'h': case 'hh':
+ hour = parseInt(matchGroup, 10);
+ if (hour === 12) hour = 0;
+ if ((hour < 0) || (hour > 11)) return null;
+ break;
+ case 'H': case 'HH':
+ hour = parseInt(matchGroup, 10);
+ if ((hour < 0) || (hour > 23)) return null;
+ break;
+ case 'm': case 'mm':
+ min = parseInt(matchGroup, 10);
+ if ((min < 0) || (min > 59)) return null;
+ break;
+ case 's': case 'ss':
+ sec = parseInt(matchGroup, 10);
+ if ((sec < 0) || (sec > 59)) return null;
+ break;
+ case 'tt': case 't':
+ var upperToken = matchGroup.toUpperCase();
+ pmHour = (upperToken === dtf.PMDesignator.toUpperCase());
+ if (!pmHour && (upperToken !== dtf.AMDesignator.toUpperCase())) return null;
+ break;
+ case 'f':
+ msec = parseInt(matchGroup, 10) * 100;
+ if ((msec < 0) || (msec > 999)) return null;
+ break;
+ case 'ff':
+ msec = parseInt(matchGroup, 10) * 10;
+ if ((msec < 0) || (msec > 999)) return null;
+ break;
+ case 'fff':
+ msec = parseInt(matchGroup, 10);
+ if ((msec < 0) || (msec > 999)) return null;
+ break;
+ case 'dddd':
+ weekDay = cultureInfo._getDayIndex(matchGroup);
+ if ((weekDay < 0) || (weekDay > 6)) return null;
+ break;
+ case 'ddd':
+ weekDay = cultureInfo._getAbbrDayIndex(matchGroup);
+ if ((weekDay < 0) || (weekDay > 6)) return null;
+ break;
+ case 'zzz':
+ var offsets = matchGroup.split(/:/);
+ if (offsets.length !== 2) return null;
+ hourOffset = parseInt(offsets[0], 10);
+ if ((hourOffset < -12) || (hourOffset > 13)) return null;
+ var minOffset = parseInt(offsets[1], 10);
+ if ((minOffset < 0) || (minOffset > 59)) return null;
+ tzMinOffset = (hourOffset * 60) + (matchGroup.startsWith('-')? -minOffset : minOffset);
+ break;
+ case 'z': case 'zz':
+ hourOffset = parseInt(matchGroup, 10);
+ if ((hourOffset < -12) || (hourOffset > 13)) return null;
+ tzMinOffset = hourOffset * 60;
+ break;
+ case 'g': case 'gg':
+ var eraName = matchGroup;
+ if (!eraName || !dtf.eras) return null;
+ eraName = eraName.toLowerCase().trim();
+ for (var i = 0, l = dtf.eras.length; i < l; i += 4) {
+ if (eraName === dtf.eras[i + 1].toLowerCase()) {
+ era = i;
+ break;
+ }
+ }
+ if (era === null) return null;
+ break;
+ }
+ }
+ }
+ var result = new Date(), defaultYear, convert = dtf.Calendar.convert;
+ if (convert) {
+ defaultYear = convert.fromGregorian(result)[0];
+ }
+ else {
+ defaultYear = result.getFullYear();
+ }
+ if (year === null) {
+ year = defaultYear;
+ }
+ else if (dtf.eras) {
+ year += dtf.eras[(era || 0) + 3];
+ }
+ if (month === null) {
+ month = 0;
+ }
+ if (date === null) {
+ date = 1;
+ }
+ if (convert) {
+ result = convert.toGregorian(year, month, date);
+ if (result === null) return null;
+ }
+ else {
+ result.setFullYear(year, month, date);
+ if (result.getDate() !== date) return null;
+ if ((weekDay !== null) && (result.getDay() !== weekDay)) {
+ return null;
+ }
+ }
+ if (pmHour && (hour < 12)) {
+ hour += 12;
+ }
+ result.setHours(hour, min, sec, msec);
+ if (tzMinOffset !== null) {
+ var adjustedMin = result.getMinutes() - (tzMinOffset + result.getTimezoneOffset());
+ result.setHours(result.getHours() + parseInt(adjustedMin/60, 10), adjustedMin%60);
+ }
+ return result;
+}
+Date.prototype.format = function Date$format(format) {
+ ///
+ ///
+ ///
+ 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$localeFormat(format) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "format", type: String}
+ ]);
+ if (e) throw e;
+ return this._toFormattedString(format, Sys.CultureInfo.CurrentCulture);
+}
+Date.prototype._toFormattedString = 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]|$)/g;
+ function hasDay() {
+ if (foundDay || checkedDay) {
+ return foundDay;
+ }
+ foundDay = dayPartRegExp.test(format);
+ checkedDay = true;
+ return foundDay;
+ }
+
+ var quoteCount = 0,
+ tokenRegExp = Date._getTokenRegExp(),
+ converted;
+ if (!sortable && convert) {
+ converted = convert.fromGregorian(this);
+ }
+ for (;;) {
+ var index = tokenRegExp.lastIndex;
+ var ar = tokenRegExp.exec(format);
+ var preMatch = format.slice(index, ar ? ar.index : format.length);
+ quoteCount += Date._appendPreOrPostMatch(preMatch, ret);
+ if (!ar) break;
+ if ((quoteCount%2) === 1) {
+ ret.append(ar[0]);
+ continue;
+ }
+
+ function getPart(date, part) {
+ if (converted) {
+ return converted[part];
+ }
+ switch (part) {
+ case 0: return date.getFullYear();
+ case 1: return date.getMonth();
+ case 2: return date.getDate();
+ }
+ }
+ switch (ar[0]) {
+ case "dddd":
+ ret.append(dtf.DayNames[this.getDay()]);
+ break;
+ case "ddd":
+ ret.append(dtf.AbbreviatedDayNames[this.getDay()]);
+ break;
+ case "dd":
+ foundDay = true;
+ ret.append(addLeadingZero(getPart(this, 2)));
+ break;
+ case "d":
+ foundDay = true;
+ ret.append(getPart(this, 2));
+ break;
+ case "MMMM":
+ ret.append((dtf.MonthGenitiveNames && hasDay())
+ ? dtf.MonthGenitiveNames[getPart(this, 1)]
+ : dtf.MonthNames[getPart(this, 1)]);
+ break;
+ case "MMM":
+ ret.append((dtf.AbbreviatedMonthGenitiveNames && hasDay())
+ ? dtf.AbbreviatedMonthGenitiveNames[getPart(this, 1)]
+ : dtf.AbbreviatedMonthNames[getPart(this, 1)]);
+ break;
+ case "MM":
+ ret.append(addLeadingZero(getPart(this, 1) + 1));
+ break;
+ case "M":
+ ret.append(getPart(this, 1) + 1);
+ break;
+ case "yyyy":
+ ret.append(padYear(converted ? converted[0] : Date._getEraYear(this, dtf, Date._getEra(this, eras), sortable)));
+ break;
+ case "yy":
+ ret.append(addLeadingZero((converted ? converted[0] : Date._getEraYear(this, dtf, Date._getEra(this, eras), sortable)) % 100));
+ break;
+ case "y":
+ ret.append((converted ? converted[0] : Date._getEraYear(this, dtf, Date._getEra(this, eras), sortable)) % 100);
+ break;
+ case "hh":
+ hour = this.getHours() % 12;
+ if (hour === 0) hour = 12;
+ ret.append(addLeadingZero(hour));
+ break;
+ case "h":
+ hour = this.getHours() % 12;
+ if (hour === 0) hour = 12;
+ ret.append(hour);
+ break;
+ case "HH":
+ ret.append(addLeadingZero(this.getHours()));
+ break;
+ case "H":
+ ret.append(this.getHours());
+ break;
+ case "mm":
+ ret.append(addLeadingZero(this.getMinutes()));
+ break;
+ case "m":
+ ret.append(this.getMinutes());
+ break;
+ case "ss":
+ ret.append(addLeadingZero(this.getSeconds()));
+ break;
+ case "s":
+ ret.append(this.getSeconds());
+ break;
+ case "tt":
+ ret.append((this.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator);
+ break;
+ case "t":
+ ret.append(((this.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator).charAt(0));
+ break;
+ case "f":
+ ret.append(addLeadingZeros(this.getMilliseconds()).charAt(0));
+ break;
+ case "ff":
+ ret.append(addLeadingZeros(this.getMilliseconds()).substr(0, 2));
+ break;
+ case "fff":
+ ret.append(addLeadingZeros(this.getMilliseconds()));
+ break;
+ case "z":
+ hour = this.getTimezoneOffset() / 60;
+ ret.append(((hour <= 0) ? '+' : '-') + Math.floor(Math.abs(hour)));
+ break;
+ case "zz":
+ hour = this.getTimezoneOffset() / 60;
+ ret.append(((hour <= 0) ? '+' : '-') + addLeadingZero(Math.floor(Math.abs(hour))));
+ break;
+ case "zzz":
+ hour = this.getTimezoneOffset() / 60;
+ ret.append(((hour <= 0) ? '+' : '-') + addLeadingZero(Math.floor(Math.abs(hour))) +
+ ":" + addLeadingZero(Math.abs(this.getTimezoneOffset() % 60)));
+ break;
+ case "g":
+ case "gg":
+ if (dtf.eras) {
+ ret.append(dtf.eras[Date._getEra(this, eras) + 1]);
+ }
+ break;
+ case "/":
+ ret.append(dtf.DateSeparator);
+ break;
+ }
+ }
+ return ret.toString();
+}
+String.localeFormat = function String$localeFormat(format, args) {
+ ///
+ ///
+ ///
+ ///
+ 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$parseLocale(value) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "value", type: String}
+ ], false);
+ if (e) throw e;
+ return Number._parse(value, Sys.CultureInfo.CurrentCulture);
+}
+Number.parseInvariant = function Number$parseInvariant(value) {
+ ///
+ ///
+ ///
+ 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$_parse(value, cultureInfo) {
+ value = value.trim();
+
+ if (value.match(/^[+-]?infinity$/i)) {
+ return parseFloat(value);
+ }
+ if (value.match(/^0x[a-f0-9]+$/i)) {
+ return parseInt(value);
+ }
+ var numFormat = cultureInfo.numberFormat;
+ var signInfo = Number._parseNumberNegativePattern(value, numFormat, numFormat.NumberNegativePattern);
+ var sign = signInfo[0];
+ var num = signInfo[1];
+
+ if ((sign === '') && (numFormat.NumberNegativePattern !== 1)) {
+ signInfo = Number._parseNumberNegativePattern(value, numFormat, 1);
+ sign = signInfo[0];
+ num = signInfo[1];
+ }
+ if (sign === '') sign = '+';
+
+ var exponent;
+ var intAndFraction;
+ var exponentPos = num.indexOf('e');
+ if (exponentPos < 0) exponentPos = num.indexOf('E');
+ if (exponentPos < 0) {
+ intAndFraction = num;
+ exponent = null;
+ }
+ else {
+ intAndFraction = num.substr(0, exponentPos);
+ exponent = num.substr(exponentPos + 1);
+ }
+
+ var integer;
+ var fraction;
+ var decimalPos = intAndFraction.indexOf(numFormat.NumberDecimalSeparator);
+ if (decimalPos < 0) {
+ integer = intAndFraction;
+ fraction = null;
+ }
+ else {
+ integer = intAndFraction.substr(0, decimalPos);
+ fraction = intAndFraction.substr(decimalPos + numFormat.NumberDecimalSeparator.length);
+ }
+
+ integer = integer.split(numFormat.NumberGroupSeparator).join('');
+ var altNumGroupSeparator = numFormat.NumberGroupSeparator.replace(/\u00A0/g, " ");
+ if (numFormat.NumberGroupSeparator !== altNumGroupSeparator) {
+ integer = integer.split(altNumGroupSeparator).join('');
+ }
+
+ var p = sign + integer;
+ if (fraction !== null) {
+ p += '.' + fraction;
+ }
+ if (exponent !== null) {
+ var expSignInfo = Number._parseNumberNegativePattern(exponent, numFormat, 1);
+ if (expSignInfo[0] === '') {
+ expSignInfo[0] = '+';
+ }
+ p += 'e' + expSignInfo[0] + expSignInfo[1];
+ }
+ if (p.match(/^[+-]?\d*\.?\d*(e[+-]?\d+)?$/)) {
+ return parseFloat(p);
+ }
+ return Number.NaN;
+}
+Number._parseNumberNegativePattern = function Number$_parseNumberNegativePattern(value, numFormat, numberNegativePattern) {
+ var neg = numFormat.NegativeSign;
+ var pos = numFormat.PositiveSign;
+ switch (numberNegativePattern) {
+ case 4:
+ neg = ' ' + neg;
+ pos = ' ' + pos;
+ case 3:
+ if (value.endsWith(neg)) {
+ return ['-', value.substr(0, value.length - neg.length)];
+ }
+ else if (value.endsWith(pos)) {
+ return ['+', value.substr(0, value.length - pos.length)];
+ }
+ break;
+ case 2:
+ neg += ' ';
+ pos += ' ';
+ case 1:
+ if (value.startsWith(neg)) {
+ return ['-', value.substr(neg.length)];
+ }
+ else if (value.startsWith(pos)) {
+ return ['+', value.substr(pos.length)];
+ }
+ break;
+ case 0:
+ if (value.startsWith('(') && value.endsWith(')')) {
+ return ['-', value.substr(1, value.length - 2)];
+ }
+ break;
+ }
+ return ['', value];
+}
+Number.prototype.format = function Number$format(format) {
+ ///
+ ///
+ ///
+ 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$localeFormat(format) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "format", type: String}
+ ]);
+ if (e) throw e;
+ return this._toFormattedString(format, Sys.CultureInfo.CurrentCulture);
+}
+Number.prototype._toFormattedString = 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 = ["$n","n$","$ n","n $"];
+ var _currencyNegativePattern = ["($n)","-$n","$-n","$n-","(n$)","-n$","n-$","n$-","-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) {
+
+ 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 "$":
+ ret += nf.CurrencySymbol;
+ break;
+ case "-":
+ if (/[1-9]/.test(number)) {
+ ret += nf.NegativeSign;
+ }
+ break;
+ case "%":
+ ret += nf.PercentSymbol;
+ break;
+ }
+ }
+ return ret;
+}
+
+Sys.CultureInfo = function Sys$CultureInfo(name, numberFormat, dateTimeFormat) {
+ ///
+ ///
+ ///
+ ///
+ 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":"$","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":false},"DateSeparator":"/","FirstDayOfWeek":0,"CalendarWeekRule":0,"FullDateTimePattern":"dddd, MMMM dd, yyyy h:mm:ss tt","LongDatePattern":"dddd, MMMM dd, yyyy","LongTimePattern":"h:mm:ss tt","MonthDayPattern":"MMMM dd","PMDesignator":"PM","RFC1123Pattern":"ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'","ShortDatePattern":"M/d/yyyy","ShortTimePattern":"h:mm tt","SortableDateTimePattern":"yyyy\'-\'MM\'-\'dd\'T\'HH\':\'mm\':\'ss","TimeSeparator":":","UniversalSortableDateTimePattern":"yyyy\'-\'MM\'-\'dd HH\':\'mm\':\'ss\'Z\'","YearMonthPattern":"MMMM, yyyy","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":false,"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]});
+}
+Type.registerNamespace('Sys.Serialization');
+Sys.Serialization.JavaScriptSerializer = function Sys$Serialization$JavaScriptSerializer() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+}
+Sys.Serialization.JavaScriptSerializer.registerClass('Sys.Serialization.JavaScriptSerializer');
+Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs = [];
+Sys.Serialization.JavaScriptSerializer._charsToEscape = [];
+Sys.Serialization.JavaScriptSerializer._dateRegEx = new RegExp('(^|[^\\\\])\\"\\\\/Date\\((-?[0-9]+)(?:[a-zA-Z]|(?:\\+|-)[0-9]{4})?\\)\\\\/\\"', 'g');
+Sys.Serialization.JavaScriptSerializer._escapeChars = {};
+Sys.Serialization.JavaScriptSerializer._escapeRegEx = new RegExp('["\\\\\\x00-\\x1F]', 'i');
+Sys.Serialization.JavaScriptSerializer._escapeRegExGlobal = new RegExp('["\\\\\\x00-\\x1F]', 'g');
+Sys.Serialization.JavaScriptSerializer._jsonRegEx = new RegExp('[^,:{}\\[\\]0-9.\\-+Eaeflnr-u \\n\\r\\t]', 'g');
+Sys.Serialization.JavaScriptSerializer._jsonStringRegEx = new RegExp('"(\\\\.|[^"\\\\])*"', 'g');
+Sys.Serialization.JavaScriptSerializer._serverTypeFieldName = '__type';
+Sys.Serialization.JavaScriptSerializer._init = function Sys$Serialization$JavaScriptSerializer$_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$Serialization$JavaScriptSerializer$_serializeBooleanWithBuilder(object, stringBuilder) {
+ stringBuilder.append(object.toString());
+}
+Sys.Serialization.JavaScriptSerializer._serializeNumberWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeNumberWithBuilder(object, stringBuilder) {
+ if (isFinite(object)) {
+ stringBuilder.append(String(object));
+ }
+ else {
+ throw Error.invalidOperation(Sys.Res.cannotSerializeNonFiniteNumbers);
+ }
+}
+Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeStringWithBuilder(string, stringBuilder) {
+ stringBuilder.append('"');
+ if (Sys.Serialization.JavaScriptSerializer._escapeRegEx.test(string)) {
+ if (Sys.Serialization.JavaScriptSerializer._charsToEscape.length === 0) {
+ Sys.Serialization.JavaScriptSerializer._init();
+ }
+ if (string.length < 128) {
+ string = string.replace(Sys.Serialization.JavaScriptSerializer._escapeRegExGlobal,
+ function(x) { return Sys.Serialization.JavaScriptSerializer._escapeChars[x]; });
+ }
+ else {
+ for (var i = 0; i < 34; i++) {
+ var c = Sys.Serialization.JavaScriptSerializer._charsToEscape[i];
+ if (string.indexOf(c) !== -1) {
+ if (Sys.Browser.agent === Sys.Browser.Opera || Sys.Browser.agent === Sys.Browser.FireFox) {
+ string = string.split(c).join(Sys.Serialization.JavaScriptSerializer._escapeChars[c]);
+ }
+ else {
+ string = string.replace(Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[c],
+ Sys.Serialization.JavaScriptSerializer._escapeChars[c]);
+ }
+ }
+ }
+ }
+ }
+ stringBuilder.append(string);
+ stringBuilder.append('"');
+}
+Sys.Serialization.JavaScriptSerializer._serializeWithBuilder = function Sys$Serialization$JavaScriptSerializer$_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('$')) {
+ continue;
+ }
+ if (name === Sys.Serialization.JavaScriptSerializer._serverTypeFieldName && propertyCount !== 0){
+ properties[propertyCount++] = properties[0];
+ properties[0] = name;
+ }
+ else{
+ properties[propertyCount++] = name;
+ }
+ }
+ if (sort) properties.sort();
+ stringBuilder.append('{');
+ var needComma = false;
+
+ for (i=0; i
+ ///
+ ///
+ 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$Serialization$JavaScriptSerializer$deserialize(data, secure) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "data", type: String},
+ {name: "secure", type: Boolean, optional: true}
+ ]);
+ if (e) throw e;
+
+ if (data.length === 0) throw Error.argument('data', Sys.Res.cannotDeserializeEmptyString);
+ try {
+ var exp = data.replace(Sys.Serialization.JavaScriptSerializer._dateRegEx, "$1new Date($2)");
+
+ if (secure && Sys.Serialization.JavaScriptSerializer._jsonRegEx.test(
+ exp.replace(Sys.Serialization.JavaScriptSerializer._jsonStringRegEx, ''))) throw null;
+ return eval('(' + exp + ')');
+ }
+ catch (e) {
+ throw Error.argument('data', Sys.Res.cannotDeserializeInvalidJson);
+ }
+}
+Type.registerNamespace('Sys.UI');
+
+Sys.EventHandlerList = function Sys$EventHandlerList() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ this._list = {};
+}
+ function Sys$EventHandlerList$_addHandler(id, handler) {
+ Array.add(this._getEvent(id, true), handler);
+ }
+ function Sys$EventHandlerList$addHandler(id, handler) {
+ ///
+ ///
+ ///
+ 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._getEvent(id);
+ if (!evt) return;
+ Array.remove(evt, handler);
+ }
+ function Sys$EventHandlerList$removeHandler(id, handler) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "id", type: String},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ this._removeHandler(id, handler);
+ }
+ function Sys$EventHandlerList$getHandler(id) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "id", type: String}
+ ]);
+ if (e) throw e;
+ var evt = this._getEvent(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$_getEvent(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$EventHandlerList$addHandler,
+ _removeHandler: Sys$EventHandlerList$_removeHandler,
+ removeHandler: Sys$EventHandlerList$removeHandler,
+ getHandler: Sys$EventHandlerList$getHandler,
+ _getEvent: Sys$EventHandlerList$_getEvent
+}
+Sys.EventHandlerList.registerClass('Sys.EventHandlerList');
+Sys.CommandEventArgs = function Sys$CommandEventArgs(commandName, commandArgument, commandSource) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "commandName", type: String},
+ {name: "commandArgument", mayBeNull: true},
+ {name: "commandSource", mayBeNull: true}
+ ]);
+ if (e) throw e;
+ Sys.CommandEventArgs.initializeBase(this);
+ this._commandName = commandName;
+ this._commandArgument = commandArgument;
+ this._commandSource = commandSource;
+}
+ function Sys$CommandEventArgs$get_commandName() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._commandName;
+ }
+ function Sys$CommandEventArgs$get_commandArgument() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._commandArgument;
+ }
+ function Sys$CommandEventArgs$get_commandSource() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._commandSource;
+ }
+Sys.CommandEventArgs.prototype = {
+ _commandName: null,
+ _commandArgument: null,
+ _commandSource: null,
+ get_commandName: Sys$CommandEventArgs$get_commandName,
+ get_commandArgument: Sys$CommandEventArgs$get_commandArgument,
+ get_commandSource: Sys$CommandEventArgs$get_commandSource
+}
+Sys.CommandEventArgs.registerClass("Sys.CommandEventArgs", Sys.CancelEventArgs);
+
+Sys.INotifyPropertyChange = function Sys$INotifyPropertyChange() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+}
+ function Sys$INotifyPropertyChange$add_propertyChanged(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+ function Sys$INotifyPropertyChange$remove_propertyChanged(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+Sys.INotifyPropertyChange.prototype = {
+ add_propertyChanged: Sys$INotifyPropertyChange$add_propertyChanged,
+ remove_propertyChanged: Sys$INotifyPropertyChange$remove_propertyChanged
+}
+Sys.INotifyPropertyChange.registerInterface('Sys.INotifyPropertyChange');
+
+Sys.PropertyChangedEventArgs = function Sys$PropertyChangedEventArgs(propertyName) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "propertyName", type: String}
+ ]);
+ if (e) throw e;
+ Sys.PropertyChangedEventArgs.initializeBase(this);
+ this._propertyName = propertyName;
+}
+
+ function Sys$PropertyChangedEventArgs$get_propertyName() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._propertyName;
+ }
+Sys.PropertyChangedEventArgs.prototype = {
+ get_propertyName: Sys$PropertyChangedEventArgs$get_propertyName
+}
+Sys.PropertyChangedEventArgs.registerClass('Sys.PropertyChangedEventArgs', Sys.EventArgs);
+
+Sys.INotifyDisposing = function Sys$INotifyDisposing() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+}
+ function Sys$INotifyDisposing$add_disposing(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+ function Sys$INotifyDisposing$remove_disposing(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+Sys.INotifyDisposing.prototype = {
+ add_disposing: Sys$INotifyDisposing$add_disposing,
+ remove_disposing: Sys$INotifyDisposing$remove_disposing
+}
+Sys.INotifyDisposing.registerInterface("Sys.INotifyDisposing");
+
+Sys.Component = function Sys$Component() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (Sys.Application) Sys.Application.registerDisposableObject(this);
+}
+ function Sys$Component$get_events() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (!this._events) {
+ this._events = new Sys.EventHandlerList();
+ }
+ return this._events;
+ }
+ function Sys$Component$get_id() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._id;
+ }
+ function Sys$Component$set_id(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: String}]);
+ if (e) throw e;
+ if (this._idSet) throw Error.invalidOperation(Sys.Res.componentCantSetIdTwice);
+ this._idSet = true;
+ var oldId = this.get_id();
+ if (oldId && Sys.Application.findComponent(oldId)) throw Error.invalidOperation(Sys.Res.componentCantSetIdAfterAddedToApp);
+ this._id = value;
+ }
+ function Sys$Component$get_isInitialized() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._initialized;
+ }
+ function Sys$Component$get_isUpdating() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._updating;
+ }
+ function Sys$Component$add_disposing(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().addHandler("disposing", handler);
+ }
+ function Sys$Component$remove_disposing(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().removeHandler("disposing", handler);
+ }
+ function Sys$Component$add_propertyChanged(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().addHandler("propertyChanged", handler);
+ }
+ function Sys$Component$remove_propertyChanged(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().removeHandler("propertyChanged", handler);
+ }
+ function Sys$Component$beginUpdate() {
+ this._updating = true;
+ }
+ function Sys$Component$dispose() {
+ if (this._events) {
+ var handler = this._events.getHandler("disposing");
+ if (handler) {
+ handler(this, Sys.EventArgs.Empty);
+ }
+ }
+ delete this._events;
+ Sys.Application.unregisterDisposableObject(this);
+ Sys.Application.removeComponent(this);
+ }
+ function Sys$Component$endUpdate() {
+ this._updating = false;
+ if (!this._initialized) this.initialize();
+ this.updated();
+ }
+ function Sys$Component$initialize() {
+ this._initialized = true;
+ }
+ function Sys$Component$raisePropertyChanged(propertyName) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "propertyName", type: String}
+ ]);
+ if (e) throw e;
+ if (!this._events) return;
+ var handler = this._events.getHandler("propertyChanged");
+ if (handler) {
+ handler(this, new Sys.PropertyChangedEventArgs(propertyName));
+ }
+ }
+ function Sys$Component$updated() {
+ }
+Sys.Component.prototype = {
+ _id: null,
+ _idSet: false,
+ _initialized: false,
+ _updating: false,
+ get_events: Sys$Component$get_events,
+ get_id: Sys$Component$get_id,
+ set_id: Sys$Component$set_id,
+ get_isInitialized: Sys$Component$get_isInitialized,
+ get_isUpdating: Sys$Component$get_isUpdating,
+ add_disposing: Sys$Component$add_disposing,
+ remove_disposing: Sys$Component$remove_disposing,
+ add_propertyChanged: Sys$Component$add_propertyChanged,
+ remove_propertyChanged: Sys$Component$remove_propertyChanged,
+ beginUpdate: Sys$Component$beginUpdate,
+ dispose: Sys$Component$dispose,
+ endUpdate: Sys$Component$endUpdate,
+ initialize: Sys$Component$initialize,
+ raisePropertyChanged: Sys$Component$raisePropertyChanged,
+ updated: Sys$Component$updated
+}
+Sys.Component.registerClass('Sys.Component', null, Sys.IDisposable, Sys.INotifyPropertyChange, Sys.INotifyDisposing);
+function Sys$Component$_setProperties(target, properties) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "target"},
+ {name: "properties"}
+ ]);
+ if (e) throw e;
+ var current;
+ var targetType = Object.getType(target);
+ var isObject = (targetType === Object) || (targetType === Sys.UI.DomElement);
+ var isComponent = Sys.Component.isInstanceOfType(target) && !target.get_isUpdating();
+ if (isComponent) target.beginUpdate();
+ for (var name in properties) {
+ var val = properties[name];
+ var getter = isObject ? null : target["get_" + name];
+ if (isObject || typeof(getter) !== 'function') {
+ var targetVal = target[name];
+ if (!isObject && typeof(targetVal) === 'undefined') throw Error.invalidOperation(String.format(Sys.Res.propertyUndefined, name));
+ if (!val || (typeof(val) !== 'object') || (isObject && !targetVal)) {
+ target[name] = val;
+ }
+ else {
+ Sys$Component$_setProperties(targetVal, val);
+ }
+ }
+ else {
+ var setter = target["set_" + name];
+ if (typeof(setter) === 'function') {
+ setter.apply(target, [val]);
+ }
+ else if (val instanceof Array) {
+ current = getter.apply(target);
+ if (!(current instanceof Array)) throw new Error.invalidOperation(String.format(Sys.Res.propertyNotAnArray, name));
+ for (var i = 0, j = current.length, l= val.length; i < l; i++, j++) {
+ current[j] = val[i];
+ }
+ }
+ else if ((typeof(val) === 'object') && (Object.getType(val) === Object)) {
+ current = getter.apply(target);
+ if ((typeof(current) === 'undefined') || (current === null)) throw new Error.invalidOperation(String.format(Sys.Res.propertyNullOrUndefined, name));
+ Sys$Component$_setProperties(current, val);
+ }
+ else {
+ throw new Error.invalidOperation(String.format(Sys.Res.propertyNotWritable, name));
+ }
+ }
+ }
+ if (isComponent) target.endUpdate();
+}
+function Sys$Component$_setReferences(component, references) {
+ for (var name in references) {
+ var setter = component["set_" + name];
+ var reference = $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 $create = Sys.Component.create = function Sys$Component$create(type, properties, events, references, element) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "type", type: Type},
+ {name: "properties", mayBeNull: true, optional: true},
+ {name: "events", mayBeNull: true, optional: true},
+ {name: "references", mayBeNull: true, optional: true},
+ {name: "element", mayBeNull: true, domElement: true, optional: true}
+ ]);
+ if (e) throw e;
+ if (!type.inheritsFrom(Sys.Component)) {
+ throw Error.argument('type', String.format(Sys.Res.createNotComponent, type.getName()));
+ }
+ if (type.inheritsFrom(Sys.UI.Behavior) || type.inheritsFrom(Sys.UI.Control)) {
+ if (!element) throw Error.argument('element', Sys.Res.createNoDom);
+ }
+ else if (element) throw Error.argument('element', Sys.Res.createComponentOnDom);
+ var component = (element ? new type(element): new type());
+ var app = Sys.Application;
+ var creatingComponents = app.get_isCreatingComponents();
+ component.beginUpdate();
+ if (properties) {
+ Sys$Component$_setProperties(component, properties);
+ }
+ if (events) {
+ for (var name in events) {
+ if (!(component["add_" + name] instanceof Function)) throw new Error.invalidOperation(String.format(Sys.Res.undefinedEvent, name));
+ if (!(events[name] instanceof Function)) throw new Error.invalidOperation(Sys.Res.eventHandlerNotFunction);
+ component["add_" + name](events[name]);
+ }
+ }
+ if (component.get_id()) {
+ app.addComponent(component);
+ }
+ if (creatingComponents) {
+ app._createdComponents[app._createdComponents.length] = component;
+ if (references) {
+ app._addComponentToSecondPass(component, references);
+ }
+ else {
+ component.endUpdate();
+ }
+ }
+ else {
+ if (references) {
+ Sys$Component$_setReferences(component, references);
+ }
+ component.endUpdate();
+ }
+ return component;
+}
+
+Sys.UI.MouseButton = function Sys$UI$MouseButton() {
+ ///
+ ///
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+}
+Sys.UI.MouseButton.prototype = {
+ leftButton: 0,
+ middleButton: 1,
+ rightButton: 2
+}
+Sys.UI.MouseButton.registerEnum("Sys.UI.MouseButton");
+
+Sys.UI.Key = function Sys$UI$Key() {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+}
+Sys.UI.Key.prototype = {
+ backspace: 8,
+ tab: 9,
+ enter: 13,
+ esc: 27,
+ space: 32,
+ pageUp: 33,
+ pageDown: 34,
+ end: 35,
+ home: 36,
+ left: 37,
+ up: 38,
+ right: 39,
+ down: 40,
+ del: 127
+}
+Sys.UI.Key.registerEnum("Sys.UI.Key");
+
+Sys.UI.Point = function Sys$UI$Point(x, y) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "x", type: Number},
+ {name: "y", type: Number}
+ ]);
+ if (e) throw e;
+ this.rawX = x;
+ this.rawY = y;
+ this.x = Math.round(x);
+ this.y = Math.round(y);
+}
+Sys.UI.Point.registerClass('Sys.UI.Point');
+
+Sys.UI.Bounds = function Sys$UI$Bounds(x, y, width, height) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "x", type: Number, integer: true},
+ {name: "y", type: Number, integer: true},
+ {name: "width", type: Number, integer: true},
+ {name: "height", type: Number, integer: true}
+ ]);
+ if (e) throw e;
+ this.x = x;
+ this.y = y;
+ this.height = height;
+ this.width = width;
+}
+Sys.UI.Bounds.registerClass('Sys.UI.Bounds');
+
+Sys.UI.DomEvent = function Sys$UI$DomEvent(eventObject) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "eventObject"}
+ ]);
+ if (e) throw e;
+ var ev = eventObject;
+ var etype = this.type = ev.type.toLowerCase();
+ this.rawEvent = ev;
+ this.altKey = ev.altKey;
+ if (typeof(ev.button) !== 'undefined') {
+ this.button = (typeof(ev.which) !== 'undefined') ? ev.button :
+ (ev.button === 4) ? Sys.UI.MouseButton.middleButton :
+ (ev.button === 2) ? Sys.UI.MouseButton.rightButton :
+ Sys.UI.MouseButton.leftButton;
+ }
+ if (etype === 'keypress') {
+ this.charCode = ev.charCode || ev.keyCode;
+ }
+ else if (ev.keyCode && (ev.keyCode === 46)) {
+ this.keyCode = 127;
+ }
+ else {
+ this.keyCode = ev.keyCode;
+ }
+ this.clientX = ev.clientX;
+ this.clientY = ev.clientY;
+ this.ctrlKey = ev.ctrlKey;
+ this.target = ev.target ? ev.target : ev.srcElement;
+ if (!etype.startsWith('key')) {
+ if ((typeof(ev.offsetX) !== 'undefined') && (typeof(ev.offsetY) !== 'undefined')) {
+ this.offsetX = ev.offsetX;
+ this.offsetY = ev.offsetY;
+ }
+ else if (this.target && (this.target.nodeType !== 3) && (typeof(ev.clientX) === 'number')) {
+ var loc = Sys.UI.DomElement.getLocation(this.target);
+ var w = Sys.UI.DomElement._getWindow(this.target);
+ this.offsetX = (w.pageXOffset || 0) + ev.clientX - loc.x;
+ this.offsetY = (w.pageYOffset || 0) + ev.clientY - loc.y;
+ }
+ }
+ this.screenX = ev.screenX;
+ this.screenY = ev.screenY;
+ this.shiftKey = ev.shiftKey;
+}
+ function 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$UI$DomEvent$stopPropagation() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this.rawEvent.stopPropagation) {
+ this.rawEvent.stopPropagation();
+ }
+ else if (window.event) {
+ this.rawEvent.cancelBubble = true;
+ }
+ }
+Sys.UI.DomEvent.prototype = {
+ preventDefault: Sys$UI$DomEvent$preventDefault,
+ stopPropagation: Sys$UI$DomEvent$stopPropagation
+}
+Sys.UI.DomEvent.registerClass('Sys.UI.DomEvent');
+var $addHandler = Sys.UI.DomEvent.addHandler = function Sys$UI$DomEvent$addHandler(element, eventName, handler, autoRemove) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element"},
+ {name: "eventName", type: String},
+ {name: "handler", type: Function},
+ {name: "autoRemove", type: Boolean, optional: true}
+ ]);
+ if (e) throw e;
+ Sys.UI.DomEvent._ensureDomNode(element);
+ if (eventName === "error") throw Error.invalidOperation(Sys.Res.addHandlerCantBeUsedForError);
+ if (!element._events) {
+ element._events = {};
+ }
+ var eventCache = element._events[eventName];
+ if (!eventCache) {
+ element._events[eventName] = eventCache = [];
+ }
+ var browserHandler;
+ if (element.addEventListener) {
+ browserHandler = function(e) {
+ return handler.call(element, new Sys.UI.DomEvent(e));
+ }
+ element.addEventListener(eventName, browserHandler, false);
+ }
+ else if (element.attachEvent) {
+ browserHandler = function() {
+ var e = {};
+ try {e = Sys.UI.DomElement._getWindow(element).event} catch(ex) {}
+ return handler.call(element, new Sys.UI.DomEvent(e));
+ }
+ element.attachEvent('on' + eventName, browserHandler);
+ }
+ eventCache[eventCache.length] = {handler: handler, browserHandler: browserHandler, autoRemove: autoRemove };
+ if (autoRemove) {
+ var d = element.dispose;
+ if (d !== Sys.UI.DomEvent._disposeHandlers) {
+ element.dispose = Sys.UI.DomEvent._disposeHandlers;
+ if (typeof(d) !== "undefined") {
+ element._chainDispose = d;
+ }
+ }
+ }
+}
+var $addHandlers = Sys.UI.DomEvent.addHandlers = function Sys$UI$DomEvent$addHandlers(element, events, handlerOwner, autoRemove) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element"},
+ {name: "events", type: Object},
+ {name: "handlerOwner", optional: true},
+ {name: "autoRemove", type: Boolean, optional: true}
+ ]);
+ if (e) throw e;
+ Sys.UI.DomEvent._ensureDomNode(element);
+ for (var name in events) {
+ var handler = events[name];
+ if (typeof(handler) !== 'function') throw Error.invalidOperation(Sys.Res.cantAddNonFunctionhandler);
+ if (handlerOwner) {
+ handler = Function.createDelegate(handlerOwner, handler);
+ }
+ $addHandler(element, name, handler, autoRemove || false);
+ }
+}
+var $clearHandlers = Sys.UI.DomEvent.clearHandlers = function Sys$UI$DomEvent$clearHandlers(element) {
+ ///
+ ///
+ 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$UI$DomEvent$_clearHandlers(element, autoRemoving) {
+ if (element._events) {
+ var cache = element._events;
+ for (var name in cache) {
+ var handlers = cache[name];
+ for (var i = handlers.length - 1; i >= 0; i--) {
+ var entry = handlers[i];
+ if (!autoRemoving || entry.autoRemove) {
+ $removeHandler(element, name, entry.handler);
+ }
+ }
+ }
+ element._events = null;
+ }
+}
+Sys.UI.DomEvent._disposeHandlers = function Sys$UI$DomEvent$_disposeHandlers() {
+ Sys.UI.DomEvent._clearHandlers(this, true);
+ var d = this._chainDispose, type = typeof(d);
+ if (type !== "undefined") {
+ this.dispose = d;
+ this._chainDispose = null;
+ if (type === "function") {
+ this.dispose();
+ }
+ }
+}
+var $removeHandler = Sys.UI.DomEvent.removeHandler = function Sys$UI$DomEvent$removeHandler(element, eventName, handler) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element"},
+ {name: "eventName", type: String},
+ {name: "handler", type: Function}
+ ]);
+ if (e) throw e;
+ Sys.UI.DomEvent._removeHandler(element, eventName, handler);
+}
+Sys.UI.DomEvent._removeHandler = function Sys$UI$DomEvent$_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$UI$DomEvent$_ensureDomNode(element) {
+ if (element.tagName && (element.tagName.toUpperCase() === "SCRIPT")) return;
+
+ var doc = element.ownerDocument || element.document || element;
+ if ((typeof(element.document) !== 'object') && (element != doc) && (typeof(element.nodeType) !== 'number')) {
+ throw Error.argument("element", Sys.Res.argumentDomNode);
+ }
+}
+
+Sys.UI.DomElement = function Sys$UI$DomElement() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+}
+Sys.UI.DomElement.registerClass('Sys.UI.DomElement');
+Sys.UI.DomElement.addCssClass = function Sys$UI$DomElement$addCssClass(element, className) {
+ ///
+ ///
+ ///
+ 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$UI$DomElement$containsCssClass(element, className) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true},
+ {name: "className", type: String}
+ ]);
+ if (e) throw e;
+ return Array.contains(element.className.split(' '), className);
+}
+Sys.UI.DomElement.getBounds = function Sys$UI$DomElement$getBounds(element) {
+ ///
+ ///
+ ///
+ 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 $get = Sys.UI.DomElement.getElementById = function Sys$UI$DomElement$getElementById(id, element) {
+ ///
+ ///
+ ///
+ ///
+ 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$UI$DomElement$getLocation(element) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true}
+ ]);
+ if (e) throw e;
+ if (element.self || element.nodeType === 9 ||
+ (element === document.documentElement) ||
+ (element.parentNode === element.ownerDocument.documentElement)) {
+ return new Sys.UI.Point(0, 0);
+ }
+
+ var clientRect = element.getBoundingClientRect();
+ if (!clientRect) {
+ return new Sys.UI.Point(0,0);
+ }
+ var documentElement = element.ownerDocument.documentElement;
+ var bodyElement = element.ownerDocument.body;
+ var ex,
+ offsetX = Math.round(clientRect.left) + (documentElement.scrollLeft || bodyElement.scrollLeft),
+ offsetY = Math.round(clientRect.top) + (documentElement.scrollTop || bodyElement.scrollTop);
+ if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {
+ try {
+ var f = element.ownerDocument.parentWindow.frameElement || null;
+ if (f) {
+ var offset = (f.frameBorder === "0" || f.frameBorder === "no") ? 2 : 0;
+ offsetX += offset;
+ offsetY += offset;
+ }
+ }
+ catch(ex) {
+ }
+ if (Sys.Browser.version === 7 && !document.documentMode) {
+ var body = document.body,
+ rect = body.getBoundingClientRect(),
+ zoom = (rect.right-rect.left) / body.clientWidth;
+ zoom = Math.round(zoom * 100);
+ zoom = (zoom - zoom % 5) / 100;
+ if (!isNaN(zoom) && (zoom !== 1)) {
+ offsetX = Math.round(offsetX / zoom);
+ offsetY = Math.round(offsetY / zoom);
+ }
+ }
+ if ((document.documentMode || 0) < 8) {
+ offsetX -= documentElement.clientLeft;
+ offsetY -= documentElement.clientTop;
+ }
+ }
+ return new Sys.UI.Point(offsetX, offsetY);
+ }
+}
+else if (Sys.Browser.agent === Sys.Browser.Safari) {
+ Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) {
+ ///
+ ///
+ ///
+ 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$UI$DomElement$getLocation(element) {
+ ///
+ ///
+ ///
+ 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 = null;
+ for (parent = element; parent; previous = parent, previousStyle = currentStyle, parent = parent.offsetParent) {
+ var tagName = parent.tagName ? parent.tagName.toUpperCase() : null;
+ currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);
+ if ((parent.offsetLeft || parent.offsetTop) &&
+ !((tagName === "BODY") &&
+ (!previousStyle || previousStyle.position !== "absolute"))) {
+ offsetX += parent.offsetLeft;
+ offsetY += parent.offsetTop;
+ }
+ if (previous !== null && currentStyle) {
+ if ((tagName !== "TABLE") && (tagName !== "TD") && (tagName !== "HTML")) {
+ offsetX += parseInt(currentStyle.borderLeftWidth) || 0;
+ offsetY += parseInt(currentStyle.borderTopWidth) || 0;
+ }
+ if (tagName === "TABLE" &&
+ (currentStyle.position === "relative" || currentStyle.position === "absolute")) {
+ offsetX += parseInt(currentStyle.marginLeft) || 0;
+ offsetY += parseInt(currentStyle.marginTop) || 0;
+ }
+ }
+ }
+ 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);
+ if (currentStyle) {
+ offsetX += parseInt(currentStyle.borderLeftWidth) || 0;
+ offsetY += parseInt(currentStyle.borderTopWidth) || 0;
+ }
+ }
+ }
+ }
+ return new Sys.UI.Point(offsetX, offsetY);
+ }
+}
+Sys.UI.DomElement.isDomElement = function Sys$UI$DomElement$isDomElement(obj) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "obj"}
+ ]);
+ if (e) throw e;
+ return Sys._isDomElement(obj);
+}
+Sys.UI.DomElement.removeCssClass = function Sys$UI$DomElement$removeCssClass(element, className) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true},
+ {name: "className", type: String}
+ ]);
+ if (e) throw e;
+ var currentClassName = ' ' + element.className + ' ';
+ var index = currentClassName.indexOf(' ' + className + ' ');
+ if (index >= 0) {
+ element.className = (currentClassName.substr(0, index) + ' ' +
+ currentClassName.substring(index + className.length + 1, currentClassName.length)).trim();
+ }
+}
+Sys.UI.DomElement.resolveElement = function Sys$UI$DomElement$resolveElement(elementOrElementId, containerElement) {
+ ///
+ ///
+ ///
+ ///
+ 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$UI$DomElement$raiseBubbleEvent(source, args) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "source", domElement: true},
+ {name: "args", type: Sys.EventArgs}
+ ]);
+ if (e) throw e;
+ var target = source;
+ while (target) {
+ var control = target.control;
+ if (control && control.onBubbleEvent && control.raiseBubbleEvent) {
+ Sys.UI.DomElement._raiseBubbleEventFromControl(control, source, args);
+ return;
+ }
+ target = target.parentNode;
+ }
+}
+Sys.UI.DomElement._raiseBubbleEventFromControl = function Sys$UI$DomElement$_raiseBubbleEventFromControl(control, source, args) {
+ if (!control.onBubbleEvent(source, args)) {
+ control._raiseBubbleEvent(source, args);
+ }
+}
+Sys.UI.DomElement.setLocation = function Sys$UI$DomElement$setLocation(element, x, y) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true},
+ {name: "x", type: Number, integer: true},
+ {name: "y", type: Number, integer: true}
+ ]);
+ if (e) throw e;
+ var style = element.style;
+ style.position = 'absolute';
+ style.left = x + "px";
+ style.top = y + "px";
+}
+Sys.UI.DomElement.toggleCssClass = function Sys$UI$DomElement$toggleCssClass(element, className) {
+ ///
+ ///
+ ///
+ 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$UI$DomElement$getVisibilityMode(element) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true}
+ ]);
+ if (e) throw e;
+ return (element._visibilityMode === Sys.UI.VisibilityMode.hide) ?
+ Sys.UI.VisibilityMode.hide :
+ Sys.UI.VisibilityMode.collapse;
+}
+Sys.UI.DomElement.setVisibilityMode = function Sys$UI$DomElement$setVisibilityMode(element, value) {
+ ///
+ ///
+ ///
+ 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$UI$DomElement$getVisible(element) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true}
+ ]);
+ if (e) throw e;
+ var style = element.currentStyle || Sys.UI.DomElement._getCurrentStyle(element);
+ if (!style) return true;
+ return (style.visibility !== 'hidden') && (style.display !== 'none');
+}
+Sys.UI.DomElement.setVisible = function Sys$UI$DomElement$setVisible(element, value) {
+ ///
+ ///
+ ///
+ 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$UI$DomElement$_ensureOldDisplayMode(element) {
+ if (!element._oldDisplayMode) {
+ var style = element.currentStyle || Sys.UI.DomElement._getCurrentStyle(element);
+ element._oldDisplayMode = style ? style.display : null;
+ if (!element._oldDisplayMode || element._oldDisplayMode === 'none') {
+ switch(element.tagName.toUpperCase()) {
+ case 'DIV': case 'P': case 'ADDRESS': case 'BLOCKQUOTE': case 'BODY': case 'COL':
+ case 'COLGROUP': case 'DD': case 'DL': case 'DT': case 'FIELDSET': case 'FORM':
+ case 'H1': case 'H2': case 'H3': case 'H4': case 'H5': case 'H6': case 'HR':
+ case 'IFRAME': case 'LEGEND': case 'OL': case 'PRE': case 'TABLE': case 'TD':
+ case 'TH': case 'TR': case 'UL':
+ element._oldDisplayMode = 'block';
+ break;
+ case 'LI':
+ element._oldDisplayMode = 'list-item';
+ break;
+ default:
+ element._oldDisplayMode = 'inline';
+ }
+ }
+ }
+}
+Sys.UI.DomElement._getWindow = function Sys$UI$DomElement$_getWindow(element) {
+ var doc = element.ownerDocument || element.document || element;
+ return doc.defaultView || doc.parentWindow;
+}
+Sys.UI.DomElement._getCurrentStyle = function Sys$UI$DomElement$_getCurrentStyle(element) {
+ if (element.nodeType === 3) return null;
+ var w = Sys.UI.DomElement._getWindow(element);
+ if (element.documentElement) element = element.documentElement;
+ var computedStyle = (w && (element !== w) && w.getComputedStyle) ?
+ w.getComputedStyle(element, null) :
+ element.currentStyle || element.style;
+ if (!computedStyle && (Sys.Browser.agent === Sys.Browser.Safari) && element.style) {
+ var oldDisplay = element.style.display;
+ var oldPosition = element.style.position;
+ element.style.position = 'absolute';
+ element.style.display = 'block';
+ var style = w.getComputedStyle(element, null);
+ element.style.display = oldDisplay;
+ element.style.position = oldPosition;
+ computedStyle = {};
+ for (var n in style) {
+ computedStyle[n] = style[n];
+ }
+ computedStyle.display = 'none';
+ }
+ return computedStyle;
+}
+
+Sys.IContainer = function Sys$IContainer() {
+ throw Error.notImplemented();
+}
+ function Sys$IContainer$addComponent(component) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "component", type: Sys.Component}
+ ]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+ function Sys$IContainer$removeComponent(component) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "component", type: Sys.Component}
+ ]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+ function Sys$IContainer$findComponent(id) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "id", type: String}
+ ]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+ function Sys$IContainer$getComponents() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+Sys.IContainer.prototype = {
+ addComponent: Sys$IContainer$addComponent,
+ removeComponent: Sys$IContainer$removeComponent,
+ findComponent: Sys$IContainer$findComponent,
+ getComponents: Sys$IContainer$getComponents
+}
+Sys.IContainer.registerInterface("Sys.IContainer");
+
+Sys.ApplicationLoadEventArgs = function Sys$ApplicationLoadEventArgs(components, isPartialLoad) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "components", type: Array, elementType: Sys.Component},
+ {name: "isPartialLoad", type: Boolean}
+ ]);
+ if (e) throw e;
+ Sys.ApplicationLoadEventArgs.initializeBase(this);
+ this._components = components;
+ this._isPartialLoad = isPartialLoad;
+}
+
+ function Sys$ApplicationLoadEventArgs$get_components() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._components;
+ }
+ function Sys$ApplicationLoadEventArgs$get_isPartialLoad() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._isPartialLoad;
+ }
+Sys.ApplicationLoadEventArgs.prototype = {
+ get_components: Sys$ApplicationLoadEventArgs$get_components,
+ get_isPartialLoad: Sys$ApplicationLoadEventArgs$get_isPartialLoad
+}
+Sys.ApplicationLoadEventArgs.registerClass('Sys.ApplicationLoadEventArgs', Sys.EventArgs);
+
+Sys._Application = function Sys$_Application() {
+ ///
+ 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$_Application$get_isCreatingComponents() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._creatingComponents;
+ }
+ function Sys$_Application$get_isDisposing() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._disposing;
+ }
+ function Sys$_Application$add_init(handler) {
+ ///
+ 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$_Application$remove_init(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().removeHandler("init", handler);
+ }
+ function Sys$_Application$add_load(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().addHandler("load", handler);
+ }
+ function Sys$_Application$remove_load(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().removeHandler("load", handler);
+ }
+ function Sys$_Application$add_unload(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().addHandler("unload", handler);
+ }
+ function Sys$_Application$remove_unload(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this.get_events().removeHandler("unload", handler);
+ }
+ function Sys$_Application$addComponent(component) {
+ ///
+ ///
+ 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$_Application$beginCreateComponents() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ this._creatingComponents = true;
+ }
+ function 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$_Application$disposeElement(element, childNodesOnly) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element"},
+ {name: "childNodesOnly", type: Boolean}
+ ]);
+ if (e) throw e;
+ if (element.nodeType === 1) {
+ var i, allElements = element.getElementsByTagName("*"),
+ length = allElements.length,
+ children = new Array(length);
+ for (i = 0; i < length; i++) {
+ children[i] = allElements[i];
+ }
+ for (i = length - 1; i >= 0; i--) {
+ var child = children[i];
+ var d = child.dispose;
+ if (d && typeof(d) === "function") {
+ child.dispose();
+ }
+ else {
+ var c = child.control;
+ if (c && typeof(c.dispose) === "function") {
+ c.dispose();
+ }
+ }
+ var list = child._behaviors;
+ if (list) {
+ this._disposeComponents(list);
+ }
+ list = child._components;
+ if (list) {
+ this._disposeComponents(list);
+ child._components = null;
+ }
+ }
+ if (!childNodesOnly) {
+ 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$_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$_Application$findComponent(id, parent) {
+ ///
+ ///
+ ///
+ ///
+ 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$_Application$getComponents() {
+ ///
+ ///
+ 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$_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$_Application$notifyScriptLoaded() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ }
+ function Sys$_Application$registerDisposableObject(object) {
+ ///
+ ///
+ 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$_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$_Application$removeComponent(component) {
+ ///
+ ///
+ 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$_Application$unregisterDisposableObject(object) {
+ ///
+ ///
+ 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$_Application$_addComponentToSecondPass(component, references) {
+ this._secondPassComponents[this._secondPassComponents.length] = {component: component, references: references};
+ }
+ function Sys$_Application$_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$_Application$_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$_Application$_raiseInit() {
+ var handler = this.get_events().getHandler("init");
+ if (handler) {
+ this.beginCreateComponents();
+ handler(this, Sys.EventArgs.Empty);
+ this.endCreateComponents();
+ }
+ }
+ function Sys$_Application$_unloadHandler(event) {
+ this.dispose();
+ }
+Sys._Application.prototype = {
+ _creatingComponents: false,
+ _disposing: false,
+ _deleteCount: 0,
+ get_isCreatingComponents: Sys$_Application$get_isCreatingComponents,
+ get_isDisposing: Sys$_Application$get_isDisposing,
+ add_init: Sys$_Application$add_init,
+ remove_init: Sys$_Application$remove_init,
+ add_load: Sys$_Application$add_load,
+ remove_load: Sys$_Application$remove_load,
+ add_unload: Sys$_Application$add_unload,
+ remove_unload: Sys$_Application$remove_unload,
+ addComponent: Sys$_Application$addComponent,
+ beginCreateComponents: Sys$_Application$beginCreateComponents,
+ dispose: Sys$_Application$dispose,
+ disposeElement: Sys$_Application$disposeElement,
+ endCreateComponents: Sys$_Application$endCreateComponents,
+ findComponent: Sys$_Application$findComponent,
+ getComponents: Sys$_Application$getComponents,
+ initialize: Sys$_Application$initialize,
+ notifyScriptLoaded: Sys$_Application$notifyScriptLoaded,
+ registerDisposableObject: Sys$_Application$registerDisposableObject,
+ raiseLoad: Sys$_Application$raiseLoad,
+ removeComponent: Sys$_Application$removeComponent,
+ unregisterDisposableObject: Sys$_Application$unregisterDisposableObject,
+ _addComponentToSecondPass: Sys$_Application$_addComponentToSecondPass,
+ _disposeComponents: Sys$_Application$_disposeComponents,
+ _domReady: Sys$_Application$_domReady,
+ _raiseInit: Sys$_Application$_raiseInit,
+ _unloadHandler: Sys$_Application$_unloadHandler
+}
+Sys._Application.registerClass('Sys._Application', Sys.Component, Sys.IContainer);
+Sys.Application = new Sys._Application();
+var $find = Sys.Application.findComponent;
+
+Sys.UI.Behavior = function Sys$UI$Behavior(element) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true}
+ ]);
+ if (e) throw e;
+ Sys.UI.Behavior.initializeBase(this);
+ this._element = element;
+ var behaviors = element._behaviors;
+ if (!behaviors) {
+ element._behaviors = [this];
+ }
+ else {
+ behaviors[behaviors.length] = this;
+ }
+}
+ function Sys$UI$Behavior$get_element() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._element;
+ }
+ function Sys$UI$Behavior$get_id() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ var baseId = Sys.UI.Behavior.callBaseMethod(this, 'get_id');
+ if (baseId) return baseId;
+ if (!this._element || !this._element.id) return '';
+ return this._element.id + '$' + this.get_name();
+ }
+ function Sys$UI$Behavior$get_name() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this._name) return this._name;
+ var name = Object.getTypeName(this);
+ var i = name.lastIndexOf('.');
+ if (i !== -1) name = name.substr(i + 1);
+ if (!this.get_isInitialized()) this._name = name;
+ return name;
+ }
+ function Sys$UI$Behavior$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$UI$Behavior$initialize() {
+ Sys.UI.Behavior.callBaseMethod(this, 'initialize');
+ var name = this.get_name();
+ if (name) this._element[name] = this;
+ }
+ function Sys$UI$Behavior$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$UI$Behavior$get_element,
+ get_id: Sys$UI$Behavior$get_id,
+ get_name: Sys$UI$Behavior$get_name,
+ set_name: Sys$UI$Behavior$set_name,
+ initialize: Sys$UI$Behavior$initialize,
+ dispose: Sys$UI$Behavior$dispose
+}
+Sys.UI.Behavior.registerClass('Sys.UI.Behavior', Sys.Component);
+Sys.UI.Behavior.getBehaviorByName = function Sys$UI$Behavior$getBehaviorByName(element, name) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true},
+ {name: "name", type: String}
+ ]);
+ if (e) throw e;
+ var b = element[name];
+ return (b && Sys.UI.Behavior.isInstanceOfType(b)) ? b : null;
+}
+Sys.UI.Behavior.getBehaviors = function Sys$UI$Behavior$getBehaviors(element) {
+ ///
+ ///
+ ///
+ 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$UI$Behavior$getBehaviorsByType(element, type) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true},
+ {name: "type", type: Type}
+ ]);
+ if (e) throw e;
+ var behaviors = element._behaviors;
+ var results = [];
+ if (behaviors) {
+ for (var i = 0, l = behaviors.length; i < l; i++) {
+ if (type.isInstanceOfType(behaviors[i])) {
+ results[results.length] = behaviors[i];
+ }
+ }
+ }
+ return results;
+}
+
+Sys.UI.VisibilityMode = function Sys$UI$VisibilityMode() {
+ ///
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+}
+Sys.UI.VisibilityMode.prototype = {
+ hide: 0,
+ collapse: 1
+}
+Sys.UI.VisibilityMode.registerEnum("Sys.UI.VisibilityMode");
+
+Sys.UI.Control = function Sys$UI$Control(element) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "element", domElement: true}
+ ]);
+ if (e) throw e;
+ if (element.control !== null && typeof(element.control) !== 'undefined') throw Error.invalidOperation(Sys.Res.controlAlreadyDefined);
+ Sys.UI.Control.initializeBase(this);
+ this._element = element;
+ element.control = this;
+ var role = this.get_role();
+ if (role) {
+ element.setAttribute("role", role);
+ }
+}
+ function Sys$UI$Control$get_element() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._element;
+ }
+ function Sys$UI$Control$get_id() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (!this._element) return '';
+ return this._element.id;
+ }
+ function Sys$UI$Control$set_id(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: String}]);
+ if (e) throw e;
+ throw Error.invalidOperation(Sys.Res.cantSetId);
+ }
+ function Sys$UI$Control$get_parent() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this._parent) return this._parent;
+ if (!this._element) return null;
+
+ var parentElement = this._element.parentNode;
+ while (parentElement) {
+ if (parentElement.control) {
+ return parentElement.control;
+ }
+ parentElement = parentElement.parentNode;
+ }
+ return null;
+ }
+ function Sys$UI$Control$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$UI$Control$get_role() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return null;
+ }
+ function Sys$UI$Control$get_visibilityMode() {
+ ///
+ 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$UI$Control$set_visibilityMode(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Sys.UI.VisibilityMode}]);
+ if (e) throw e;
+ if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
+ Sys.UI.DomElement.setVisibilityMode(this._element, value);
+ }
+ function Sys$UI$Control$get_visible() {
+ ///
+ 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$UI$Control$set_visible(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
+ if (e) throw e;
+ if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
+ Sys.UI.DomElement.setVisible(this._element, value)
+ }
+ function Sys$UI$Control$addCssClass(className) {
+ ///
+ ///
+ 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$UI$Control$dispose() {
+ Sys.UI.Control.callBaseMethod(this, 'dispose');
+ if (this._element) {
+ this._element.control = null;
+ delete this._element;
+ }
+ if (this._parent) delete this._parent;
+ }
+ function Sys$UI$Control$onBubbleEvent(source, args) {
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "source"},
+ {name: "args", type: Sys.EventArgs}
+ ]);
+ if (e) throw e;
+ return false;
+ }
+ function Sys$UI$Control$raiseBubbleEvent(source, args) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "source"},
+ {name: "args", type: Sys.EventArgs}
+ ]);
+ if (e) throw e;
+ this._raiseBubbleEvent(source, args);
+ }
+ function Sys$UI$Control$_raiseBubbleEvent(source, args) {
+ var currentTarget = this.get_parent();
+ while (currentTarget) {
+ if (currentTarget.onBubbleEvent(source, args)) {
+ return;
+ }
+ currentTarget = currentTarget.get_parent();
+ }
+ }
+ function Sys$UI$Control$removeCssClass(className) {
+ ///
+ ///
+ 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.removeCssClass(this._element, className);
+ }
+ function Sys$UI$Control$toggleCssClass(className) {
+ ///
+ ///
+ 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$UI$Control$get_element,
+ get_id: Sys$UI$Control$get_id,
+ set_id: Sys$UI$Control$set_id,
+ get_parent: Sys$UI$Control$get_parent,
+ set_parent: Sys$UI$Control$set_parent,
+ get_role: Sys$UI$Control$get_role,
+ get_visibilityMode: Sys$UI$Control$get_visibilityMode,
+ set_visibilityMode: Sys$UI$Control$set_visibilityMode,
+ get_visible: Sys$UI$Control$get_visible,
+ set_visible: Sys$UI$Control$set_visible,
+ addCssClass: Sys$UI$Control$addCssClass,
+ dispose: Sys$UI$Control$dispose,
+ onBubbleEvent: Sys$UI$Control$onBubbleEvent,
+ raiseBubbleEvent: Sys$UI$Control$raiseBubbleEvent,
+ _raiseBubbleEvent: Sys$UI$Control$_raiseBubbleEvent,
+ removeCssClass: Sys$UI$Control$removeCssClass,
+ toggleCssClass: Sys$UI$Control$toggleCssClass
+}
+Sys.UI.Control.registerClass('Sys.UI.Control', Sys.Component);
+Sys.HistoryEventArgs = function Sys$HistoryEventArgs(state) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "state", type: Object}
+ ]);
+ if (e) throw e;
+ Sys.HistoryEventArgs.initializeBase(this);
+ this._state = state;
+}
+ function Sys$HistoryEventArgs$get_state() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._state;
+ }
+Sys.HistoryEventArgs.prototype = {
+ get_state: Sys$HistoryEventArgs$get_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$_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$_Application$get_enableHistory() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._enableHistory;
+};
+Sys._Application.prototype.set_enableHistory = function Sys$_Application$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$_Application$add_navigate(handler) {
+ ///
+ ///
+ 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$_Application$remove_navigate(handler) {
+ ///
+ ///
+ 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$_Application$addHistoryPoint(state, title) {
+ ///
+ ///
+ ///
+ 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$_Application$setServerId(clientId, uniqueId) {
+ ///
+ ///
+ ///
+ 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$_Application$setServerState(value) {
+ ///
+ ///
+ 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$_Application$_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$_Application$_enableHistoryInScriptManager() {
+ this._enableHistory = true;
+ this._historyEnabledInScriptManager = true;
+};
+Sys._Application.prototype._ensureHistory = function Sys$_Application$_ensureHistory() {
+ if (!this._historyInitialized && this._enableHistory) {
+ if ((Sys.Browser.agent === Sys.Browser.InternetExplorer) &&
+ ((!document.documentMode) || document.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$_Application$_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$_Application$_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$_Application$_onIFrameLoad(entry) {
+ if ((!document.documentMode) || document.documentMode < 8 ) {
+ this._ensureHistory();
+ if (!this._ignoreIFrame) {
+ this._historyPointIsNew = false;
+ this._navigate(entry);
+ }
+ this._ignoreIFrame = false;
+ }
+};
+Sys._Application.prototype._onPageRequestManagerBeginRequest = function Sys$_Application$_onPageRequestManagerBeginRequest(sender, args) {
+ this._ignoreTimer = true;
+ this._originalTitle = document.title;
+};
+Sys._Application.prototype._onPageRequestManagerEndRequest = function Sys$_Application$_onPageRequestManagerEndRequest(sender, args) {
+ var dataItem = args.get_dataItems()[this._clientId];
+ var originalTitle = this._originalTitle;
+ this._originalTitle = null;
+ 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;
+ if (typeof(originalTitle) === "string") {
+ if (Sys.Browser.agent !== Sys.Browser.InternetExplorer || Sys.Browser.version > 7) {
+ var newTitle = document.title;
+ document.title = originalTitle;
+ this._setState(entry);
+ document.title = newTitle;
+ }
+ else {
+ this._setState(entry);
+ }
+ this._raiseNavigate();
+ }
+ else {
+ this._setState(entry);
+ this._raiseNavigate();
+ }
+ }
+};
+Sys._Application.prototype._raiseNavigate = function Sys$_Application$_raiseNavigate() {
+ var isNew = this._historyPointIsNew;
+ 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);
+ }
+ if (!isNew) {
+ var err;
+ try {
+ if ((Sys.Browser.agent === Sys.Browser.Firefox) && window.location.hash &&
+ (!window.frameElement || window.top.location.hash)) {
+ (Sys.Browser.version < 3.5) ?
+ window.history.go(0) :
+ location.hash = this.get_stateString();
+ }
+ }
+ catch(err) {
+ }
+ }
+};
+Sys._Application.prototype._serializeState = function Sys$_Application$_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$_Application$_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) {
+ var newDiv = document.createElement("div");
+ newDiv.appendChild(document.createTextNode(title || document.title));
+ var htmlEncodedTitle = newDiv.innerHTML;
+ this._ignoreIFrame = true;
+ var frameDoc = this._historyFrame.contentWindow.document;
+ frameDoc.open("javascript:''");
+ frameDoc.write("
" + htmlEncodedTitle +
+ "parent.Sys.Application._onIFrameLoad(" +
+ Sys.Serialization.JavaScriptSerializer.serialize(entry) +
+ ");");
+ 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 > 2048) {
+ throw Error.invalidOperation(String.format(Sys.Res.urlTooLong, 2048));
+ }
+ 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$_Application$_updateHiddenField(value) {
+ if (this._clientId) {
+ var serverStateField = document.getElementById(this._clientId);
+ if (serverStateField) {
+ serverStateField.value = value;
+ }
+ }
+};
+
+if (!window.XMLHttpRequest) {
+ window.XMLHttpRequest = function window$XMLHttpRequest() {
+ var progIDs = [ 'Msxml2.XMLHTTP.3.0', 'Msxml2.XMLHTTP' ];
+ for (var i = 0, l = progIDs.length; i < l; i++) {
+ try {
+ return new ActiveXObject(progIDs[i]);
+ }
+ catch (ex) {
+ }
+ }
+ return null;
+ }
+}
+Type.registerNamespace('Sys.Net');
+
+Sys.Net.WebRequestExecutor = function Sys$Net$WebRequestExecutor() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ this._webRequest = null;
+ this._resultObject = null;
+}
+ function Sys$Net$WebRequestExecutor$get_webRequest() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._webRequest;
+ }
+ function Sys$Net$WebRequestExecutor$_set_webRequest(value) {
+ if (this.get_started()) {
+ throw Error.invalidOperation(String.format(Sys.Res.cannotCallOnceStarted, 'set_webRequest'));
+ }
+ this._webRequest = value;
+ }
+ function Sys$Net$WebRequestExecutor$get_started() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_responseAvailable() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_timedOut() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_aborted() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_responseData() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_statusCode() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_statusText() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_xml() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$get_object() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (!this._resultObject) {
+ this._resultObject = Sys.Serialization.JavaScriptSerializer.deserialize(this.get_responseData());
+ }
+ return this._resultObject;
+ }
+ function Sys$Net$WebRequestExecutor$executeRequest() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$abort() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$getResponseHeader(header) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "header", type: String}
+ ]);
+ if (e) throw e;
+ throw Error.notImplemented();
+ }
+ function Sys$Net$WebRequestExecutor$getAllResponseHeaders() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ throw Error.notImplemented();
+ }
+Sys.Net.WebRequestExecutor.prototype = {
+ get_webRequest: Sys$Net$WebRequestExecutor$get_webRequest,
+ _set_webRequest: Sys$Net$WebRequestExecutor$_set_webRequest,
+ get_started: Sys$Net$WebRequestExecutor$get_started,
+ get_responseAvailable: Sys$Net$WebRequestExecutor$get_responseAvailable,
+ get_timedOut: Sys$Net$WebRequestExecutor$get_timedOut,
+ get_aborted: Sys$Net$WebRequestExecutor$get_aborted,
+ get_responseData: Sys$Net$WebRequestExecutor$get_responseData,
+ get_statusCode: Sys$Net$WebRequestExecutor$get_statusCode,
+ get_statusText: Sys$Net$WebRequestExecutor$get_statusText,
+ get_xml: Sys$Net$WebRequestExecutor$get_xml,
+ get_object: Sys$Net$WebRequestExecutor$get_object,
+ executeRequest: Sys$Net$WebRequestExecutor$executeRequest,
+ abort: Sys$Net$WebRequestExecutor$abort,
+ getResponseHeader: Sys$Net$WebRequestExecutor$getResponseHeader,
+ getAllResponseHeaders: Sys$Net$WebRequestExecutor$getAllResponseHeaders
+}
+Sys.Net.WebRequestExecutor.registerClass('Sys.Net.WebRequestExecutor');
+
+Sys.Net.XMLDOM = function Sys$Net$XMLDOM(markup) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "markup", type: String}
+ ]);
+ if (e) throw e;
+ if (!window.DOMParser) {
+ var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];
+ for (var i = 0, l = progIDs.length; i < l; i++) {
+ try {
+ var xmlDOM = new ActiveXObject(progIDs[i]);
+ xmlDOM.async = false;
+ xmlDOM.loadXML(markup);
+ xmlDOM.setProperty('SelectionLanguage', 'XPath');
+ return xmlDOM;
+ }
+ catch (ex) {
+ }
+ }
+ }
+ else {
+ try {
+ var domParser = new window.DOMParser();
+ return domParser.parseFromString(markup, 'text/xml');
+ }
+ catch (ex) {
+ }
+ }
+ return null;
+}
+Sys.Net.XMLHttpExecutor = function Sys$Net$XMLHttpExecutor() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ Sys.Net.XMLHttpExecutor.initializeBase(this);
+ var _this = this;
+ this._xmlHttpRequest = null;
+ this._webRequest = null;
+ this._responseAvailable = false;
+ this._timedOut = false;
+ this._timer = null;
+ this._aborted = false;
+ this._started = false;
+ this._onReadyStateChange = (function () {
+
+ if (_this._xmlHttpRequest.readyState === 4 ) {
+ try {
+ if (typeof(_this._xmlHttpRequest.status) === "undefined" || _this._xmlHttpRequest.status === 0) {
+ return;
+ }
+ }
+ catch(ex) {
+ return;
+ }
+
+ _this._clearTimer();
+ _this._responseAvailable = true;
+ _this._webRequest.completed(Sys.EventArgs.Empty);
+ if (_this._xmlHttpRequest != null) {
+ _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
+ _this._xmlHttpRequest = null;
+ }
+ }
+ });
+ this._clearTimer = (function() {
+ if (_this._timer != null) {
+ window.clearTimeout(_this._timer);
+ _this._timer = null;
+ }
+ });
+ this._onTimeout = (function() {
+ if (!_this._responseAvailable) {
+ _this._clearTimer();
+ _this._timedOut = true;
+ _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
+ _this._xmlHttpRequest.abort();
+ _this._webRequest.completed(Sys.EventArgs.Empty);
+ _this._xmlHttpRequest = null;
+ }
+ });
+}
+ function Sys$Net$XMLHttpExecutor$get_timedOut() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._timedOut;
+ }
+ function Sys$Net$XMLHttpExecutor$get_started() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._started;
+ }
+ function Sys$Net$XMLHttpExecutor$get_responseAvailable() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._responseAvailable;
+ }
+ function Sys$Net$XMLHttpExecutor$get_aborted() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._aborted;
+ }
+ function 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$Net$XMLHttpExecutor$getResponseHeader(header) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "header", type: String}
+ ]);
+ if (e) throw e;
+ if (!this._responseAvailable) {
+ throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'getResponseHeader'));
+ }
+ if (!this._xmlHttpRequest) {
+ throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'getResponseHeader'));
+ }
+ var result;
+ try {
+ result = this._xmlHttpRequest.getResponseHeader(header);
+ } catch (e) {
+ }
+ if (!result) result = "";
+ return result;
+ }
+ function Sys$Net$XMLHttpExecutor$getAllResponseHeaders() {
+ ///
+ ///
+ 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$Net$XMLHttpExecutor$get_responseData() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (!this._responseAvailable) {
+ throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_responseData'));
+ }
+ if (!this._xmlHttpRequest) {
+ throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_responseData'));
+ }
+ return this._xmlHttpRequest.responseText;
+ }
+ function Sys$Net$XMLHttpExecutor$get_statusCode() {
+ ///
+ 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$Net$XMLHttpExecutor$get_statusText() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (!this._responseAvailable) {
+ throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, 'get_statusText'));
+ }
+ if (!this._xmlHttpRequest) {
+ throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, 'get_statusText'));
+ }
+ return this._xmlHttpRequest.statusText;
+ }
+ function Sys$Net$XMLHttpExecutor$get_xml() {
+ ///
+ 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 && typeof(xml.setProperty) != 'undefined') {
+ 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$Net$XMLHttpExecutor$abort() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (!this._started) {
+ throw Error.invalidOperation(Sys.Res.cannotAbortBeforeStart);
+ }
+ if (this._aborted || this._responseAvailable || this._timedOut)
+ return;
+ this._aborted = true;
+ this._clearTimer();
+ if (this._xmlHttpRequest && !this._responseAvailable) {
+ this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
+ this._xmlHttpRequest.abort();
+
+ this._xmlHttpRequest = null;
+ this._webRequest.completed(Sys.EventArgs.Empty);
+ }
+ }
+Sys.Net.XMLHttpExecutor.prototype = {
+ get_timedOut: Sys$Net$XMLHttpExecutor$get_timedOut,
+ get_started: Sys$Net$XMLHttpExecutor$get_started,
+ get_responseAvailable: Sys$Net$XMLHttpExecutor$get_responseAvailable,
+ get_aborted: Sys$Net$XMLHttpExecutor$get_aborted,
+ executeRequest: Sys$Net$XMLHttpExecutor$executeRequest,
+ getResponseHeader: Sys$Net$XMLHttpExecutor$getResponseHeader,
+ getAllResponseHeaders: Sys$Net$XMLHttpExecutor$getAllResponseHeaders,
+ get_responseData: Sys$Net$XMLHttpExecutor$get_responseData,
+ get_statusCode: Sys$Net$XMLHttpExecutor$get_statusCode,
+ get_statusText: Sys$Net$XMLHttpExecutor$get_statusText,
+ get_xml: Sys$Net$XMLHttpExecutor$get_xml,
+ abort: Sys$Net$XMLHttpExecutor$abort
+}
+Sys.Net.XMLHttpExecutor.registerClass('Sys.Net.XMLHttpExecutor', Sys.Net.WebRequestExecutor);
+
+Sys.Net._WebRequestManager = function Sys$Net$_WebRequestManager() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ this._defaultTimeout = 0;
+ this._defaultExecutorType = "Sys.Net.XMLHttpExecutor";
+}
+ function Sys$Net$_WebRequestManager$add_invokingRequest(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("invokingRequest", handler);
+ }
+ function Sys$Net$_WebRequestManager$remove_invokingRequest(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("invokingRequest", handler);
+ }
+ function Sys$Net$_WebRequestManager$add_completedRequest(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("completedRequest", handler);
+ }
+ function Sys$Net$_WebRequestManager$remove_completedRequest(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("completedRequest", handler);
+ }
+ function Sys$Net$_WebRequestManager$_get_eventHandlerList() {
+ if (!this._events) {
+ this._events = new Sys.EventHandlerList();
+ }
+ return this._events;
+ }
+ function Sys$Net$_WebRequestManager$get_defaultTimeout() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._defaultTimeout;
+ }
+ 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$get_defaultExecutorType() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._defaultExecutorType;
+ }
+ 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$executeRequest(webRequest) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "webRequest", type: Sys.Net.WebRequest}
+ ]);
+ if (e) throw e;
+ var executor = webRequest.get_executor();
+ if (!executor) {
+ var failed = false;
+ try {
+ var executorType = eval(this._defaultExecutorType);
+ executor = new executorType();
+ } catch (e) {
+ failed = true;
+ }
+ if (failed || !Sys.Net.WebRequestExecutor.isInstanceOfType(executor) || !executor) {
+ throw Error.argument("defaultExecutorType", String.format(Sys.Res.invalidExecutorType, this._defaultExecutorType));
+ }
+ webRequest.set_executor(executor);
+ }
+ if (executor.get_aborted()) {
+ return;
+ }
+ var evArgs = new Sys.Net.NetworkRequestEventArgs(webRequest);
+ var handler = this._get_eventHandlerList().getHandler("invokingRequest");
+ if (handler) {
+ handler(this, evArgs);
+ }
+ if (!evArgs.get_cancel()) {
+ executor.executeRequest();
+ }
+ }
+Sys.Net._WebRequestManager.prototype = {
+ add_invokingRequest: Sys$Net$_WebRequestManager$add_invokingRequest,
+ remove_invokingRequest: Sys$Net$_WebRequestManager$remove_invokingRequest,
+ add_completedRequest: Sys$Net$_WebRequestManager$add_completedRequest,
+ remove_completedRequest: Sys$Net$_WebRequestManager$remove_completedRequest,
+ _get_eventHandlerList: Sys$Net$_WebRequestManager$_get_eventHandlerList,
+ get_defaultTimeout: Sys$Net$_WebRequestManager$get_defaultTimeout,
+ set_defaultTimeout: Sys$Net$_WebRequestManager$set_defaultTimeout,
+ get_defaultExecutorType: Sys$Net$_WebRequestManager$get_defaultExecutorType,
+ set_defaultExecutorType: Sys$Net$_WebRequestManager$set_defaultExecutorType,
+ executeRequest: Sys$Net$_WebRequestManager$executeRequest
+}
+Sys.Net._WebRequestManager.registerClass('Sys.Net._WebRequestManager');
+Sys.Net.WebRequestManager = new Sys.Net._WebRequestManager();
+
+Sys.Net.NetworkRequestEventArgs = function Sys$Net$NetworkRequestEventArgs(webRequest) {
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "webRequest", type: Sys.Net.WebRequest}
+ ]);
+ if (e) throw e;
+ Sys.Net.NetworkRequestEventArgs.initializeBase(this);
+ this._webRequest = webRequest;
+}
+ function Sys$Net$NetworkRequestEventArgs$get_webRequest() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._webRequest;
+ }
+Sys.Net.NetworkRequestEventArgs.prototype = {
+ get_webRequest: Sys$Net$NetworkRequestEventArgs$get_webRequest
+}
+Sys.Net.NetworkRequestEventArgs.registerClass('Sys.Net.NetworkRequestEventArgs', Sys.CancelEventArgs);
+
+Sys.Net.WebRequest = function Sys$Net$WebRequest() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ this._url = "";
+ this._headers = { };
+ this._body = null;
+ this._userContext = null;
+ this._httpVerb = null;
+ this._executor = null;
+ this._invokeCalled = false;
+ this._timeout = 0;
+}
+ function Sys$Net$WebRequest$add_completed(handler) {
+ ///
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().addHandler("completed", handler);
+ }
+ function Sys$Net$WebRequest$remove_completed(handler) {
+ var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);
+ if (e) throw e;
+ this._get_eventHandlerList().removeHandler("completed", handler);
+ }
+ function Sys$Net$WebRequest$completed(eventArgs) {
+ ///
+ ///
+ 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$Net$WebRequest$_get_eventHandlerList() {
+ if (!this._events) {
+ this._events = new Sys.EventHandlerList();
+ }
+ return this._events;
+ }
+ function Sys$Net$WebRequest$get_url() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._url;
+ }
+ function Sys$Net$WebRequest$set_url(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: String}]);
+ if (e) throw e;
+ this._url = value;
+ }
+ function Sys$Net$WebRequest$get_headers() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._headers;
+ }
+ function Sys$Net$WebRequest$get_httpVerb() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this._httpVerb === null) {
+ if (this._body === null) {
+ return "GET";
+ }
+ return "POST";
+ }
+ return this._httpVerb;
+ }
+ function Sys$Net$WebRequest$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$Net$WebRequest$get_body() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._body;
+ }
+ function Sys$Net$WebRequest$set_body(value) {
+ var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
+ if (e) throw e;
+ this._body = value;
+ }
+ function Sys$Net$WebRequest$get_userContext() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._userContext;
+ }
+ function Sys$Net$WebRequest$set_userContext(value) {
+ var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
+ if (e) throw e;
+ this._userContext = value;
+ }
+ function Sys$Net$WebRequest$get_executor() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._executor;
+ }
+ function Sys$Net$WebRequest$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$Net$WebRequest$get_timeout() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this._timeout === 0) {
+ return Sys.Net.WebRequestManager.get_defaultTimeout();
+ }
+ return this._timeout;
+ }
+ function Sys$Net$WebRequest$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$Net$WebRequest$getResolvedUrl() {
+ ///
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return Sys.Net.WebRequest._resolveUrl(this._url);
+ }
+ function 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$Net$WebRequest$add_completed,
+ remove_completed: Sys$Net$WebRequest$remove_completed,
+ completed: Sys$Net$WebRequest$completed,
+ _get_eventHandlerList: Sys$Net$WebRequest$_get_eventHandlerList,
+ get_url: Sys$Net$WebRequest$get_url,
+ set_url: Sys$Net$WebRequest$set_url,
+ get_headers: Sys$Net$WebRequest$get_headers,
+ get_httpVerb: Sys$Net$WebRequest$get_httpVerb,
+ set_httpVerb: Sys$Net$WebRequest$set_httpVerb,
+ get_body: Sys$Net$WebRequest$get_body,
+ set_body: Sys$Net$WebRequest$set_body,
+ get_userContext: Sys$Net$WebRequest$get_userContext,
+ set_userContext: Sys$Net$WebRequest$set_userContext,
+ get_executor: Sys$Net$WebRequest$get_executor,
+ set_executor: Sys$Net$WebRequest$set_executor,
+ get_timeout: Sys$Net$WebRequest$get_timeout,
+ set_timeout: Sys$Net$WebRequest$set_timeout,
+ getResolvedUrl: Sys$Net$WebRequest$getResolvedUrl,
+ invoke: Sys$Net$WebRequest$invoke
+}
+Sys.Net.WebRequest._resolveUrl = function Sys$Net$WebRequest$_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$Net$WebRequest$_createQueryString(queryString, encodeMethod, addParams) {
+ encodeMethod = encodeMethod || encodeURIComponent;
+ var i = 0, obj, val, arg, sb = new Sys.StringBuilder();
+ if (queryString) {
+ for (arg in queryString) {
+ obj = queryString[arg];
+ if (typeof(obj) === "function") continue;
+ val = Sys.Serialization.JavaScriptSerializer.serialize(obj);
+ if (i++) {
+ sb.append('&');
+ }
+ sb.append(arg);
+ sb.append('=');
+ sb.append(encodeMethod(val));
+ }
+ }
+ if (addParams) {
+ if (i) {
+ sb.append('&');
+ }
+ sb.append(addParams);
+ }
+ return sb.toString();
+}
+Sys.Net.WebRequest._createUrl = function Sys$Net$WebRequest$_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(scriptElement, completedCallback) {
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "scriptElement", domElement: true},
+ {name: "completedCallback", type: Function}
+ ]);
+ if (e) throw e;
+ this._scriptElement = scriptElement;
+ this._completedCallback = completedCallback;
+}
+ function Sys$_ScriptLoaderTask$get_scriptElement() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._scriptElement;
+ }
+ function Sys$_ScriptLoaderTask$dispose() {
+ if(this._disposed) {
+ return;
+ }
+ this._disposed = true;
+ this._removeScriptElementHandlers();
+ Sys._ScriptLoaderTask._clearScript(this._scriptElement);
+ this._scriptElement = null;
+ }
+ function Sys$_ScriptLoaderTask$execute() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ if (this._ensureReadyStateLoaded()) {
+ this._executeInternal();
+ }
+ }
+ function Sys$_ScriptLoaderTask$_executeInternal() {
+ this._addScriptElementHandlers();
+ var headElements = document.getElementsByTagName('head');
+ if (headElements.length === 0) {
+ throw new Error.invalidOperation(Sys.Res.scriptLoadFailedNoHead);
+ }
+ else {
+ headElements[0].appendChild(this._scriptElement);
+ }
+ }
+ function Sys$_ScriptLoaderTask$_ensureReadyStateLoaded() {
+ if (this._useReadyState() && this._scriptElement.readyState !== 'loaded' && this._scriptElement.readyState !== 'complete') {
+ this._scriptDownloadDelegate = Function.createDelegate(this, this._executeInternal);
+ $addHandler(this._scriptElement, 'readystatechange', this._scriptDownloadDelegate);
+ return false;
+ }
+ return true;
+ }
+ function Sys$_ScriptLoaderTask$_addScriptElementHandlers() {
+ if (this._scriptDownloadDelegate) {
+ $removeHandler(this._scriptElement, 'readystatechange', this._scriptDownloadDelegate);
+ this._scriptDownloadDelegate = null;
+ }
+ this._scriptLoadDelegate = Function.createDelegate(this, this._scriptLoadHandler);
+ if (this._useReadyState()) {
+ $addHandler(this._scriptElement, 'readystatechange', this._scriptLoadDelegate);
+ } else {
+ $addHandler(this._scriptElement, 'load', this._scriptLoadDelegate);
+ }
+ if (this._scriptElement.addEventListener) {
+ this._scriptErrorDelegate = Function.createDelegate(this, this._scriptErrorHandler);
+ this._scriptElement.addEventListener('error', this._scriptErrorDelegate, false);
+ }
+ }
+ function Sys$_ScriptLoaderTask$_removeScriptElementHandlers() {
+ if(this._scriptLoadDelegate) {
+ var scriptElement = this.get_scriptElement();
+ if (this._scriptDownloadDelegate) {
+ $removeHandler(this._scriptElement, 'readystatechange', this._scriptDownloadDelegate);
+ this._scriptDownloadDelegate = null;
+ }
+ if (this._useReadyState() && this._scriptLoadDelegate) {
+ $removeHandler(scriptElement, 'readystatechange', this._scriptLoadDelegate);
+ }
+ else {
+ $removeHandler(scriptElement, 'load', this._scriptLoadDelegate);
+ }
+ if (this._scriptErrorDelegate) {
+ this._scriptElement.removeEventListener('error', this._scriptErrorDelegate, false);
+ this._scriptErrorDelegate = null;
+ }
+ this._scriptLoadDelegate = null;
+ }
+ }
+ function Sys$_ScriptLoaderTask$_scriptErrorHandler() {
+ if(this._disposed) {
+ return;
+ }
+
+ this._completedCallback(this.get_scriptElement(), false);
+ }
+ function Sys$_ScriptLoaderTask$_scriptLoadHandler() {
+ if(this._disposed) {
+ return;
+ }
+ var scriptElement = this.get_scriptElement();
+ if (this._useReadyState() && scriptElement.readyState !== 'complete') {
+ return;
+ }
+ this._completedCallback(scriptElement, true);
+ }
+ function Sys$_ScriptLoaderTask$_useReadyState() {
+ return (Sys.Browser.agent === Sys.Browser.InternetExplorer && (Sys.Browser.version < 9 || ((document.documentMode || 0) < 9)));
+ }
+Sys._ScriptLoaderTask.prototype = {
+ get_scriptElement: Sys$_ScriptLoaderTask$get_scriptElement,
+ dispose: Sys$_ScriptLoaderTask$dispose,
+ execute: Sys$_ScriptLoaderTask$execute,
+ _executeInternal: Sys$_ScriptLoaderTask$_executeInternal,
+ _ensureReadyStateLoaded: Sys$_ScriptLoaderTask$_ensureReadyStateLoaded,
+ _addScriptElementHandlers: Sys$_ScriptLoaderTask$_addScriptElementHandlers,
+ _removeScriptElementHandlers: Sys$_ScriptLoaderTask$_removeScriptElementHandlers,
+ _scriptErrorHandler: Sys$_ScriptLoaderTask$_scriptErrorHandler,
+ _scriptLoadHandler: Sys$_ScriptLoaderTask$_scriptLoadHandler,
+ _useReadyState: Sys$_ScriptLoaderTask$_useReadyState
+}
+Sys._ScriptLoaderTask.registerClass("Sys._ScriptLoaderTask", null, Sys.IDisposable);
+Sys._ScriptLoaderTask._clearScript = function Sys$_ScriptLoaderTask$_clearScript(scriptElement) {
+ if (!Sys.Debug.isDebug && scriptElement.parentNode) {
+ scriptElement.parentNode.removeChild(scriptElement);
+ }
+}
+Type.registerNamespace('Sys.Net');
+
+Sys.Net.WebServiceProxy = function Sys$Net$WebServiceProxy() {
+}
+ function Sys$Net$WebServiceProxy$get_timeout() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._timeout || 0;
+ }
+ function Sys$Net$WebServiceProxy$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$Net$WebServiceProxy$get_defaultUserContext() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return (typeof(this._userContext) === "undefined") ? null : this._userContext;
+ }
+ function Sys$Net$WebServiceProxy$set_defaultUserContext(value) {
+ var e = Function._validateParams(arguments, [{name: "value", mayBeNull: true}]);
+ if (e) throw e;
+ this._userContext = value;
+ }
+ function Sys$Net$WebServiceProxy$get_defaultSucceededCallback() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._succeeded || null;
+ }
+ function Sys$Net$WebServiceProxy$set_defaultSucceededCallback(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);
+ if (e) throw e;
+ this._succeeded = value;
+ }
+ function Sys$Net$WebServiceProxy$get_defaultFailedCallback() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._failed || null;
+ }
+ function Sys$Net$WebServiceProxy$set_defaultFailedCallback(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Function, mayBeNull: true}]);
+ if (e) throw e;
+ this._failed = value;
+ }
+ function Sys$Net$WebServiceProxy$get_enableJsonp() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return !!this._jsonp;
+ }
+ function Sys$Net$WebServiceProxy$set_enableJsonp(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);
+ if (e) throw e;
+ this._jsonp = value;
+ }
+ function Sys$Net$WebServiceProxy$get_path() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._path || null;
+ }
+ function Sys$Net$WebServiceProxy$set_path(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: String}]);
+ if (e) throw e;
+ this._path = value;
+ }
+ function Sys$Net$WebServiceProxy$get_jsonpCallbackParameter() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._callbackParameter || "callback";
+ }
+ function Sys$Net$WebServiceProxy$set_jsonpCallbackParameter(value) {
+ var e = Function._validateParams(arguments, [{name: "value", type: String}]);
+ if (e) throw e;
+ this._callbackParameter = value;
+ }
+ function Sys$Net$WebServiceProxy$_invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ 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$Net$WebServiceProxy$get_timeout,
+ set_timeout: Sys$Net$WebServiceProxy$set_timeout,
+ get_defaultUserContext: Sys$Net$WebServiceProxy$get_defaultUserContext,
+ set_defaultUserContext: Sys$Net$WebServiceProxy$set_defaultUserContext,
+ get_defaultSucceededCallback: Sys$Net$WebServiceProxy$get_defaultSucceededCallback,
+ set_defaultSucceededCallback: Sys$Net$WebServiceProxy$set_defaultSucceededCallback,
+ get_defaultFailedCallback: Sys$Net$WebServiceProxy$get_defaultFailedCallback,
+ set_defaultFailedCallback: Sys$Net$WebServiceProxy$set_defaultFailedCallback,
+ get_enableJsonp: Sys$Net$WebServiceProxy$get_enableJsonp,
+ set_enableJsonp: Sys$Net$WebServiceProxy$set_enableJsonp,
+ get_path: Sys$Net$WebServiceProxy$get_path,
+ set_path: Sys$Net$WebServiceProxy$set_path,
+ get_jsonpCallbackParameter: Sys$Net$WebServiceProxy$get_jsonpCallbackParameter,
+ set_jsonpCallbackParameter: Sys$Net$WebServiceProxy$set_jsonpCallbackParameter,
+ _invoke: Sys$Net$WebServiceProxy$_invoke
+}
+Sys.Net.WebServiceProxy.registerClass('Sys.Net.WebServiceProxy');
+Sys.Net.WebServiceProxy.invoke = function Sys$Net$WebServiceProxy$invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext, timeout, enableJsonp, jsonpCallbackParameter) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ 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$Net$WebServiceProxy$_createFailedError(methodName, errorMessage) {
+ var displayMessage = "Sys.Net.WebServiceFailedException: " + errorMessage;
+ var e = Error.create(displayMessage, { 'name': 'Sys.Net.WebServiceFailedException', 'methodName': methodName });
+ e.popStackFrame();
+ return e;
+}
+Sys.Net.WebServiceProxy._defaultFailedCallback = function Sys$Net$WebServiceProxy$_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$Net$WebServiceProxy$_generateTypedConstructor(type) {
+ return function(properties) {
+ if (properties) {
+ for (var name in properties) {
+ this[name] = properties[name];
+ }
+ }
+ this.__type = type;
+ }
+}
+Sys._jsonp = 0;
+Sys.Net.WebServiceProxy._xdomain = /^\s*([a-zA-Z0-9\+\-\.]+\:)\/\/([^?#\/]+)/;
+
+Sys.Net.WebServiceError = function Sys$Net$WebServiceError(timedOut, message, stackTrace, exceptionType, errorObject) {
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ var e = Function._validateParams(arguments, [
+ {name: "timedOut", type: Boolean},
+ {name: "message", type: String, mayBeNull: true},
+ {name: "stackTrace", type: String, mayBeNull: true, optional: true},
+ {name: "exceptionType", type: String, mayBeNull: true, optional: true},
+ {name: "errorObject", type: Object, mayBeNull: true, optional: true}
+ ]);
+ if (e) throw e;
+ this._timedOut = timedOut;
+ this._message = message;
+ this._stackTrace = stackTrace;
+ this._exceptionType = exceptionType;
+ this._errorObject = errorObject;
+ this._statusCode = -1;
+}
+ function Sys$Net$WebServiceError$get_timedOut() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._timedOut;
+ }
+ function Sys$Net$WebServiceError$get_statusCode() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._statusCode;
+ }
+ function Sys$Net$WebServiceError$get_message() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._message;
+ }
+ function Sys$Net$WebServiceError$get_stackTrace() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._stackTrace || "";
+ }
+ function Sys$Net$WebServiceError$get_exceptionType() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._exceptionType || "";
+ }
+ function Sys$Net$WebServiceError$get_errorObject() {
+ ///
+ if (arguments.length !== 0) throw Error.parameterCount();
+ return this._errorObject || null;
+ }
+Sys.Net.WebServiceError.prototype = {
+ get_timedOut: Sys$Net$WebServiceError$get_timedOut,
+ get_statusCode: Sys$Net$WebServiceError$get_statusCode,
+ get_message: Sys$Net$WebServiceError$get_message,
+ get_stackTrace: Sys$Net$WebServiceError$get_stackTrace,
+ get_exceptionType: Sys$Net$WebServiceError$get_exceptionType,
+ get_errorObject: Sys$Net$WebServiceError$get_errorObject
+}
+Sys.Net.WebServiceError.registerClass('Sys.Net.WebServiceError');
+
+
+Type.registerNamespace('Sys');
+Sys.Res={
+"argumentInteger":"Value must be an integer.",
+"invokeCalledTwice":"Cannot call invoke more than once.",
+"webServiceFailed":"The server method \u0027{0}\u0027 failed with the following error: {1}",
+"argumentType":"Object cannot be converted to the required type.",
+"argumentNull":"Value cannot be null.",
+"scriptAlreadyLoaded":"The script \u0027{0}\u0027 has been referenced multiple times. If referencing Microsoft AJAX scripts explicitly, set the MicrosoftAjaxMode property of the ScriptManager to Explicit.",
+"scriptDependencyNotFound":"The script \u0027{0}\u0027 failed to load because it is dependent on script \u0027{1}\u0027.",
+"formatBadFormatSpecifier":"Format specifier was invalid.",
+"requiredScriptReferenceNotIncluded":"\u0027{0}\u0027 requires that you have included a script reference to \u0027{1}\u0027.",
+"webServiceFailedNoMsg":"The server method \u0027{0}\u0027 failed.",
+"argumentDomElement":"Value must be a DOM element.",
+"invalidExecutorType":"Could not create a valid Sys.Net.WebRequestExecutor from: {0}.",
+"cannotCallBeforeResponse":"Cannot call {0} when responseAvailable is false.",
+"actualValue":"Actual value was {0}.",
+"enumInvalidValue":"\u0027{0}\u0027 is not a valid value for enum {1}.",
+"scriptLoadFailed":"The script \u0027{0}\u0027 could not be loaded.",
+"parameterCount":"Parameter count mismatch.",
+"cannotDeserializeEmptyString":"Cannot deserialize empty string.",
+"formatInvalidString":"Input string was not in a correct format.",
+"invalidTimeout":"Value must be greater than or equal to zero.",
+"cannotAbortBeforeStart":"Cannot abort when executor has not started.",
+"argument":"Value does not fall within the expected range.",
+"cannotDeserializeInvalidJson":"Cannot deserialize. The data does not correspond to valid JSON.",
+"invalidHttpVerb":"httpVerb cannot be set to an empty or null string.",
+"nullWebRequest":"Cannot call executeRequest with a null webRequest.",
+"eventHandlerInvalid":"Handler was not added through the Sys.UI.DomEvent.addHandler method.",
+"cannotSerializeNonFiniteNumbers":"Cannot serialize non finite numbers.",
+"argumentUndefined":"Value cannot be undefined.",
+"webServiceInvalidReturnType":"The server method \u0027{0}\u0027 returned an invalid type. Expected type: {1}",
+"servicePathNotSet":"The path to the web service has not been set.",
+"argumentTypeWithTypes":"Object of type \u0027{0}\u0027 cannot be converted to type \u0027{1}\u0027.",
+"cannotCallOnceStarted":"Cannot call {0} once started.",
+"badBaseUrl1":"Base URL does not contain ://.",
+"badBaseUrl2":"Base URL does not contain another /.",
+"badBaseUrl3":"Cannot find last / in base URL.",
+"setExecutorAfterActive":"Cannot set executor after it has become active.",
+"paramName":"Parameter name: {0}",
+"nullReferenceInPath":"Null reference while evaluating data path: \u0027{0}\u0027.",
+"cannotCallOutsideHandler":"Cannot call {0} outside of a completed event handler.",
+"cannotSerializeObjectWithCycle":"Cannot serialize object with cyclic reference within child properties.",
+"format":"One of the identified items was in an invalid format.",
+"assertFailedCaller":"Assertion Failed: {0}\r\nat {1}",
+"argumentOutOfRange":"Specified argument was out of the range of valid values.",
+"webServiceTimedOut":"The server method \u0027{0}\u0027 timed out.",
+"notImplemented":"The method or operation is not implemented.",
+"assertFailed":"Assertion Failed: {0}",
+"invalidOperation":"Operation is not valid due to the current state of the object.",
+"breakIntoDebugger":"{0}\r\n\r\nBreak into debugger?",
+"argumentTypeName":"Value is not the name of an existing type.",
+"cantBeCalledAfterDispose":"Can\u0027t be called after dispose.",
+"componentCantSetIdAfterAddedToApp":"The id property of a component can\u0027t be set after it\u0027s been added to the Application object.",
+"behaviorDuplicateName":"A behavior with name \u0027{0}\u0027 already exists or it is the name of an existing property on the target element.",
+"notATypeName":"Value is not a valid type name.",
+"elementNotFound":"An element with id \u0027{0}\u0027 could not be found.",
+"stateMustBeStringDictionary":"The state object can only have null and string fields.",
+"boolTrueOrFalse":"Value must be \u0027true\u0027 or \u0027false\u0027.",
+"scriptLoadFailedNoHead":"ScriptLoader requires pages to contain a \u003chead\u003e element.",
+"stringFormatInvalid":"The format string is invalid.",
+"referenceNotFound":"Component \u0027{0}\u0027 was not found.",
+"enumReservedName":"\u0027{0}\u0027 is a reserved name that can\u0027t be used as an enum value name.",
+"circularParentChain":"The chain of control parents can\u0027t have circular references.",
+"namespaceContainsNonObject":"Object {0} already exists and is not an object.",
+"undefinedEvent":"\u0027{0}\u0027 is not an event.",
+"propertyUndefined":"\u0027{0}\u0027 is not a property or an existing field.",
+"observableConflict":"Object already contains a member with the name \u0027{0}\u0027.",
+"historyCannotEnableHistory":"Cannot set enableHistory after initialization.",
+"scriptLoadFailedDebug":"The script \u0027{0}\u0027 failed to load. Check for:\r\n Inaccessible path.\r\n Script errors. (IE) Enable \u0027Display a notification about every script error\u0027 under advanced settings.",
+"propertyNotWritable":"\u0027{0}\u0027 is not a writable property.",
+"enumInvalidValueName":"\u0027{0}\u0027 is not a valid name for an enum value.",
+"controlAlreadyDefined":"A control is already associated with the element.",
+"addHandlerCantBeUsedForError":"Can\u0027t add a handler for the error event using this method. Please set the window.onerror property instead.",
+"cantAddNonFunctionhandler":"Can\u0027t add a handler that is not a function.",
+"invalidNameSpace":"Value is not a valid namespace identifier.",
+"notAnInterface":"Value is not a valid interface.",
+"eventHandlerNotFunction":"Handler must be a function.",
+"propertyNotAnArray":"\u0027{0}\u0027 is not an Array property.",
+"namespaceContainsClass":"Object {0} already exists as a class, enum, or interface.",
+"typeRegisteredTwice":"Type {0} has already been registered. The type may be defined multiple times or the script file that defines it may have already been loaded. A possible cause is a change of settings during a partial update.",
+"cantSetNameAfterInit":"The name property can\u0027t be set on this object after initialization.",
+"historyMissingFrame":"For the history feature to work in IE, the page must have an iFrame element with id \u0027__historyFrame\u0027 pointed to a page that gets its title from the \u0027title\u0027 query string parameter and calls Sys.Application._onIFrameLoad() on the parent window. This can be done by setting EnableHistory to true on ScriptManager.",
+"appDuplicateComponent":"Two components with the same id \u0027{0}\u0027 can\u0027t be added to the application.",
+"historyCannotAddHistoryPointWithHistoryDisabled":"A history point can only be added if enableHistory is set to true.",
+"baseNotAClass":"Value is not a class.",
+"expectedElementOrId":"Value must be a DOM element or DOM element Id.",
+"methodNotFound":"No method found with name \u0027{0}\u0027.",
+"arrayParseBadFormat":"Value must be a valid string representation for an array. It must start with a \u0027[\u0027 and end with a \u0027]\u0027.",
+"stateFieldNameInvalid":"State field names must not contain any \u0027=\u0027 characters.",
+"cantSetId":"The id property can\u0027t be set on this object.",
+"stringFormatBraceMismatch":"The format string contains an unmatched opening or closing brace.",
+"enumValueNotInteger":"An enumeration definition can only contain integer values.",
+"propertyNullOrUndefined":"Cannot set the properties of \u0027{0}\u0027 because it returned a null value.",
+"argumentDomNode":"Value must be a DOM element or a text node.",
+"componentCantSetIdTwice":"The id property of a component can\u0027t be set more than once.",
+"createComponentOnDom":"Value must be null for Components that are not Controls or Behaviors.",
+"createNotComponent":"{0} does not derive from Sys.Component.",
+"createNoDom":"Value must not be null for Controls and Behaviors.",
+"cantAddWithoutId":"Can\u0027t add a component that doesn\u0027t have an id.",
+"urlTooLong":"The history state must be small enough to not make the url larger than {0} characters.",
+"notObservable":"Instances of type \u0027{0}\u0027 cannot be observed.",
+"badTypeName":"Value is not the name of the type being registered or the name is a reserved word."
+};
diff --git a/niayesh/SearchSkinObjectPreview.css b/niayesh/SearchSkinObjectPreview.css
new file mode 100644
index 0000000..7ae2c94
--- /dev/null
+++ b/niayesh/SearchSkinObjectPreview.css
@@ -0,0 +1,38 @@
+.searchInputContainer { display: inline-block; margin: 0 -3px 0 0; position: relative; }
+
+ .searchInputContainer > input[type="text"]::-ms-clear { display: none; }
+
+ .searchInputContainer a.dnnSearchBoxClearText { display: block; position: absolute; right: 10px; width: 16px; height: 16px; background: none; cursor: pointer; margin: 7px 0 7px 0; z-index: 20; }
+
+ .searchInputContainer a.dnnSearchBoxClearText.dnnShow { background: url(../../../images/search/clearText.png) center center no-repeat; }
+
+ul.searchSkinObjectPreview { position: absolute; top: 100%; right: 0; background: #fff; margin: 0; list-style: none; border: 1px solid #c9c9c9; width: 350px; z-index: 200; padding: 0; }
+
+ ul.searchSkinObjectPreview li { list-style: none; }
+
+ ul.searchSkinObjectPreview > li { padding: 6px 12px 6px 22px; border-top: 1px solid #c9c9c9; color: #666; cursor: pointer; position: relative; margin: 0; text-transform: none; }
+
+ ul.searchSkinObjectPreview > li:hover { background-color: #e8f1fa; color: #333; }
+
+ ul.searchSkinObjectPreview > li > span { }
+
+ ul.searchSkinObjectPreview > li > span img.userpic { width: 32px; height: 32px; display: block; float: left; margin-right: 4px; }
+
+ ul.searchSkinObjectPreview > li > span > b { font-weight: bold; color: #000; }
+
+ ul.searchSkinObjectPreview > li p { margin: 0; font-size: 10px; line-height: 1.2em; color: #999; font-style: italic; white-space: normal; }
+
+ ul.searchSkinObjectPreview > li p b { color: #000; }
+
+ ul.searchSkinObjectPreview > li.searchSkinObjectPreview_group { padding: 6px 12px 6px 12px; font-weight: bold; color: #000; border-bottom: 2px solid #000; cursor: inherit; }
+
+ ul.searchSkinObjectPreview > li.searchSkinObjectPreview_group:hover { background-color: #fff; color: #000; }
+
+ ul.searchSkinObjectPreview > li > a.searchSkinObjectPreview_more { display: inline; position: static; background: none; z-index: inherit; width: auto; height: auto; text-indent: inherit; float: none; }
+/*dnnplus.ir 2017 */
+.rtl .searchInputContainer { display: inline-block; margin: 0 0 0 -3px; position: relative; }
+ .rtl .searchInputContainer a.dnnSearchBoxClearText { display: block; position: absolute; right: auto; left: 10px; width: 16px; height: 16px; background: none; cursor: pointer; margin: 7px 0 7px 0; z-index: 20; }
+ .rtl .searchInputContainer a.dnnSearchBoxClearText.dnnShow { background: url(../../../images/search/clearText.png) center center no-repeat; }
+ .rtl ul.searchSkinObjectPreview { position: absolute; top: 100%; right: auto; left: 0; background: #fff; margin: 0; list-style: none; border: 1px solid #c9c9c9; width: 350px; z-index: 200; padding: 0; }
+ .rtl ul.searchSkinObjectPreview > li { padding: 6px 22px 6px 12px; border-top: 1px solid #c9c9c9; color: #666; cursor: pointer; position: relative; margin: 0; text-transform: none; }
+ .rtl ul.searchSkinObjectPreview > li > span img.userpic { width: 32px; height: 32px; display: block; float: right; margin-left: 4px; }
\ No newline at end of file
diff --git a/niayesh/SearchSkinObjectPreview.js.download b/niayesh/SearchSkinObjectPreview.js.download
new file mode 100644
index 0000000..f69d798
--- /dev/null
+++ b/niayesh/SearchSkinObjectPreview.js.download
@@ -0,0 +1,189 @@
+(function ($) {
+ if (typeof dnn == 'undefined') window.dnn = {};
+ if (typeof dnn.searchSkinObject == 'undefined') {
+ dnn.searchSkinObject = function (options) {
+ var settings = {
+ delayTriggerAutoSearch: 100,
+ minCharRequiredTriggerAutoSearch: 2,
+ searchType: 'S',
+ enableWildSearch: true,
+ cultureCode: 'en-US'
+ };
+ this.settings = $.extend({}, settings, options);
+ };
+ dnn.searchSkinObject.prototype = {
+ _ignoreKeyCodes: [9, 13, 16, 17, 18, 19, 20, 27, 33, 34, 35, 36, 37, 38, 39, 40, 45],
+ init: function () {
+ var throttle = null, self = this;
+ var makeUrl = function (val, service) {
+ var url = service ? service.getServiceRoot('internalservices') + 'searchService/preview' : null;
+ if (!url) return null;
+ var params = {};
+ params['keywords'] = val.replace(/^\s+|\s+$/g, '');
+ if (!self.settings.enableWildSearch) params["forceWild"] = "0";
+ params['culture'] = self.settings.cultureCode;
+ if (self.settings.portalId >= 0)
+ params['portal'] = self.settings.portalId;
+ var urlAppend = [];
+ $.each(params, function (index, value) {
+ urlAppend.push([index, encodeURIComponent(value)].join('='));
+ });
+
+ if (urlAppend.length) {
+ url += url.indexOf('?') === -1 ? '?' : '&';
+ url += urlAppend.join('&');
+ }
+ return url;
+ };
+
+ var generatePreviewTemplate = function (data, $wrap) {
+ var preview = $('.searchSkinObjectPreview', $wrap);
+ if (preview.length)
+ preview.remove();
+
+ var markup = '
';
+ if (data && data.length) {
+ for (var i = 0; i < data.length; i++) {
+ var group = data[i];
+ if (group.Results && group.Results.length) {
+ var groupTitle = group.DocumentTypeName;
+ markup += '
' + groupTitle + '
';
+ for (var j = 0; j < group.Results.length; j++) {
+ var item = group.Results[j];
+ var itemTitle = item.Title;
+ var itemUrl = item.DocumentUrl;
+ var itemSnippet = item.Snippet;
+ markup += '