PageRenderTime 63ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 1ms

/src/Samples/Xmlt.Sample/Scripts/embed/MicrosoftAjaxWebForms.debug.js

#
JavaScript | 2130 lines | 1812 code | 247 blank | 71 comment | 373 complexity | 78a92650b654e37c04b37e5699db3c46 MD5 | raw file
    

  1. // (c) 2010 CodePlex Foundation

    2. 

  2. (function() {

    3. 

  3. 

    4. 

  4. function execute() {

    5. 

  5. 

    6. 

  6. Type._registerScript("MicrosoftAjaxWebForms.js", [

    7. 

  7. 	"MicrosoftAjaxCore.js",

    8. 

  8. 	"MicrosoftAjaxSerialization.js",

    9. 

  9. 	"MicrosoftAjaxNetwork.js",

    10. 

  10. 	"MicrosoftAjaxComponentModel.js"]);

    11. 

  11. var $type, $prototype;

    12. 

  12. Type.registerNamespace('Sys.WebForms');

    13. 

  13. 

    14. 

  14. $type = Sys.WebForms.BeginRequestEventArgs = function BeginRequestEventArgs(request, postBackElement, updatePanelsToUpdate) {

    15. 

  15.     /// <summary locid="M:J#Sys.WebForms.BeginRequestEventArgs.#ctor">The arguments for the PageRequestManager's beginRequest event. The beginRequest event is raised when a request is about to be made.</summary>

    16. 

  16.     /// <param name="request" type="Sys.Net.WebRequest">The web request for the EventArgs.</param>

    17. 

  17.     /// <param name="postBackElement" domElement="true" mayBeNull="true">The postback element that initiated the async postback.</param>

    18. 

  18.     /// <param name="updatePanelsToUpdate" type="Array" elementType="String" mayBeNull="true" optional="true">A list of UniqueIDs for UpdatePanel controls that are requested to update their rendering by the client. Server-side processing may update additional UpdatePanels.</param>

    19. 

  19.     var e = Function._validateParams(arguments, [

    20. 

  20.         {name: "request", type: Sys.Net.WebRequest},

    21. 

  21.         {name: "postBackElement", mayBeNull: true, domElement: true},

    22. 

  22.         {name: "updatePanelsToUpdate", type: Array, mayBeNull: true, optional: true, elementType: String}

    23. 

  23.     ]);

    24. 

  24.     if (e) throw e;

    25. 

  25.     Sys.WebForms.BeginRequestEventArgs.initializeBase(this);

    26. 

  26.     this._request = request;

    27. 

  27.     this._postBackElement = postBackElement;

    28. 

  28.     this._updatePanelsToUpdate = updatePanelsToUpdate;

    29. 

  29. }

    30. 

  30. 

    31. 

  31. $type.prototype = {

    32. 

  32.     get_postBackElement: function BeginRequestEventArgs$get_postBackElement() {

    33. 

  33.         /// <value domElement="true" mayBeNull="true" locid="P:J#Sys.WebForms.BeginRequestEventArgs.postBackElement"></value>

    34. 

  34.         if (arguments.length !== 0) throw Error.parameterCount();

    35. 

  35.         return this._postBackElement;

    36. 

  36.     },

    37. 

  37.     get_request: function BeginRequestEventArgs$get_request() {

    38. 

  38.         /// <value type="Sys.Net.WebRequest" locid="P:J#Sys.WebForms.BeginRequestEventArgs.request"></value>

    39. 

  39.         if (arguments.length !== 0) throw Error.parameterCount();

    40. 

  40.         return this._request;

    41. 

  41.     },

    42. 

  42.     get_updatePanelsToUpdate: function BeginRequestEventArgs$get_updatePanelsToUpdate() {

    43. 

  43.         /// <value type="Array" elementType="String" locid="P:J#Sys.WebForms.BeginRequestEventArgs.updatePanelsToUpdate"></value>

    44. 

  44.         if (arguments.length !== 0) throw Error.parameterCount();

    45. 

  45.         return this._updatePanelsToUpdate ? Array.clone(this._updatePanelsToUpdate) : [];

    46. 

  46.     }

    47. 

  47. }

    48. 

  48. 

    49. 

  49. $type.registerClass('Sys.WebForms.BeginRequestEventArgs', Sys.EventArgs);

    50. 

  50. $type = Sys.WebForms.EndRequestEventArgs = function EndRequestEventArgs(error, dataItems, response) {

    51. 

  51.     /// <summary locid="M:J#Sys.WebForms.EndRequestEventArgs.#ctor">The arguments for the PageRequestManager's endRequest event. The endRequest event is raised when a response has finished processing.</summary>

    52. 

  52.     /// <param name="error" type="Error" mayBeNull="true"></param>

    53. 

  53.     /// <param name="dataItems" type="Object" mayBeNull="true"></param>

    54. 

  54.     /// <param name="response" type="Sys.Net.WebRequestExecutor"></param>

    55. 

  55.     var e = Function._validateParams(arguments, [

    56. 

  56.         {name: "error", type: Error, mayBeNull: true},

    57. 

  57.         {name: "dataItems", type: Object, mayBeNull: true},

    58. 

  58.         {name: "response", type: Sys.Net.WebRequestExecutor}

    59. 

  59.     ]);

    60. 

  60.     if (e) throw e;

    61. 

  61. 

    62. 

  62.     Sys.WebForms.EndRequestEventArgs.initializeBase(this);

    63. 

  63.     this._errorHandled = false;

    64. 

  64.     this._error = error;

    65. 

  65.     this._dataItems = dataItems || new Object();

    66. 

  66.     this._response = response;

    67. 

  67. }

    68. 

  68. 

    69. 

  69. $type.prototype = {

    70. 

  70.     get_dataItems: function EndRequestEventArgs$get_dataItems() {

    71. 

  71.         /// <value type="Object" locid="P:J#Sys.WebForms.EndRequestEventArgs.dataItems"></value>

    72. 

  72.         if (arguments.length !== 0) throw Error.parameterCount();

    73. 

  73.         return this._dataItems;

    74. 

  74.     },

    75. 

  75. 

    76. 

  76.     get_error: function EndRequestEventArgs$get_error() {

    77. 

  77.         /// <value type="Error" locid="P:J#Sys.WebForms.EndRequestEventArgs.error"></value>

    78. 

  78.         if (arguments.length !== 0) throw Error.parameterCount();

    79. 

  79.         return this._error;

    80. 

  80.     },

    81. 

  81. 

    82. 

  82.     get_errorHandled: function EndRequestEventArgs$get_errorHandled() {

    83. 

  83.         /// <value type="Boolean" locid="P:J#Sys.WebForms.EndRequestEventArgs.errorHandled"></value>

    84. 

  84.         if (arguments.length !== 0) throw Error.parameterCount();

    85. 

  85.         return this._errorHandled;

    86. 

  86.     },

    87. 

  87.     set_errorHandled: function EndRequestEventArgs$set_errorHandled(value) {

    88. 

  88.         var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);

    89. 

  89.         if (e) throw e;

    90. 

  90.         this._errorHandled = value;

    91. 

  91.     },

    92. 

  92. 

    93. 

  93.     get_response: function EndRequestEventArgs$get_response() {

    94. 

  94.         /// <value type="Sys.Net.WebRequestExecutor" locid="P:J#Sys.WebForms.EndRequestEventArgs.response"></value>

    95. 

  95.         if (arguments.length !== 0) throw Error.parameterCount();

    96. 

  96.         return this._response;

    97. 

  97.     }

    98. 

  98. }

    99. 

  99. 

    100. 

  100. $type.registerClass('Sys.WebForms.EndRequestEventArgs', Sys.EventArgs);

    101. 

  101. $type = Sys.WebForms.InitializeRequestEventArgs = function InitializeRequestEventArgs(request, postBackElement, updatePanelsToUpdate) {

    102. 

  102.     /// <summary locid="M:J#Sys.WebForms.InitializeRequestEventArgs.#ctor">The arguments for the PageRequestManager's initializeRequest event. The initializeRequest event is raised when a request is being prepared and can be cancelled.</summary>

    103. 

  103.     /// <param name="request" type="Sys.Net.WebRequest">The web request to be packaged in this EventArgs.</param>

    104. 

  104.     /// <param name="postBackElement" domElement="true" mayBeNull="true">The postback element that initiated the async postback.</param>

    105. 

  105.     /// <param name="updatePanelsToUpdate" type="Array" elementType="String" mayBeNull="true" optional="true">A list of UniqueIDs for UpdatePanel controls that are requested to update their rendering by the client. Server-side processing may update additional UpdatePanels.</param>

    106. 

  106.     var e = Function._validateParams(arguments, [

    107. 

  107.         {name: "request", type: Sys.Net.WebRequest},

    108. 

  108.         {name: "postBackElement", mayBeNull: true, domElement: true},

    109. 

  109.         {name: "updatePanelsToUpdate", type: Array, mayBeNull: true, optional: true, elementType: String}

    110. 

  110.     ]);

    111. 

  111.     if (e) throw e;

    112. 

  112.     Sys.WebForms.InitializeRequestEventArgs.initializeBase(this);

    113. 

  113.     this._request = request;

    114. 

  114.     this._postBackElement = postBackElement;

    115. 

  115.     this._updatePanelsToUpdate = updatePanelsToUpdate;

    116. 

  116. }

    117. 

  117. 

    118. 

  118. $type.prototype = {

    119. 

  119.     get_postBackElement: function InitializeRequestEventArgs$get_postBackElement() {

    120. 

  120.         /// <value domElement="true" mayBeNull="true" locid="P:J#Sys.WebForms.InitializeRequestEventArgs.postBackElement"></value>

    121. 

  121.         if (arguments.length !== 0) throw Error.parameterCount();

    122. 

  122.         return this._postBackElement;

    123. 

  123.     },

    124. 

  124.     get_request: function InitializeRequestEventArgs$get_request() {

    125. 

  125.         /// <value type="Sys.Net.WebRequest" locid="P:J#Sys.WebForms.InitializeRequestEventArgs.request"></value>

    126. 

  126.         if (arguments.length !== 0) throw Error.parameterCount();

    127. 

  127.         return this._request;

    128. 

  128.     },

    129. 

  129.     get_updatePanelsToUpdate: function InitializeRequestEventArgs$get_updatePanelsToUpdate() {

    130. 

  130.         /// <value type="Array" elementType="String" locid="P:J#Sys.WebForms.InitializeRequestEventArgs.updatePanelsToUpdate"></value>

    131. 

  131.         if (arguments.length !== 0) throw Error.parameterCount();

    132. 

  132.         return this._updatePanelsToUpdate ? Array.clone(this._updatePanelsToUpdate) : [];

    133. 

  133.     },

    134. 

  134.     set_updatePanelsToUpdate: function InitializeRequestEventArgs$set_updatePanelsToUpdate(value) {

    135. 

  135.         var e = Function._validateParams(arguments, [{name: "value", type: Array, elementType: String}]);

    136. 

  136.         if (e) throw e;

    137. 

  137.         this._updated = true;

    138. 

  138.         this._updatePanelsToUpdate = value;

    139. 

  139.     }

    140. 

  140. }

    141. 

  141. 

    142. 

  142. $type.registerClass('Sys.WebForms.InitializeRequestEventArgs', Sys.CancelEventArgs);

    143. 

  143. $type = Sys.WebForms.PageLoadedEventArgs = function PageLoadedEventArgs(panelsUpdated, panelsCreated, dataItems) {

    144. 

  144.     /// <summary locid="M:J#Sys.WebForms.PageLoadedEventArgs.#ctor">The arguments for the PageRequestManager's pageLoaded event. The pageLoaded event is raised after the DOM has been updated.</summary>

    145. 

  145.     /// <param name="panelsUpdated" type="Array">An array of UpdatePanels that were updated.</param>

    146. 

  146.     /// <param name="panelsCreated" type="Array">An array of UpdatePanels that were created.</param>

    147. 

  147.     /// <param name="dataItems" type="Object" mayBeNull="true"></param>

    148. 

  148.     var e = Function._validateParams(arguments, [

    149. 

  149.         {name: "panelsUpdated", type: Array},

    150. 

  150.         {name: "panelsCreated", type: Array},

    151. 

  151.         {name: "dataItems", type: Object, mayBeNull: true}

    152. 

  152.     ]);

    153. 

  153.     if (e) throw e;

    154. 

  154.     Sys.WebForms.PageLoadedEventArgs.initializeBase(this);

    155. 

  155. 

    156. 

  156.     this._panelsUpdated = panelsUpdated;

    157. 

  157.     this._panelsCreated = panelsCreated;

    158. 

  158.     this._dataItems = dataItems || new Object();

    159. 

  159. }

    160. 

  160. 

    161. 

  161. $type.prototype = {

    162. 

  162.     get_dataItems: function PageLoadedEventArgs$get_dataItems() {

    163. 

  163.         /// <value type="Object" locid="P:J#Sys.WebForms.PageLoadedEventArgs.dataItems"></value>

    164. 

  164.         if (arguments.length !== 0) throw Error.parameterCount();

    165. 

  165.         return this._dataItems;

    166. 

  166.     },

    167. 

  167. 

    168. 

  168.     get_panelsCreated: function PageLoadedEventArgs$get_panelsCreated() {

    169. 

  169.         /// <value type="Array" locid="P:J#Sys.WebForms.PageLoadedEventArgs.panelsCreated"></value>

    170. 

  170.         if (arguments.length !== 0) throw Error.parameterCount();

    171. 

  171.         return this._panelsCreated;

    172. 

  172.     },

    173. 

  173. 

    174. 

  174.     get_panelsUpdated: function PageLoadedEventArgs$get_panelsUpdated() {

    175. 

  175.         /// <value type="Array" locid="P:J#Sys.WebForms.PageLoadedEventArgs.panelsUpdated"></value>

    176. 

  176.         if (arguments.length !== 0) throw Error.parameterCount();

    177. 

  177.         return this._panelsUpdated;

    178. 

  178.     }

    179. 

  179. }

    180. 

  180. 

    181. 

  181. $type.registerClass('Sys.WebForms.PageLoadedEventArgs', Sys.EventArgs);

    182. 

  182. $type = Sys.WebForms.PageLoadingEventArgs = function PageLoadingEventArgs(panelsUpdating, panelsDeleting, dataItems) {

    183. 

  183.     /// <summary locid="M:J#Sys.WebForms.PageLoadingEventArgs.#ctor">The arguments for the PageRequestManager's pageLoading event. The pageLoading event is raised before the DOM has been updated.</summary>

    184. 

  184.     /// <param name="panelsUpdating" type="Array">An array of UpdatePanels that are going to be updated.</param>

    185. 

  185.     /// <param name="panelsDeleting" type="Array">An array of UpdatePanels that are going to be deleted.</param>

    186. 

  186.     /// <param name="dataItems" type="Object" mayBeNull="true"></param>

    187. 

  187.     var e = Function._validateParams(arguments, [

    188. 

  188.         {name: "panelsUpdating", type: Array},

    189. 

  189.         {name: "panelsDeleting", type: Array},

    190. 

  190.         {name: "dataItems", type: Object, mayBeNull: true}

    191. 

  191.     ]);

    192. 

  192.     if (e) throw e;

    193. 

  193.     Sys.WebForms.PageLoadingEventArgs.initializeBase(this);

    194. 

  194. 

    195. 

  195.     this._panelsUpdating = panelsUpdating;

    196. 

  196.     this._panelsDeleting = panelsDeleting;

    197. 

  197.     this._dataItems = dataItems || new Object();

    198. 

  198. }

    199. 

  199. 

    200. 

  200. $type.prototype = {

    201. 

  201.     get_dataItems: function PageLoadingEventArgs$get_dataItems() {

    202. 

  202.         /// <value type="Object" locid="P:J#Sys.WebForms.PageLoadingEventArgs.dataItems"></value>

    203. 

  203.         if (arguments.length !== 0) throw Error.parameterCount();

    204. 

  204.         return this._dataItems;

    205. 

  205.     },

    206. 

  206. 

    207. 

  207.     get_panelsDeleting: function PageLoadingEventArgs$get_panelsDeleting() {

    208. 

  208.         /// <value type="Array" locid="P:J#Sys.WebForms.PageLoadingEventArgs.panelsDeleting"></value>

    209. 

  209.         if (arguments.length !== 0) throw Error.parameterCount();

    210. 

  210.         return this._panelsDeleting;

    211. 

  211.     },

    212. 

  212. 

    213. 

  213.     get_panelsUpdating: function PageLoadingEventArgs$get_panelsUpdating() {

    214. 

  214.         /// <value type="Array" locid="P:J#Sys.WebForms.PageLoadingEventArgs.panelsUpdating"></value>

    215. 

  215.         if (arguments.length !== 0) throw Error.parameterCount();

    216. 

  216.         return this._panelsUpdating;

    217. 

  217.     }

    218. 

  218. }

    219. 

  219. 

    220. 

  220. $type.registerClass('Sys.WebForms.PageLoadingEventArgs', Sys.EventArgs);

    221. 

  221. 

    222. 

  222. $type = Sys._ScriptLoaderTask = function _ScriptLoaderTask(scriptElement, completedCallback) {

    223. 

  223.     /// <summary locid="M:J#Sys._ScriptLoaderTask.#ctor"></summary>

    224. 

  224.     /// <param name="scriptElement" domElement="true">The script element to add to the DOM.</param>

    225. 

  225.     /// <param name="completedCallback" type="Function">Callback to call when the script has loaded or failed to load.</param>

    226. 

  226.     var e = Function._validateParams(arguments, [

    227. 

  227.         {name: "scriptElement", domElement: true},

    228. 

  228.         {name: "completedCallback", type: Function}

    229. 

  229.     ]);

    230. 

  230.     if (e) throw e;

    231. 

  231.     this._scriptElement = scriptElement;

    232. 

  232.     this._completedCallback = completedCallback;

    233. 

  233. }

    234. 

  234. $type.prototype = {

    235. 

  235.     get_scriptElement: function _ScriptLoaderTask$get_scriptElement() {

    236. 

  236.         /// <value domElement="true" locid="P:J#Sys._ScriptLoaderTask.scriptElement">The script element.</value>

    237. 

  237.         if (arguments.length !== 0) throw Error.parameterCount();

    238. 

  238.         return this._scriptElement;

    239. 

  239.     },

    240. 

  240.     

    241. 

  241.     dispose: function _ScriptLoaderTask$dispose() {

    242. 

  242.         if(this._disposed) {

    243. 

  243.             return;

    244. 

  244.         }

    245. 

  245.         this._disposed = true;

    246. 

  246.         this._removeScriptElementHandlers();

    247. 

  247.         Sys._ScriptLoaderTask._clearScript(this._scriptElement);

    248. 

  248.         this._scriptElement = null;

    249. 

  249.     },

    250. 

  250.         

    251. 

  251.     execute: function _ScriptLoaderTask$execute() {

    252. 

  252.         /// <summary locid="M:J#Sys._ScriptLoaderTask.execute">Begins loading the given script element.</summary>

    253. 

  253.         if (arguments.length !== 0) throw Error.parameterCount();

    254. 

  254.         this._addScriptElementHandlers();

    255. 

  255.         var headElements = document.getElementsByTagName('head');

    256. 

  256.         if (headElements.length === 0) {

    257. 

  257.              throw new Error.invalidOperation(Sys.Res.scriptLoadFailedNoHead);

    258. 

  258.         }

    259. 

  259.         else {

    260. 

  260.              headElements[0].appendChild(this._scriptElement);

    261. 

  261.         }

    262. 

  262.     },

    263. 

  263.        

    264. 

  264.     _addScriptElementHandlers: function _ScriptLoaderTask$_addScriptElementHandlers() {

    265. 

  265.         this._scriptLoadDelegate = Function.createDelegate(this, this._scriptLoadHandler);

    266. 

  266.         

    267. 

  267.         if (document.addEventListener) {

    268. 

  268.             this._scriptElement.readyState = 'loaded';

    269. 

  269.             $addHandler(this._scriptElement, 'load', this._scriptLoadDelegate);

    270. 

  270.         }

    271. 

  271.         else {

    272. 

  272.             $addHandler(this._scriptElement, 'readystatechange', this._scriptLoadDelegate);

    273. 

  273.         }    

    274. 

  274.         if (this._scriptElement.addEventListener) {

    275. 

  275.             this._scriptErrorDelegate = Function.createDelegate(this, this._scriptErrorHandler);

    276. 

  276.             this._scriptElement.addEventListener('error', this._scriptErrorDelegate, false);

    277. 

  277.         }

    278. 

  278.     },    

    279. 

  279.     

    280. 

  280.     _removeScriptElementHandlers: function _ScriptLoaderTask$_removeScriptElementHandlers() {

    281. 

  281.         if(this._scriptLoadDelegate) {

    282. 

  282.             var scriptElement = this.get_scriptElement();

    283. 

  283.             if (document.addEventListener) {

    284. 

  284.                 $removeHandler(scriptElement, 'load', this._scriptLoadDelegate);

    285. 

  285.             }

    286. 

  286.             else {

    287. 

  287.                 $removeHandler(scriptElement, 'readystatechange', this._scriptLoadDelegate);

    288. 

  288.             }

    289. 

  289.             if (this._scriptErrorDelegate) {

    290. 

  290.                 this._scriptElement.removeEventListener('error', this._scriptErrorDelegate, false);

    291. 

  291.                 this._scriptErrorDelegate = null;

    292. 

  292.             }

    293. 

  293.             this._scriptLoadDelegate = null;

    294. 

  294.         }

    295. 

  295.     },    

    296. 

  296. 

    297. 

  297.     _scriptErrorHandler: function _ScriptLoaderTask$_scriptErrorHandler() {

    298. 

  298.         if(this._disposed) {

    299. 

  299.             return;

    300. 

  300.         }

    301. 

  301.         

    302. 

  302.         this._completedCallback(this.get_scriptElement(), false);

    303. 

  303.     },

    304. 

  304.            

    305. 

  305.     _scriptLoadHandler: function _ScriptLoaderTask$_scriptLoadHandler() {

    306. 

  306.         if(this._disposed) {

    307. 

  307.             return;

    308. 

  308.         }

    309. 

  309. 

    310. 

  310.         var scriptElement = this.get_scriptElement();

    311. 

  311.         if ((scriptElement.readyState !== 'loaded') &&

    312. 

  312.             (scriptElement.readyState !== 'complete')) {

    313. 

  313.             return;

    314. 

  314.         }

    315. 

  315.         

    316. 

  316.         this._completedCallback(scriptElement, true);

    317. 

  317.     }  

    318. 

  318. }

    319. 

  319. $type.registerClass("Sys._ScriptLoaderTask", null, Sys.IDisposable);

    320. 

  320. 

    321. 

  321. $type._clearScript = function _ScriptLoaderTask$_clearScript(scriptElement) {

    322. 

  322.     if (!Sys.Debug.isDebug) {

    323. 

  323.         scriptElement.parentNode.removeChild(scriptElement);

    324. 

  324.     }

    325. 

  325. }

    326. 

  326. 

    327. 

  327. $type = Sys._ScriptLoader = function _ScriptLoader() {

    328. 

  328.     this._scriptsToLoad = null;

    329. 

  329.     this._sessions = [];

    330. 

  330.     this._scriptLoadedDelegate = Function.createDelegate(this, this._scriptLoadedHandler);

    331. 

  331. }

    332. 

  332. $type.prototype = {

    333. 

  333.     dispose: function _ScriptLoader$dispose() {

    334. 

  334.         this._stopSession();

    335. 

  335.         this._loading = false;

    336. 

  336.         if(this._events) {

    337. 

  337.             delete this._events;

    338. 

  338.         }

    339. 

  339.         this._sessions = null;

    340. 

  340.         this._currentSession = null;

    341. 

  341.         this._scriptLoadedDelegate = null;        

    342. 

  342.     },

    343. 

  343.     

    344. 

  344.     loadScripts: function _ScriptLoader$loadScripts(scriptTimeout, allScriptsLoadedCallback, scriptLoadFailedCallback, scriptLoadTimeoutCallback) {

    345. 

  345.         /// <summary locid="M:J#Sys._ScriptLoader.loadScripts">Begins loading scripts that have been queued.</summary>

    346. 

  346.         /// <param name="scriptTimeout" type="Number" integer="true">Timeout in seconds for loading all scripts.</param>

    347. 

  347.         /// <param name="allScriptsLoadedCallback" type="Function" mayBeNull="true">Callback for notification when all scripts have successfully loaded.</param>

    348. 

  348.         /// <param name="scriptLoadFailedCallback" type="Function" mayBeNull="true">Callback for notification when a script fails to load.</param>

    349. 

  349.         /// <param name="scriptLoadTimeoutCallback" type="Function" mayBeNull="true">Callback for notification when scripts have not finished loading within the given timeout.</param>

    350. 

  350.         var e = Function._validateParams(arguments, [

    351. 

  351.             {name: "scriptTimeout", type: Number, integer: true},

    352. 

  352.             {name: "allScriptsLoadedCallback", type: Function, mayBeNull: true},

    353. 

  353.             {name: "scriptLoadFailedCallback", type: Function, mayBeNull: true},

    354. 

  354.             {name: "scriptLoadTimeoutCallback", type: Function, mayBeNull: true}

    355. 

  355.         ]);

    356. 

  356.         if (e) throw e;

    357. 

  357.         var session = {

    358. 

  358.             allScriptsLoadedCallback: allScriptsLoadedCallback,

    359. 

  359.             scriptLoadFailedCallback: scriptLoadFailedCallback,

    360. 

  360.             scriptLoadTimeoutCallback: scriptLoadTimeoutCallback,

    361. 

  361.             scriptsToLoad: this._scriptsToLoad,

    362. 

  362.             scriptTimeout: scriptTimeout };

    363. 

  363.         this._scriptsToLoad = null;

    364. 

  364.         this._sessions.push(session);

    365. 

  365.         

    366. 

  366.         if (!this._loading) {

    367. 

  367.             this._nextSession();

    368. 

  368.         }

    369. 

  369.     },

    370. 

  370.     

    371. 

  371.     queueCustomScriptTag: function _ScriptLoader$queueCustomScriptTag(scriptAttributes) {

    372. 

  372.         /// <summary locid="M:J#Sys._ScriptLoader.queueCustomScriptTag">Queues a script reference with the given set of custom script element attributes.</summary>

    373. 

  373.         /// <param name="scriptAttributes" mayBeNull="false">A JSON object that describtes the attributes to apply to the script element.</param>

    374. 

  374.         var e = Function._validateParams(arguments, [

    375. 

  375.             {name: "scriptAttributes"}

    376. 

  376.         ]);

    377. 

  377.         if (e) throw e;

    378. 

  378.         if(!this._scriptsToLoad) {

    379. 

  379.             this._scriptsToLoad = [];

    380. 

  380.         }

    381. 

  381.         Array.add(this._scriptsToLoad, scriptAttributes);

    382. 

  382.     },

    383. 

  383. 

    384. 

  384.     queueScriptBlock: function _ScriptLoader$queueScriptBlock(scriptContent) {

    385. 

  385.         /// <summary locid="M:J#Sys._ScriptLoader.queueScriptBlock">Queues a script reference with literal script.</summary>

    386. 

  386.         /// <param name="scriptContent" type="String" mayBeNull="false">Literal script to execute.</param>

    387. 

  387.         var e = Function._validateParams(arguments, [

    388. 

  388.             {name: "scriptContent", type: String}

    389. 

  389.         ]);

    390. 

  390.         if (e) throw e;

    391. 

  391.         if(!this._scriptsToLoad) {

    392. 

  392.             this._scriptsToLoad = [];

    393. 

  393.         }

    394. 

  394.         Array.add(this._scriptsToLoad, {text: scriptContent});

    395. 

  395.     },

    396. 

  396. 

    397. 

  397.     queueScriptReference: function _ScriptLoader$queueScriptReference(scriptUrl) {

    398. 

  398.         /// <summary locid="M:J#Sys._ScriptLoader.queueScriptReference">Queues a script reference to the given script URL.</summary>

    399. 

  399.         /// <param name="scriptUrl" type="String" mayBeNull="false">URL to the script to reference.</param>

    400. 

  400.         var e = Function._validateParams(arguments, [

    401. 

  401.             {name: "scriptUrl", type: String}

    402. 

  402.         ]);

    403. 

  403.         if (e) throw e;

    404. 

  404.         if(!this._scriptsToLoad) {

    405. 

  405.             this._scriptsToLoad = [];

    406. 

  406.         }

    407. 

  407.         Array.add(this._scriptsToLoad, {src: scriptUrl});

    408. 

  408.     },

    409. 

  409.     

    410. 

  410.     _createScriptElement: function _ScriptLoader$_createScriptElement(queuedScript) {

    411. 

  411.         var scriptElement = document.createElement('script');

    412. 

  412. 

    413. 

  413.         scriptElement.type = 'text/javascript';

    414. 

  414. 

    415. 

  415.         for (var attr in queuedScript) {

    416. 

  416.             scriptElement[attr] = queuedScript[attr];

    417. 

  417.         }

    418. 

  418.         

    419. 

  419.         return scriptElement;

    420. 

  420.     },

    421. 

  421.     

    422. 

  422.     _loadScriptsInternal: function _ScriptLoader$_loadScriptsInternal() {

    423. 

  423.         var session = this._currentSession;

    424. 

  424.         if (session.scriptsToLoad && session.scriptsToLoad.length > 0) {

    425. 

  425.             var nextScript = Array.dequeue(session.scriptsToLoad);

    426. 

  426.             var scriptElement = this._createScriptElement(nextScript);

    427. 

  427.             

    428. 

  428.             if (scriptElement.text && Sys.Browser.agent === Sys.Browser.Safari) {

    429. 

  429.                 scriptElement.innerHTML = scriptElement.text;

    430. 

  430.                 delete scriptElement.text;

    431. 

  431.             }            

    432. 

  432. 

    433. 

  433.             if (typeof(nextScript.src) === "string") {

    434. 

  434.                 this._currentTask = new Sys._ScriptLoaderTask(scriptElement, this._scriptLoadedDelegate);

    435. 

  435.                 this._currentTask.execute();

    436. 

  436.             }

    437. 

  437.             else {

    438. 

  438.                 var headElements = document.getElementsByTagName('head');

    439. 

  439.                 if (headElements.length === 0) {

    440. 

  440.                      throw new Error.invalidOperation(Sys.Res.scriptLoadFailedNoHead);

    441. 

  441.                 }

    442. 

  442.                 else {

    443. 

  443.                      headElements[0].appendChild(scriptElement);

    444. 

  444.                 }

    445. 

  445.                 

    446. 

  446.                 

    447. 

  447.                 Sys._ScriptLoaderTask._clearScript(scriptElement);

    448. 

  448.                 this._loadScriptsInternal();

    449. 

  449.             }

    450. 

  450.         }

    451. 

  451.         else {

    452. 

  452.             this._stopSession();

    453. 

  453.             var callback = session.allScriptsLoadedCallback;

    454. 

  454.             if(callback) {

    455. 

  455.                 callback(this);

    456. 

  456.             }

    457. 

  457.             this._nextSession();

    458. 

  458.         }

    459. 

  459.     },

    460. 

  460. 

    461. 

  461.     _nextSession: function _ScriptLoader$_nextSession() {

    462. 

  462.         if (this._sessions.length === 0) {

    463. 

  463.             this._loading = false;

    464. 

  464.             this._currentSession = null;

    465. 

  465.             return;

    466. 

  466.         }

    467. 

  467.         this._loading = true;

    468. 

  468.         

    469. 

  469.         var session = Array.dequeue(this._sessions);

    470. 

  470.         this._currentSession = session;

    471. 

  471.         this._loadScriptsInternal();

    472. 

  472.     },

    473. 

  473. 

    474. 

  474.     _raiseError: function _ScriptLoader$_raiseError() {

    475. 

  475.         var callback = this._currentSession.scriptLoadFailedCallback;

    476. 

  476.         var scriptElement = this._currentTask.get_scriptElement();

    477. 

  477.         this._stopSession();

    478. 

  478.         

    479. 

  479.         if(callback) {

    480. 

  480.             callback(this, scriptElement);

    481. 

  481.             this._nextSession();

    482. 

  482.         }

    483. 

  483.         else {

    484. 

  484.             this._loading = false;

    485. 

  485.             throw Sys._ScriptLoader._errorScriptLoadFailed(scriptElement.src);

    486. 

  486.         }

    487. 

  487.     },

    488. 

  488.     

    489. 

  489.     _scriptLoadedHandler: function _ScriptLoader$_scriptLoadedHandler(scriptElement, loaded) {

    490. 

  490.         if (loaded) {

    491. 

  491.             Array.add(Sys._ScriptLoader._getLoadedScripts(), scriptElement.src);

    492. 

  492.             this._currentTask.dispose();

    493. 

  493.             this._currentTask = null;

    494. 

  494.             this._loadScriptsInternal();

    495. 

  495.         }

    496. 

  496.         else {

    497. 

  497.             this._raiseError();

    498. 

  498.         }

    499. 

  499.     },

    500. 

  500.     _stopSession: function _ScriptLoader$_stopSession() {

    501. 

  501.         if(this._currentTask) {

    502. 

  502.             this._currentTask.dispose();

    503. 

  503.             this._currentTask = null;

    504. 

  504.         }

    505. 

  505.     }    

    506. 

  506. }

    507. 

  507. $type.registerClass('Sys._ScriptLoader', null, Sys.IDisposable);

    508. 

  508. 

    509. 

  509. $type.getInstance = function _ScriptLoader$getInstance() {

    510. 

  510.     var sl = Sys._ScriptLoader._activeInstance;

    511. 

  511.     if(!sl) {

    512. 

  512.         sl = Sys._ScriptLoader._activeInstance = new Sys._ScriptLoader();

    513. 

  513.     }

    514. 

  514.     return sl;

    515. 

  515. }

    516. 

  516. 

    517. 

  517. $type.isScriptLoaded = function _ScriptLoader$isScriptLoaded(scriptSrc) {

    518. 

  518.     var dummyScript = document.createElement('script');

    519. 

  519.     dummyScript.src = scriptSrc;

    520. 

  520.     return Array.contains(Sys._ScriptLoader._getLoadedScripts(), dummyScript.src);

    521. 

  521. }

    522. 

  522. 

    523. 

  523. $type.readLoadedScripts = function _ScriptLoader$readLoadedScripts() {

    524. 

  524.     if(!Sys._ScriptLoader._referencedScripts) {

    525. 

  525.         var referencedScripts = Sys._ScriptLoader._referencedScripts = [];

    526. 

  526. 

    527. 

  527.         var existingScripts = document.getElementsByTagName('script');

    528. 

  528.         for (var i = existingScripts.length - 1; i >= 0; i--) {

    529. 

  529.             var scriptNode = existingScripts[i];

    530. 

  530.             var scriptSrc = scriptNode.src;

    531. 

  531.             if (scriptSrc.length) {

    532. 

  532.                 if (!Array.contains(referencedScripts, scriptSrc)) {

    533. 

  533.                     Array.add(referencedScripts, scriptSrc);

    534. 

  534.                 }

    535. 

  535.             }

    536. 

  536.         }

    537. 

  537.     }

    538. 

  538. }

    539. 

  539. 

    540. 

  540. $type._errorScriptLoadFailed = function _ScriptLoader$_errorScriptLoadFailed(scriptUrl) {

    541. 

  541.     var errorMessage;

    542. 

  542.     errorMessage = Sys.Res.scriptLoadFailedDebug;

    543. 

  543. 

    544. 

  544.     var displayMessage = "Sys.ScriptLoadFailedException: " + String.format(errorMessage, scriptUrl);

    545. 

  545.     var e = Error.create(displayMessage, {name: 'Sys.ScriptLoadFailedException', 'scriptUrl': scriptUrl });

    546. 

  546.     e.popStackFrame();

    547. 

  547.     return e;

    548. 

  548. }

    549. 

  549. 

    550. 

  550. $type._getLoadedScripts = function _ScriptLoader$_getLoadedScripts() {

    551. 

  551.     if(!Sys._ScriptLoader._referencedScripts) {

    552. 

  552.         Sys._ScriptLoader._referencedScripts = [];

    553. 

  553.         Sys._ScriptLoader.readLoadedScripts();

    554. 

  554.     }

    555. 

  555.     return Sys._ScriptLoader._referencedScripts;

    556. 

  556. }

    557. 

  557. $type = Sys.WebForms.PageRequestManager = function PageRequestManager() {

    558. 

  558.     this._form = null;

    559. 

  559.     this._activeDefaultButton = null;

    560. 

  560.     this._activeDefaultButtonClicked = false;

    561. 

  561.     this._updatePanelIDs = null;

    562. 

  562.     this._updatePanelClientIDs = null;

    563. 

  563.     this._updatePanelHasChildrenAsTriggers = null;

    564. 

  564.     this._asyncPostBackControlIDs = null;

    565. 

  565.     this._asyncPostBackControlClientIDs = null;

    566. 

  566.     this._postBackControlIDs = null;

    567. 

  567.     this._postBackControlClientIDs = null;

    568. 

  568.     this._scriptManagerID = null;

    569. 

  569.     this._pageLoadedHandler = null;

    570. 

  570. 

    571. 

  571.     this._additionalInput = null;

    572. 

  572.     this._onsubmit = null;

    573. 

  573.     this._onSubmitStatements = [];

    574. 

  574.     this._originalDoPostBack = null;

    575. 

  575.     this._originalDoPostBackWithOptions = null;

    576. 

  576.     this._originalFireDefaultButton = null;

    577. 

  577.     this._originalDoCallback = null;

    578. 

  578.     this._isCrossPost = false;

    579. 

  579.     this._postBackSettings = null;

    580. 

  580.     this._request = null;

    581. 

  581.     this._onFormSubmitHandler = null;

    582. 

  582.     this._onFormElementClickHandler = null;

    583. 

  583.     this._onWindowUnloadHandler = null;

    584. 

  584.     this._asyncPostBackTimeout = null;

    585. 

  585. 

    586. 

  586.     this._controlIDToFocus = null;

    587. 

  587.     this._scrollPosition = null;

    588. 

  588.     this._processingRequest = false;

    589. 

  589.     this._scriptDisposes = {};

    590. 

  590.     

    591. 

  591.     this._transientFields = ["__VIEWSTATEENCRYPTED", "__VIEWSTATEFIELDCOUNT"];

    592. 

  592. }

    593. 

  593. 

    594. 

  594. $type.prototype = {

    595. 

  595.     get_isInAsyncPostBack: function PageRequestManager$get_isInAsyncPostBack() {

    596. 

  596.         /// <value type="Boolean" locid="P:J#Sys.WebForms.PageRequestManager.isInAsyncPostBack"></value>

    597. 

  597.         if (arguments.length !== 0) throw Error.parameterCount();

    598. 

  598.         return this._request !== null;

    599. 

  599.     },

    600. 

  600. 

    601. 

  601.     add_beginRequest: function PageRequestManager$add_beginRequest(handler) {

    602. 

  602.         /// <summary locid="E:J#Sys.WebForms.PageRequestManager.beginRequest">Adds a beginRequest event handler.</summary>

    603. 

  603.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    604. 

  604.         if (e) throw e;

    605. 

  605.         Sys.Observer.addEventHandler(this, "beginRequest", handler);

    606. 

  606.     },

    607. 

  607.     remove_beginRequest: function PageRequestManager$remove_beginRequest(handler) {

    608. 

  608.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    609. 

  609.         if (e) throw e;

    610. 

  610.         Sys.Observer.removeEventHandler(this, "beginRequest", handler);

    611. 

  611.     },

    612. 

  612. 

    613. 

  613.     add_endRequest: function PageRequestManager$add_endRequest(handler) {

    614. 

  614.         /// <summary locid="E:J#Sys.WebForms.PageRequestManager.endRequest">Adds a endRequest event handler.</summary>

    615. 

  615.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    616. 

  616.         if (e) throw e;

    617. 

  617.         Sys.Observer.addEventHandler(this, "endRequest", handler);

    618. 

  618.     },

    619. 

  619.     remove_endRequest: function PageRequestManager$remove_endRequest(handler) {

    620. 

  620.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    621. 

  621.         if (e) throw e;

    622. 

  622.         Sys.Observer.removeEventHandler(this, "endRequest", handler);

    623. 

  623.     },

    624. 

  624. 

    625. 

  625.     add_initializeRequest: function PageRequestManager$add_initializeRequest(handler) {

    626. 

  626.         /// <summary locid="E:J#Sys.WebForms.PageRequestManager.initializeRequest">Adds a initializeRequest event handler.</summary>

    627. 

  627.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    628. 

  628.         if (e) throw e;

    629. 

  629.         Sys.Observer.addEventHandler(this, "initializeRequest", handler);

    630. 

  630.     },

    631. 

  631.     remove_initializeRequest: function PageRequestManager$remove_initializeRequest(handler) {

    632. 

  632.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    633. 

  633.         if (e) throw e;

    634. 

  634.         Sys.Observer.removeEventHandler(this, "initializeRequest", handler);

    635. 

  635.     },

    636. 

  636. 

    637. 

  637.     add_pageLoaded: function PageRequestManager$add_pageLoaded(handler) {

    638. 

  638.         /// <summary locid="E:J#Sys.WebForms.PageRequestManager.pageLoaded">Adds a pageLoaded event handler.</summary>

    639. 

  639.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    640. 

  640.         if (e) throw e;

    641. 

  641.         Sys.Observer.addEventHandler(this, "pageLoaded", handler);

    642. 

  642.     },

    643. 

  643.     remove_pageLoaded: function PageRequestManager$remove_pageLoaded(handler) {

    644. 

  644.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    645. 

  645.         if (e) throw e;

    646. 

  646.         Sys.Observer.removeEventHandler(this, "pageLoaded", handler);

    647. 

  647.     },

    648. 

  648. 

    649. 

  649.     add_pageLoading: function PageRequestManager$add_pageLoading(handler) {

    650. 

  650.         /// <summary locid="E:J#Sys.WebForms.PageRequestManager.pageLoading">Adds a pageLoading event handler.</summary>

    651. 

  651.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    652. 

  652.         if (e) throw e;

    653. 

  653.         Sys.Observer.addEventHandler(this, "pageLoading", handler);

    654. 

  654.     },

    655. 

  655.     remove_pageLoading: function PageRequestManager$remove_pageLoading(handler) {

    656. 

  656.         var e = Function._validateParams(arguments, [{name: "handler", type: Function}]);

    657. 

  657.         if (e) throw e;

    658. 

  658.         Sys.Observer.removeEventHandler(this, "pageLoading", handler);

    659. 

  659.     },

    660. 

  660. 

    661. 

  661.     abortPostBack: function PageRequestManager$abortPostBack() {

    662. 

  662.         if (!this._processingRequest && this._request) {

    663. 

  663.             this._request.get_executor().abort();

    664. 

  664.             this._request = null;

    665. 

  665.         }

    666. 

  666.     },

    667. 

  667. 

    668. 

  668.     beginAsyncPostBack: function PageRequestManager$beginAsyncPostBack(updatePanelsToUpdate, eventTarget, eventArgument, causesValidation, validationGroup) {

    669. 

  669.         /// <summary locid="M:J#Sys.WebForms.PageRequestManager.beginAsyncPostBack">Begins an asynchronous postback.</summary>

    670. 

  670.         /// <param name="updatePanelsToUpdate" type="Array" elementType="String" mayBeNull="true" optional="true">A list of UniqueIDs or ClientIDs of UpdatePanel controls that should have their rendering updated.</param>

    671. 

  671.         /// <param name="eventTarget" type="String" mayBeNull="true" optional="true"></param>

    672. 

  672.         /// <param name="eventArgument" type="String" mayBeNull="true" optional="true"></param>

    673. 

  673.         /// <param name="causesValidation" type="Boolean" mayBeNull="true" optional="true"></param>

    674. 

  674.         /// <param name="validationGroup" type="String" mayBeNull="true" optional="true"></param>

    675. 

  675.         var e = Function._validateParams(arguments, [

    676. 

  676.             {name: "updatePanelsToUpdate", type: Array, mayBeNull: true, optional: true, elementType: String},

    677. 

  677.             {name: "eventTarget", type: String, mayBeNull: true, optional: true},

    678. 

  678.             {name: "eventArgument", type: String, mayBeNull: true, optional: true},

    679. 

  679.             {name: "causesValidation", type: Boolean, mayBeNull: true, optional: true},

    680. 

  680.             {name: "validationGroup", type: String, mayBeNull: true, optional: true}

    681. 

  681.         ]);

    682. 

  682.         if (e) throw e;

    683. 

  683.         if (causesValidation && (typeof(Page_ClientValidate) === 'function') && !Page_ClientValidate(validationGroup || null)) {

    684. 

  684.             return;

    685. 

  685.         }

    686. 

  686.         this._postBackSettings = this._createPostBackSettings(true, updatePanelsToUpdate, eventTarget);

    687. 

  687.         var form = this._form;

    688. 

  688.         form.__EVENTTARGET.value = (eventTarget || "");

    689. 

  689.         form.__EVENTARGUMENT.value = (eventArgument || "");

    690. 

  690.         this._isCrossPost = false;

    691. 

  691.         this._additionalInput = null;

    692. 

  692.         this._onFormSubmit();

    693. 

  693.     },

    694. 

  694.     

    695. 

  695.     _cancelPendingCallbacks: function PageRequestManager$_cancelPendingCallbacks() {

    696. 

  696.         for (var i = 0, l = window.__pendingCallbacks.length; i < l; i++) {

    697. 

  697.             var callback = window.__pendingCallbacks[i];

    698. 

  698.             if (callback) {

    699. 

  699.                 if (!callback.async) {

    700. 

  700.                     window.__synchronousCallBackIndex = -1;

    701. 

  701.                 }

    702. 

  702.                 window.__pendingCallbacks[i] = null;

    703. 

  703.                 var callbackFrameID = "__CALLBACKFRAME" + i;

    704. 

  704.                 var xmlRequestFrame = document.getElementById(callbackFrameID);

    705. 

  705.                 if (xmlRequestFrame) {

    706. 

  706.                     xmlRequestFrame.parentNode.removeChild(xmlRequestFrame);

    707. 

  707.                 }

    708. 

  708.             }

    709. 

  709.         }

    710. 

  710.     },

    711. 

  711.     

    712. 

  712.     _commitControls: function PageRequestManager$_commitControls(updatePanelData, asyncPostBackTimeout) {

    713. 

  713.         if (updatePanelData) {

    714. 

  714.             this._updatePanelIDs = updatePanelData.updatePanelIDs;

    715. 

  715.             this._updatePanelClientIDs = updatePanelData.updatePanelClientIDs;

    716. 

  716.             this._updatePanelHasChildrenAsTriggers = updatePanelData.updatePanelHasChildrenAsTriggers;

    717. 

  717.             this._asyncPostBackControlIDs = updatePanelData.asyncPostBackControlIDs;

    718. 

  718.             this._asyncPostBackControlClientIDs = updatePanelData.asyncPostBackControlClientIDs;

    719. 

  719.             this._postBackControlIDs = updatePanelData.postBackControlIDs;

    720. 

  720.             this._postBackControlClientIDs = updatePanelData.postBackControlClientIDs;

    721. 

  721.         }

    722. 

  722.         if (typeof(asyncPostBackTimeout) !== 'undefined' && asyncPostBackTimeout !== null) {

    723. 

  723.             this._asyncPostBackTimeout = asyncPostBackTimeout * 1000;

    724. 

  724.         }

    725. 

  725.     },

    726. 

  726.     

    727. 

  727.     _createHiddenField: function PageRequestManager$_createHiddenField(id, value) {

    728. 

  728.         var container, field = document.getElementById(id);

    729. 

  729. 

    730. 

  730.         if (field) {

    731. 

  731.             if (!field._isContained) {

    732. 

  732.                 field.parentNode.removeChild(field);

    733. 

  733.             }

    734. 

  734.             else {

    735. 

  735.                 container = field.parentNode;

    736. 

  736.             }

    737. 

  737.         }

    738. 

  738.         if (!container) {

    739. 

  739.             container = document.createElement('span');

    740. 

  740.             container.style.cssText = "display:none !important";

    741. 

  741.             this._form.appendChild(container);

    742. 

  742.         }

    743. 

  743.         container.innerHTML = "<input type='hidden' />";

    744. 

  744.         field = container.childNodes[0];

    745. 

  745.         field._isContained = true;

    746. 

  746.         field.id = field.name = id;

    747. 

  747.         field.value = value;

    748. 

  748.     },

    749. 

  749. 

    750. 

  750.     _createPageRequestManagerTimeoutError: function PageRequestManager$_createPageRequestManagerTimeoutError() {

    751. 

  751.         var displayMessage = "Sys.WebForms.PageRequestManagerTimeoutException: " + Sys.WebForms.Res.PRM_TimeoutError;

    752. 

  752.         var e = Error.create(displayMessage, {name: 'Sys.WebForms.PageRequestManagerTimeoutException'});

    753. 

  753.         e.popStackFrame();

    754. 

  754.         return e;

    755. 

  755.     },

    756. 

  756. 

    757. 

  757.     _createPageRequestManagerServerError: function PageRequestManager$_createPageRequestManagerServerError(httpStatusCode, message) {

    758. 

  758.         var displayMessage = "Sys.WebForms.PageRequestManagerServerErrorException: " +

    759. 

  759.             (message || String.format(Sys.WebForms.Res.PRM_ServerError, httpStatusCode));

    760. 

  760.         var e = Error.create(displayMessage, {

    761. 

  761.             name: 'Sys.WebForms.PageRequestManagerServerErrorException',

    762. 

  762.             httpStatusCode: httpStatusCode

    763. 

  763.         });

    764. 

  764.         e.popStackFrame();

    765. 

  765.         return e;

    766. 

  766.     },

    767. 

  767. 

    768. 

  768.     _createPageRequestManagerParserError: function PageRequestManager$_createPageRequestManagerParserError(parserErrorMessage) {

    769. 

  769.         var displayMessage = "Sys.WebForms.PageRequestManagerParserErrorException: " + String.format(Sys.WebForms.Res.PRM_ParserError, parserErrorMessage);

    770. 

  770.         var e = Error.create(displayMessage, {name: 'Sys.WebForms.PageRequestManagerParserErrorException'});

    771. 

  771.         e.popStackFrame();

    772. 

  772.         return e;

    773. 

  773.     },

    774. 

  774. 

    775. 

  775.     _createPanelID: function PageRequestManager$_createPanelID(panelsToUpdate, postBackSettings) {

    776. 

  776.         var asyncTarget = postBackSettings.asyncTarget,

    777. 

  777.             toUpdate = this._ensureUniqueIds(panelsToUpdate || postBackSettings.panelsToUpdate),

    778. 

  778.             panelArg = (toUpdate instanceof Array)

    779. 

  779.                 ? toUpdate.join(',')

    780. 

  780.                 : (toUpdate || this._scriptManagerID);

    781. 

  781.         if (asyncTarget) {

    782. 

  782.             panelArg += "|" + asyncTarget;

    783. 

  783.         }

    784. 

  784.         return encodeURIComponent(this._scriptManagerID) + '=' + encodeURIComponent(panelArg) + '&';

    785. 

  785.     },

    786. 

  786. 

    787. 

  787.     _createPostBackSettings: function PageRequestManager$_createPostBackSettings(async, panelsToUpdate, asyncTarget, sourceElement) {

    788. 

  788.         return { async:async, asyncTarget: asyncTarget, panelsToUpdate: panelsToUpdate, sourceElement: sourceElement };

    789. 

  789.     },

    790. 

  790. 

    791. 

  791.     _convertToClientIDs: function PageRequestManager$_convertToClientIDs(source, destinationIDs, destinationClientIDs, version4) {

    792. 

  792.         if (source) {

    793. 

  793.             for (var i = 0, l = source.length; i < l; i += (version4 ? 2 : 1)) {

    794. 

  794.                 var uniqueID = source[i],

    795. 

  795.                     clientID = (version4 ? source[i+1] : "") || this._uniqueIDToClientID(uniqueID);

    796. 

  796.                 Array.add(destinationIDs, uniqueID);

    797. 

  797.                 Array.add(destinationClientIDs, clientID);

    798. 

  798.             }

    799. 

  799.         }

    800. 

  800.     },

    801. 

  801. 

    802. 

  802.     dispose: function PageRequestManager$dispose() {

    803. 

  803.         Sys.Observer.clearEventHandlers(this);

    804. 

  804.         if (this._form) {

    805. 

  805.             Sys.UI.DomEvent.removeHandler(this._form, 'submit', this._onFormSubmitHandler);

    806. 

  806.             Sys.UI.DomEvent.removeHandler(this._form, 'click', this._onFormElementClickHandler);

    807. 

  807.             Sys.UI.DomEvent.removeHandler(window, 'unload', this._onWindowUnloadHandler);

    808. 

  808.             Sys.UI.DomEvent.removeHandler(window, 'load', this._pageLoadedHandler);

    809. 

  809.         }

    810. 

  810. 

    811. 

  811.         if (this._originalDoPostBack) {

    812. 

  812.             window.__doPostBack = this._originalDoPostBack;

    813. 

  813.             this._originalDoPostBack = null;

    814. 

  814.         }

    815. 

  815.         if (this._originalDoPostBackWithOptions) {

    816. 

  816.             window.WebForm_DoPostBackWithOptions = this._originalDoPostBackWithOptions;

    817. 

  817.             this._originalDoPostBackWithOptions = null;

    818. 

  818.         }

    819. 

  819.         if (this._originalFireDefaultButton) {

    820. 

  820.             window.WebForm_FireDefaultButton = this._originalFireDefaultButton;

    821. 

  821.             this._originalFireDefaultButton = null;

    822. 

  822.         }

    823. 

  823.         if (this._originalDoCallback) {

    824. 

  824.             window.WebForm_DoCallback = this._originalDoCallback;

    825. 

  825.             this._originalDoCallback = null;

    826. 

  826.         }

    827. 

  827. 

    828. 

  828.         this._form = null;

    829. 

  829.         this._updatePanelIDs = null;

    830. 

  830.         this._updatePanelClientIDs = null;

    831. 

  831.         this._asyncPostBackControlIDs = null;

    832. 

  832.         this._asyncPostBackControlClientIDs = null;

    833. 

  833.         this._postBackControlIDs = null;

    834. 

  834.         this._postBackControlClientIDs = null;

    835. 

  835.         this._asyncPostBackTimeout = null;

    836. 

  836.         this._scrollPosition = null;

    837. 

  837.     },

    838. 

  838.     

    839. 

  839.     _doCallback: function PageRequestManager$_doCallback(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync) {

    840. 

  840.         if (!this.get_isInAsyncPostBack()) {

    841. 

  841.             this._originalDoCallback(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync);

    842. 

  842.         }

    843. 

  843.     },

    844. 

  844. 

    845. 

  845.     _doPostBack: function PageRequestManager$_doPostBack(eventTarget, eventArgument) {

    846. 

  846.         this._additionalInput = null;

    847. 

  847. 

    848. 

  848.         var form = this._form;

    849. 

  849.         if ((eventTarget === null) || (typeof(eventTarget) === "undefined") || (this._isCrossPost)) {

    850. 

  850.             this._postBackSettings = this._createPostBackSettings(false);

    851. 

  851.             this._isCrossPost = false;

    852. 

  852.         }

    853. 

  853.         else {

    854. 

  854.             var mpUniqueID = this._masterPageUniqueID;

    855. 

  855.             var clientID = this._uniqueIDToClientID(eventTarget);

    856. 

  856.             var postBackElement = document.getElementById(clientID);

    857. 

  857.             if (!postBackElement && mpUniqueID) {

    858. 

  858.                 if (clientID.indexOf(mpUniqueID + "$") === 0) {

    859. 

  859.                     postBackElement = document.getElementById(clientID.substr(mpUniqueID.length + 1));

    860. 

  860.                 }

    861. 

  861.             }

    862. 

  862.             if (!postBackElement) {

    863. 

  863.                 if (Array.contains(this._asyncPostBackControlIDs, eventTarget)) {

    864. 

  864.                     this._postBackSettings = this._createPostBackSettings(true, null, eventTarget);

    865. 

  865.                 }

    866. 

  866.                 else {

    867. 

  867.                     if (Array.contains(this._postBackControlIDs, eventTarget)) {

    868. 

  868.                         this._postBackSettings = this._createPostBackSettings(false);

    869. 

  869.                     }

    870. 

  870.                     else {

    871. 

  871.                         var nearestUniqueIDMatch = this._findNearestElement(eventTarget);

    872. 

  872.                         if (nearestUniqueIDMatch) {

    873. 

  873.                             this._postBackSettings = this._getPostBackSettings(nearestUniqueIDMatch, eventTarget);

    874. 

  874.                         }

    875. 

  875.                         else {

    876. 

  876.                             if (mpUniqueID) {

    877. 

  877.                                 mpUniqueID += "$";

    878. 

  878.                                 if (eventTarget.indexOf(mpUniqueID) === 0) {

    879. 

  879.                                     nearestUniqueIDMatch = this._findNearestElement(eventTarget.substr(mpUniqueID.length));

    880. 

  880.                                 }

    881. 

  881.                             }

    882. 

  882.                             if (nearestUniqueIDMatch) {

    883. 

  883.                                 this._postBackSettings = this._getPostBackSettings(nearestUniqueIDMatch, eventTarget);

    884. 

  884.                             }

    885. 

  885.                             else {

    886. 

  886.                                 this._postBackSettings = this._createPostBackSettings(false);

    887. 

  887.                             }

    888. 

  888.                         }

    889. 

  889.                     }

    890. 

  890.                 }

    891. 

  891.             }

    892. 

  892.             else {

    893. 

  893.                 this._postBackSettings = this._getPostBackSettings(postBackElement, eventTarget);

    894. 

  894.             }

    895. 

  895.         }

    896. 

  896. 

    897. 

  897.         if (!this._postBackSettings.async) {

    898. 

  898.             form.onsubmit = this._onsubmit;

    899. 

  899.             this._originalDoPostBack(eventTarget, eventArgument);

    900. 

  900.             form.onsubmit = null;

    901. 

  901.             return;

    902. 

  902.         }

    903. 

  903. 

    904. 

  904.         form.__EVENTTARGET.value = eventTarget;

    905. 

  905.         form.__EVENTARGUMENT.value = eventArgument;

    906. 

  906.         this._onFormSubmit();

    907. 

  907.     },

    908. 

  908. 

    909. 

  909.     _doPostBackWithOptions: function PageRequestManager$_doPostBackWithOptions(options) {

    910. 

  910.         this._isCrossPost = options && options.actionUrl;

    911. 

  911.         this._originalDoPostBackWithOptions(options);

    912. 

  912.     },

    913. 

  913. 

    914. 

  914.     _elementContains: function PageRequestManager$_elementContains(container, element) {

    915. 

  915.         while (element) {

    916. 

  916.             if (element === container) {

    917. 

  917.                 return true;

    918. 

  918.             }

    919. 

  919.             element = element.parentNode;

    920. 

  920.         }

    921. 

  921.         return false;

    922. 

  922.     },

    923. 

  923. 

    924. 

  924.     _endPostBack: function PageRequestManager$_endPostBack(error, executor, data) {

    925. 

  925.         if (this._request === executor.get_webRequest()) {

    926. 

  926.             this._processingRequest = false;

    927. 

  927.             this._additionalInput = null;

    928. 

  928.             this._request = null;

    929. 

  929.         }

    930. 

  930. 

    931. 

  931.         var eventArgs = new Sys.WebForms.EndRequestEventArgs(error, data ? data.dataItems : {}, executor);

    932. 

  932.         Sys.Observer.raiseEvent(this, "endRequest", eventArgs);

    933. 

  933.         if (error && !eventArgs.get_errorHandled()) {

    934. 

  934.             throw error;

    935. 

  935.         }

    936. 

  936.     },

    937. 

  937. 

    938. 

  938.     _ensureUniqueIds: function PageRequestManager$_ensureUniqueIds(ids) {

    939. 

  939.         if (!ids) return ids;

    940. 

  940.         ids = ids instanceof Array ? ids : [ids];

    941. 

  941.         var uniqueIds = [];

    942. 

  942.         for (var i = 0, l = ids.length; i < l; i++) {

    943. 

  943.             var id = ids[i], index = Array.indexOf(this._updatePanelClientIDs, id);

    944. 

  944.             uniqueIds.push(index > -1 ? this._updatePanelIDs[index] : id);

    945. 

  945.         }

    946. 

  946.         return uniqueIds;

    947. 

  947.     },

    948. 

  948. 

    949. 

  949.     _findNearestElement: function PageRequestManager$_findNearestElement(uniqueID) {

    950. 

  950.         while (uniqueID.length > 0) {

    951. 

  951.             var clientID = this._uniqueIDToClientID(uniqueID);

    952. 

  952.             var element = document.getElementById(clientID);

    953. 

  953.             if (element) {

    954. 

  954.                 return element;

    955. 

  955.             }

    956. 

  956.             var indexOfLastDollar = uniqueID.lastIndexOf('$');

    957. 

  957.             if (indexOfLastDollar === -1) {

    958. 

  958.                 return null;

    959. 

  959.             }

    960. 

  960.             uniqueID = uniqueID.substring(0, indexOfLastDollar);

    961. 

  961.         }

    962. 

  962.         return null;

    963. 

  963.     },

    964. 

  964. 

    965. 

  965.     _findText: function PageRequestManager$_findText(text, location) {

    966. 

  966.         var startIndex = Math.max(0, location - 20);

    967. 

  967.         var endIndex = Math.min(text.length, location + 20);

    968. 

  968.         return text.substring(startIndex, endIndex);

    969. 

  969.     },

    970. 

  970.     

    971. 

  971.     _fireDefaultButton: function PageRequestManager$_fireDefaultButton(event, target) {

    972. 

  972.         if (event.keyCode === 13) {

    973. 

  973.             var src = event.srcElement || event.target;

    974. 

  974.             if (!src || (src.tagName.toLowerCase() !== "textarea")) {

    975. 

  975.                 var defaultButton = document.getElementById(target);

    976. 

  976. 

    977. 

  977.                 if (defaultButton && (typeof(defaultButton.click) !== "undefined")) {

    978. 

  978.                     

    979. 

  979.                     

    980. 

  980.                     this._activeDefaultButton = defaultButton;

    981. 

  981.                     this._activeDefaultButtonClicked = false;

    982. 

  982.                     try {

    983. 

  983.                         defaultButton.click();

    984. 

  984.                     }

    985. 

  985.                     finally {

    986. 

  986.                         this._activeDefaultButton = null;

    987. 

  987.                     }

    988. 

  988.                     

    989. 

  989.                     

    990. 

  990.                     event.cancelBubble = true;

    991. 

  991.                     if (typeof(event.stopPropagation) === "function") {

    992. 

  992.                         event.stopPropagation();

    993. 

  993.                     }

    994. 

  994.                     return false;

    995. 

  995.                 }

    996. 

  996.             }

    997. 

  997.         }

    998. 

  998.         return true;

    999. 

  999.     },

    1000. 

  1000. 

    1001. 

  1001.     _getPageLoadedEventArgs: function PageRequestManager$_getPageLoadedEventArgs(initialLoad, data) {

    1002. 

  1002. 

    1003. 

  1003.         var updated = [];

    1004. 

  1004.         var created = [];

    1005. 

  1005.         var version4 = data ? data.version4 : false;

    1006. 

  1006.         var upData = data ? data.updatePanelData : null;

    1007. 

  1007. 

    1008. 

  1008.         var newIDs, newClientIDs, childIDs, refreshedIDs;

    1009. 

  1009. 

    1010. 

  1010.         if (!upData) {

    1011. 

  1011.             newIDs = this._updatePanelIDs;

    1012. 

  1012.             newClientIDs = this._updatePanelClientIDs;

    1013. 

  1013.             childIDs = null;

    1014. 

  1014.             refreshedIDs = null;

    1015. 

  1015.         }

    1016. 

  1016.         else {

    1017. 

  1017.             newIDs = upData.updatePanelIDs;

    1018. 

  1018.             newClientIDs = upData.updatePanelClientIDs;

    1019. 

  1019.             childIDs = upData.childUpdatePanelIDs;

    1020. 

  1020.             refreshedIDs = upData.panelsToRefreshIDs;

    1021. 

  1021.         }

    1022. 

  1022. 

    1023. 

  1023.         var i, l, uniqueID, clientID;

    1024. 

  1024.         if (refreshedIDs) {

    1025. 

  1025.             for (i = 0, l = refreshedIDs.length; i < l; i += (version4 ? 2 : 1)) {

    1026. 

  1026.                 uniqueID = refreshedIDs[i];

    1027. 

  1027.                 clientID = (version4 ? refreshedIDs[i+1] : "") || this._uniqueIDToClientID(uniqueID);

    1028. 

  1028.                 Array.add(updated, document.getElementById(clientID));

    1029. 

  1029.             }

    1030. 

  1030.         }

    1031. 

  1031. 

    1032. 

  1032.         for (i = 0, l = newIDs.length; i < l; i++) {

    1033. 

  1033.             if (initialLoad || Array.indexOf(childIDs, newIDs[i]) !== -1) {

    1034. 

  1034.                 Array.add(created, document.getElementById(newClientIDs[i]));

    1035. 

  1035.             }

    1036. 

  1036.         }

    1037. 

  1037. 

    1038. 

  1038.         return new Sys.WebForms.PageLoadedEventArgs(updated, created, data ? data.dataItems : {});

    1039. 

  1039.     },

    1040. 

  1040. 

    1041. 

  1041.     _getPageLoadingEventArgs: function PageRequestManager$_getPageLoadingEventArgs(data) {

    1042. 

  1042. 

    1043. 

  1043.         var updated = [],

    1044. 

  1044.             deleted = [],

    1045. 

  1045.             upData = data.updatePanelData,

    1046. 

  1046.             oldIDs = upData.oldUpdatePanelIDs,

    1047. 

  1047.             oldClientIDs = upData.oldUpdatePanelClientIDs,

    1048. 

  1048.             newIDs = upData.updatePanelIDs,

    1049. 

  1049.             childIDs = upData.childUpdatePanelIDs,

    1050. 

  1050.             refreshedIDs = upData.panelsToRefreshIDs,

    1051. 

  1051.             i, l, uniqueID, clientID,

    1052. 

  1052.             version4 = data.version4;

    1053. 

  1053.         for (i = 0, l = refreshedIDs.length; i < l; i += (version4 ? 2 : 1)) {

    1054. 

  1054.             uniqueID = refreshedIDs[i];

    1055. 

  1055.             clientID = (version4 ? refreshedIDs[i+1] : "") || this._uniqueIDToClientID(uniqueID);

    1056. 

  1056.             Array.add(updated, document.getElementById(clientID));

    1057. 

  1057.         }

    1058. 

  1058. 

    1059. 

  1059.         for (i = 0, l = oldIDs.length; i < l; i++) {

    1060. 

  1060.             uniqueID = oldIDs[i];

    1061. 

  1061.             if (Array.indexOf(refreshedIDs, uniqueID) === -1 &&

    1062. 

  1062.                 (Array.indexOf(newIDs, uniqueID) === -1 || Array.indexOf(childIDs, uniqueID) > -1)) {

    1063. 

  1063.                 Array.add(deleted, document.getElementById(oldClientIDs[i]));

    1064. 

  1064.             }

    1065. 

  1065.         }

    1066. 

  1066. 

    1067. 

  1067.         return new Sys.WebForms.PageLoadingEventArgs(updated, deleted, data.dataItems);

    1068. 

  1068.     },

    1069. 

  1069. 

    1070. 

  1070.     _getPostBackSettings: function PageRequestManager$_getPostBackSettings(element, elementUniqueID) {

    1071. 

  1071. 

    1072. 

  1072.         var originalElement = element;

    1073. 

  1073. 

    1074. 

  1074.         var proposedSettings = null;

    1075. 

  1075. 

    1076. 

  1076.         while (element) {

    1077. 

  1077.             if (element.id) {

    1078. 

  1078.                 if (!proposedSettings && Array.contains(this._asyncPostBackControlClientIDs, element.id)) {

    1079. 

  1079.                     proposedSettings = this._createPostBackSettings(true, null, elementUniqueID, originalElement);

    1080. 

  1080.                 }

    1081. 

  1081.                 else {

    1082. 

  1082.                     if (!proposedSettings && Array.contains(this._postBackControlClientIDs, element.id)) {

    1083. 

  1083.                         return this._createPostBackSettings(false);

    1084. 

  1084.                     }

    1085. 

  1085.                     else {

    1086. 

  1086.                         var indexOfPanel = Array.indexOf(this._updatePanelClientIDs, element.id);

    1087. 

  1087.                         if (indexOfPanel !== -1) {

    1088. 

  1088.                             if (this._updatePanelHasChildrenAsTriggers[indexOfPanel]) {

    1089. 

  1089. 

    1090. 

  1090.                                 return this._createPostBackSettings(true, [this._updatePanelIDs[indexOfPanel]], elementUniqueID, originalElement);

    1091. 

  1091.                             }

    1092. 

  1092.                             else {

    1093. 

  1093.                                 return this._createPostBackSettings(true, null, elementUniqueID, originalElement);

    1094. 

  1094.                             }

    1095. 

  1095.                         }

    1096. 

  1096.                     }

    1097. 

  1097.                 }

    1098. 

  1098. 

    1099. 

  1099.                 if (!proposedSettings && this._matchesParentIDInList(element.id, this._asyncPostBackControlClientIDs)) {

    1100. 

  1100.                     proposedSettings = this._createPostBackSettings(true, null, elementUniqueID, originalElement);

    1101. 

  1101.                 }

    1102. 

  1102.                 else {

    1103. 

  1103.                     if (!proposedSettings && this._matchesParentIDInList(element.id, this._postBackControlClientIDs)) {

    1104. 

  1104.                         return this._createPostBackSettings(false);

    1105. 

  1105.                     }

    1106. 

  1106.                 }

    1107. 

  1107.             }

    1108. 

  1108. 

    1109. 

  1109.             element = element.parentNode;

    1110. 

  1110.         }

    1111. 

  1111. 

    1112. 

  1112.         if (!proposedSettings) {

    1113. 

  1113.             return this._createPostBackSettings(false);

    1114. 

  1114.         }

    1115. 

  1115.         else {

    1116. 

  1116.             return proposedSettings;

    1117. 

  1117.         }

    1118. 

  1118.     },

    1119. 

  1119. 

    1120. 

  1120.     _getScrollPosition: function PageRequestManager$_getScrollPosition() {

    1121. 

  1121.         var d = document.documentElement;

    1122. 

  1122.         if (d && (this._validPosition(d.scrollLeft) || this._validPosition(d.scrollTop))) {

    1123. 

  1123.             return {

    1124. 

  1124.                 x: d.scrollLeft,

    1125. 

  1125.                 y: d.scrollTop

    1126. 

  1126.             };

    1127. 

  1127.         }

    1128. 

  1128.         else {

    1129. 

  1129.             d = document.body;

    1130. 

  1130.             if (d && (this._validPosition(d.scrollLeft) || this._validPosition(d.scrollTop))) {

    1131. 

  1131.                 return {

    1132. 

  1132.                     x: d.scrollLeft,

    1133. 

  1133.                     y: d.scrollTop

    1134. 

  1134.                 };

    1135. 

  1135.             }

    1136. 

  1136.             else {

    1137. 

  1137.                 if (this._validPosition(window.pageXOffset) || this._validPosition(window.pageYOffset)) {

    1138. 

  1138.                     return {

    1139. 

  1139.                         x: window.pageXOffset,

    1140. 

  1140.                         y: window.pageYOffset

    1141. 

  1141.                     };

    1142. 

  1142.                 }

    1143. 

  1143.                 else {

    1144. 

  1144.                     return {

    1145. 

  1145.                         x: 0,

    1146. 

  1146.                         y: 0

    1147. 

  1147.                     };

    1148. 

  1148.                 }

    1149. 

  1149.             }

    1150. 

  1150.         }

    1151. 

  1151.     },

    1152. 

  1152. 

    1153. 

  1153.     _initializeInternal: function PageRequestManager$_initializeInternal(scriptManagerID, formElement, updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, asyncPostBackTimeout, masterPageUniqueID) {

    1154. 

  1154.         if (this._prmInitialized) {

    1155. 

  1155.             throw Error.invalidOperation(Sys.WebForms.Res.PRM_CannotRegisterTwice);

    1156. 

  1156.         }

    1157. 

  1157.         this._prmInitialized = true;

    1158. 

  1158.         this._masterPageUniqueID = masterPageUniqueID;

    1159. 

  1159.         this._scriptManagerID = scriptManagerID;

    1160. 

  1160.         this._form = Sys.UI.DomElement.resolveElement(formElement);

    1161. 

  1161.         this._onsubmit = this._form.onsubmit;

    1162. 

  1162.         this._form.onsubmit = null;

    1163. 

  1163.         this._onFormSubmitHandler = Function.createDelegate(this, this._onFormSubmit);

    1164. 

  1164.         this._onFormElementClickHandler = Function.createDelegate(this, this._onFormElementClick);

    1165. 

  1165.         this._onWindowUnloadHandler = Function.createDelegate(this, this._onWindowUnload);

    1166. 

  1166.         Sys.UI.DomEvent.addHandler(this._form, 'submit', this._onFormSubmitHandler);

    1167. 

  1167.         Sys.UI.DomEvent.addHandler(this._form, 'click', this._onFormElementClickHandler);

    1168. 

  1168.         Sys.UI.DomEvent.addHandler(window, 'unload', this._onWindowUnloadHandler);

    1169. 

  1169. 

    1170. 

  1170.         this._originalDoPostBack = window.__doPostBack;

    1171. 

  1171.         if (this._originalDoPostBack) {

    1172. 

  1172.             window.__doPostBack = Function.createDelegate(this, this._doPostBack);

    1173. 

  1173.         }

    1174. 

  1174.         this._originalDoPostBackWithOptions = window.WebForm_DoPostBackWithOptions;

    1175. 

  1175.         if (this._originalDoPostBackWithOptions) {

    1176. 

  1176.             window.WebForm_DoPostBackWithOptions = Function.createDelegate(this, this._doPostBackWithOptions);

    1177. 

  1177.         }

    1178. 

  1178.         this._originalFireDefaultButton = window.WebForm_FireDefaultButton;

    1179. 

  1179.         if (this._originalFireDefaultButton) {

    1180. 

  1180.             window.WebForm_FireDefaultButton = Function.createDelegate(this, this._fireDefaultButton);

    1181. 

  1181.         }

    1182. 

  1182.         this._originalDoCallback = window.WebForm_DoCallback;

    1183. 

  1183.         if (this._originalDoCallback) {

    1184. 

  1184.             window.WebForm_DoCallback = Function.createDelegate(this, this._doCallback);

    1185. 

  1185.         }

    1186. 

  1186. 

    1187. 

  1187.         this._pageLoadedHandler = Function.createDelegate(this, this._pageLoadedInitialLoad);

    1188. 

  1188.         Sys.UI.DomEvent.addHandler(window, 'load', this._pageLoadedHandler);

    1189. 

  1189.         if (updatePanelIDs) {

    1190. 

  1190.             this._updateControls(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, asyncPostBackTimeout, true);

    1191. 

  1191.         }

    1192. 

  1192.     },

    1193. 

  1193. 

    1194. 

  1194.     _matchesParentIDInList: function PageRequestManager$_matchesParentIDInList(clientID, parentIDList) {

    1195. 

  1195.         for (var i = 0, l = parentIDList.length; i < l; i++) {

    1196. 

  1196.             if (clientID.startsWith(parentIDList[i] + "_")) {

    1197. 

  1197.                 return true;

    1198. 

  1198.             }

    1199. 

  1199.         }

    1200. 

  1200.         return false;

    1201. 

  1201.     },

    1202. 

  1202.     

    1203. 

  1203.     _onFormElementActive: function PageRequestManager$_onFormElementActive(element, offsetX, offsetY) {

    1204. 

  1204.         if (element.disabled) {

    1205. 

  1205.             return;

    1206. 

  1206.         }

    1207. 

  1207. 

    1208. 

  1208.         this._postBackSettings = this._getPostBackSettings(element, element.name);

    1209. 

  1209. 

    1210. 

  1210.         if (element.name) {

    1211. 

  1211.             var tagName = element.tagName.toUpperCase();

    1212. 

  1212.             if (tagName === 'INPUT') {

    1213. 

  1213.                 var type = element.type;

    1214. 

  1214.                 if (type === 'submit') {

    1215. 

  1215.                     this._additionalInput = encodeURIComponent(element.name) + '=' + encodeURIComponent(element.value);

    1216. 

  1216.                 }

    1217. 

  1217.                 else if (type === 'image') {

    1218. 

  1218.                     this._additionalInput = encodeURIComponent(element.name) + '.x=' + offsetX + '&' + encodeURIComponent(element.name) + '.y=' + offsetY;

    1219. 

  1219.                 }

    1220. 

  1220.             }

    1221. 

  1221.             else if ((tagName === 'BUTTON') && (element.name.length !== 0) && (element.type === 'submit')) {

    1222. 

  1222.                 this._additionalInput = encodeURIComponent(element.name) + '=' + encodeURIComponent(element.value);

    1223. 

  1223.             }

    1224. 

  1224.         }

    1225. 

  1225.     },

    1226. 

  1226. 

    1227. 

  1227.     _onFormElementClick: function PageRequestManager$_onFormElementClick(evt) {

    1228. 

  1228.         this._activeDefaultButtonClicked = (evt.target === this._activeDefaultButton);

    1229. 

  1229.         this._onFormElementActive(evt.target, evt.offsetX, evt.offsetY);

    1230. 

  1230.     },

    1231. 

  1231. 

    1232. 

  1232.     _onFormSubmit: function PageRequestManager$_onFormSubmit(evt) {

    1233. 

  1233.         var i, l, continueSubmit = true,

    1234. 

  1234.             isCrossPost = this._isCrossPost;

    1235. 

  1235.         this._isCrossPost = false;

    1236. 

  1236. 

    1237. 

  1237.         if (this._onsubmit) {

    1238. 

  1238.             continueSubmit = this._onsubmit();

    1239. 

  1239.         }

    1240. 

  1240. 

    1241. 

  1241.         if (continueSubmit) {

    1242. 

  1242.             for (i = 0, l = this._onSubmitStatements.length; i < l; i++) {

    1243. 

  1243.                 if (!this._onSubmitStatements[i]()) {

    1244. 

  1244.                     continueSubmit = false;

    1245. 

  1245.                     break;

    1246. 

  1246.                 }

    1247. 

  1247.             }

    1248. 

  1248.         }

    1249. 

  1249. 

    1250. 

  1250.         if (!continueSubmit) {

    1251. 

  1251.             if (evt) {

    1252. 

  1252.                 evt.preventDefault();

    1253. 

  1253.             }

    1254. 

  1254.             return;

    1255. 

  1255.         }

    1256. 

  1256. 

    1257. 

  1257.         var form = this._form;

    1258. 

  1258.         if (isCrossPost) {

    1259. 

  1259.             return;

    1260. 

  1260.         }

    1261. 

  1261. 

    1262. 

  1262.         if (this._activeDefaultButton && !this._activeDefaultButtonClicked) {

    1263. 

  1263.             this._onFormElementActive(this._activeDefaultButton, 0, 0);

    1264. 

  1264.         }

    1265. 

  1265. 

    1266. 

  1266.         if (!this._postBackSettings || !this._postBackSettings.async) {

    1267. 

  1267.             return;

    1268. 

  1268.         }

    1269. 

  1269. 

    1270. 

  1270.         var formBody = new Sys.StringBuilder(),

    1271. 

  1271.             count = form.elements.length,

    1272. 

  1272.             panelID = this._createPanelID(null, this._postBackSettings);

    1273. 

  1273.         formBody.append(panelID);

    1274. 

  1274. 

    1275. 

  1275.         for (i = 0; i < count; i++) {

    1276. 

  1276.             var element = form.elements[i];

    1277. 

  1277.             var name = element.name;

    1278. 

  1278.             if (typeof(name) === "undefined" || (name === null) || (name.length === 0) || (name === this._scriptManagerID)) {

    1279. 

  1279.                 continue;

    1280. 

  1280.             }

    1281. 

  1281. 

    1282. 

  1282.             var tagName = element.tagName.toUpperCase();

    1283. 

  1283. 

    1284. 

  1284.             if (tagName === 'INPUT') {

    1285. 

  1285.                 var type = element.type;

    1286. 

  1286.                 if ((type === 'text') ||

    1287. 

  1287.                     (type === 'password') ||

    1288. 

  1288.                     (type === 'hidden') ||

    1289. 

  1289.                     (((type === 'checkbox') || (type === 'radio')) && element.checked)) {

    1290. 

  1290.                     formBody.append(encodeURIComponent(name));

    1291. 

  1291.                     formBody.append('=');

    1292. 

  1292.                     formBody.append(encodeURIComponent(element.value));

    1293. 

  1293.                     formBody.append('&');

    1294. 

  1294.                 }

    1295. 

  1295.             }

    1296. 

  1296.             else if (tagName === 'SELECT') {

    1297. 

  1297.                 var optionCount = element.options.length;

    1298. 

  1298.                 for (var j = 0; j < optionCount; j++) {

    1299. 

  1299.                     var option = element.options[j];

    1300. 

  1300.                     if (option.selected) {

    1301. 

  1301.                         formBody.append(encodeURIComponent(name));

    1302. 

  1302.                         formBody.append('=');

    1303. 

  1303.                         formBody.append(encodeURIComponent(option.value));

    1304. 

  1304.                         formBody.append('&');

    1305. 

  1305.                     }

    1306. 

  1306.                 }

    1307. 

  1307.             }

    1308. 

  1308.             else if (tagName === 'TEXTAREA') {

    1309. 

  1309.                 formBody.append(encodeURIComponent(name));

    1310. 

  1310.                 formBody.append('=');

    1311. 

  1311.                 formBody.append(encodeURIComponent(element.value));

    1312. 

  1312.                 formBody.append('&');

    1313. 

  1313.             }

    1314. 

  1314.         }

    1315. 

  1315. 

    1316. 

  1316.         formBody.append("__ASYNCPOST=true&");

    1317. 

  1317. 

    1318. 

  1318.         if (this._additionalInput) {

    1319. 

  1319.             formBody.append(this._additionalInput);

    1320. 

  1320.             this._additionalInput = null;

    1321. 

  1321.         }

    1322. 

  1322.         

    1323. 

  1323.         var request = new Sys.Net.WebRequest();

    1324. 

  1324.         var action = form.action;

    1325. 

  1325.         if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {

    1326. 

  1326.             var fragmentIndex = action.indexOf('#');

    1327. 

  1327.             if (fragmentIndex !== -1) {

    1328. 

  1328.                 action = action.substr(0, fragmentIndex);

    1329. 

  1329.             }

    1330. 

  1330.             var queryIndex = action.indexOf('?');

    1331. 

  1331.             if (queryIndex !== -1) {

    1332. 

  1332.                 var path = action.substr(0, queryIndex);

    1333. 

  1333.                 if (path.indexOf("%") === -1) {

    1334. 

  1334.                     action = encodeURI(path) + action.substr(queryIndex);

    1335. 

  1335.                 }

    1336. 

  1336.             }

    1337. 

  1337.             else if (action.indexOf("%") === -1) {

    1338. 

  1338.                 action = encodeURI(action);

    1339. 

  1339.             }

    1340. 

  1340.         }

    1341. 

  1341.         request.set_url(action);

    1342. 

  1342.         request.get_headers()['X-MicrosoftAjax'] = 'Delta=true';

    1343. 

  1343.         request.get_headers()['Cache-Control'] = 'no-cache';

    1344. 

  1344.         request.set_timeout(this._asyncPostBackTimeout);

    1345. 

  1345.         request.add_completed(Function.createDelegate(this, this._onFormSubmitCompleted));

    1346. 

  1346.         request.set_body(formBody.toString());

    1347. 

  1347.         var panelsToUpdate, eventArgs;

    1348. 

  1348.         panelsToUpdate = this._postBackSettings.panelsToUpdate;

    1349. 

  1349.         eventArgs = new Sys.WebForms.InitializeRequestEventArgs(request, this._postBackSettings.sourceElement, panelsToUpdate);

    1350. 

  1350.         Sys.Observer.raiseEvent(this, "initializeRequest", eventArgs);

    1351. 

  1351.         continueSubmit = !eventArgs.get_cancel();

    1352. 

  1352. 

    1353. 

  1353.         if (!continueSubmit) {

    1354. 

  1354.             if (evt) {

    1355. 

  1355.                 evt.preventDefault();

    1356. 

  1356.             }

    1357. 

  1357.             return;

    1358. 

  1358.         }

    1359. 

  1359.         

    1360. 

  1360.         if (eventArgs && eventArgs._updated) {

    1361. 

  1361.             panelsToUpdate = eventArgs.get_updatePanelsToUpdate();

    1362. 

  1362.             request.set_body(request.get_body().replace(panelID, this._createPanelID(panelsToUpdate, this._postBackSettings)));

    1363. 

  1363.         }

    1364. 

  1364. 

    1365. 

  1365.         this._scrollPosition = this._getScrollPosition();

    1366. 

  1366. 

    1367. 

  1367. 

    1368. 

  1368.         this.abortPostBack();

    1369. 

  1369. 

    1370. 

  1370.         eventArgs = new Sys.WebForms.BeginRequestEventArgs(request, this._postBackSettings.sourceElement,

    1371. 

  1371.             panelsToUpdate || this._postBackSettings.panelsToUpdate);

    1372. 

  1372.         Sys.Observer.raiseEvent(this, "beginRequest", eventArgs);

    1373. 

  1373.         

    1374. 

  1374.         if (this._originalDoCallback) {

    1375. 

  1375.             this._cancelPendingCallbacks();

    1376. 

  1376.         }

    1377. 

  1377. 

    1378. 

  1378.         this._request = request;

    1379. 

  1379.         this._processingRequest = false;

    1380. 

  1380.         request.invoke();

    1381. 

  1381. 

    1382. 

  1382.         if (evt) {

    1383. 

  1383.             evt.preventDefault();

    1384. 

  1384.         }

    1385. 

  1385.     },

    1386. 

  1386. 

    1387. 

  1387.     _onFormSubmitCompleted: function PageRequestManager$_onFormSubmitCompleted(sender, eventArgs) {

    1388. 

  1388.         this._processingRequest = true;

    1389. 

  1389. 

    1390. 

  1390. 

    1391. 

  1391.         if (sender.get_timedOut()) {

    1392. 

  1392.             this._endPostBack(this._createPageRequestManagerTimeoutError(), sender, null);

    1393. 

  1393.             return;

    1394. 

  1394.         }

    1395. 

  1395. 

    1396. 

  1396.         if (sender.get_aborted()) {

    1397. 

  1397.             this._endPostBack(null, sender, null);

    1398. 

  1398.             return;

    1399. 

  1399.         }

    1400. 

  1400. 

    1401. 

  1401.         if (!this._request || (sender.get_webRequest() !== this._request)) {

    1402. 

  1402.             return;

    1403. 

  1403.         }

    1404. 

  1404. 

    1405. 

  1405.         if (sender.get_statusCode() !== 200) {

    1406. 

  1406.             this._endPostBack(this._createPageRequestManagerServerError(sender.get_statusCode()), sender, null);

    1407. 

  1407.             return;

    1408. 

  1408.         }

    1409. 

  1409. 

    1410. 

  1410.         var data = this._parseDelta(sender);

    1411. 

  1411.         if (!data) return;

    1412. 

  1412.         

    1413. 

  1413.         var i, l;

    1414. 

  1414. 

    1415. 

  1415.         if (data.asyncPostBackControlIDsNode && data.postBackControlIDsNode &&

    1416. 

  1416.             data.updatePanelIDsNode && data.panelsToRefreshNode && data.childUpdatePanelIDsNode) {

    1417. 

  1417.             

    1418. 

  1418.             var oldUpdatePanelIDs = this._updatePanelIDs,

    1419. 

  1419.                 oldUpdatePanelClientIDs = this._updatePanelClientIDs;

    1420. 

  1420.             var childUpdatePanelIDsString = data.childUpdatePanelIDsNode.content;

    1421. 

  1421.             var childUpdatePanelIDs = childUpdatePanelIDsString.length ? childUpdatePanelIDsString.split(',') : [];

    1422. 

  1422. 

    1423. 

  1423.             var asyncPostBackControlIDsArray = this._splitNodeIntoArray(data.asyncPostBackControlIDsNode);

    1424. 

  1424.             var postBackControlIDsArray = this._splitNodeIntoArray(data.postBackControlIDsNode);

    1425. 

  1425.             var updatePanelIDsArray = this._splitNodeIntoArray(data.updatePanelIDsNode);

    1426. 

  1426.             var panelsToRefreshIDs = this._splitNodeIntoArray(data.panelsToRefreshNode);

    1427. 

  1427. 

    1428. 

  1428.             var v4 = data.version4;

    1429. 

  1429.             for (i = 0, l = panelsToRefreshIDs.length; i < l; i+= (v4 ? 2 : 1)) {

    1430. 

  1430.                 var panelClientID = (v4 ? panelsToRefreshIDs[i+1] : "") || this._uniqueIDToClientID(panelsToRefreshIDs[i]);

    1431. 

  1431.                 if (!document.getElementById(panelClientID)) {

    1432. 

  1432.                     this._endPostBack(Error.invalidOperation(String.format(Sys.WebForms.Res.PRM_MissingPanel, panelClientID)), sender, data);

    1433. 

  1433.                     return;

    1434. 

  1434.                 }

    1435. 

  1435.             }

    1436. 

  1436.             

    1437. 

  1437.             var updatePanelData = this._processUpdatePanelArrays(

    1438. 

  1438.                 updatePanelIDsArray,

    1439. 

  1439.                 asyncPostBackControlIDsArray,

    1440. 

  1440.                 postBackControlIDsArray, v4);

    1441. 

  1441.             updatePanelData.oldUpdatePanelIDs = oldUpdatePanelIDs;

    1442. 

  1442.             updatePanelData.oldUpdatePanelClientIDs = oldUpdatePanelClientIDs;

    1443. 

  1443.             updatePanelData.childUpdatePanelIDs = childUpdatePanelIDs;

    1444. 

  1444.             updatePanelData.panelsToRefreshIDs = panelsToRefreshIDs;

    1445. 

  1445.             data.updatePanelData = updatePanelData;

    1446. 

  1446.         }

    1447. 

  1447. 

    1448. 

  1448.         data.dataItems = {};

    1449. 

  1449.         var node;

    1450. 

  1450.         for (i = 0, l = data.dataItemNodes.length; i < l; i++) {

    1451. 

  1451.             node = data.dataItemNodes[i];

    1452. 

  1452.             data.dataItems[node.id] = node.content;

    1453. 

  1453.         }

    1454. 

  1454.         for (i = 0, l = data.dataItemJsonNodes.length; i < l; i++) {

    1455. 

  1455.             node = data.dataItemJsonNodes[i];

    1456. 

  1456.             data.dataItems[node.id] = Sys.Serialization.JavaScriptSerializer.deserialize(node.content);

    1457. 

  1457.         }

    1458. 

  1458. 

    1459. 

  1459.         var handler = Sys.Observer._getContext(this, true).events.getHandler("pageLoading");

    1460. 

  1460.         if (handler) {

    1461. 

  1461.             handler(this, this._getPageLoadingEventArgs(data));

    1462. 

  1462.         }

    1463. 

  1463. 

    1464. 

  1464. 

    1465. 

  1465.         

    1466. 

  1466.         Sys._ScriptLoader.readLoadedScripts();

    1467. 

  1467. 

    1468. 

  1468.         Sys.Application.beginCreateComponents();

    1469. 

  1469. 

    1470. 

  1470.         var scriptLoader = Sys._ScriptLoader.getInstance();

    1471. 

  1471.         this._queueScripts(scriptLoader, data.scriptBlockNodes, true, false);

    1472. 

  1472.         

    1473. 

  1473.         this._processingRequest = true;

    1474. 

  1474. 

    1475. 

  1475.         scriptLoader.loadScripts(0,

    1476. 

  1476.             Function.createDelegate(this, Function.createCallback(this._scriptIncludesLoadComplete, data)),

    1477. 

  1477.             Function.createDelegate(this, Function.createCallback(this._scriptIncludesLoadFailed, data)),

    1478. 

  1478.             null);        

    1479. 

  1479.     },

    1480. 

  1480.     

    1481. 

  1481.     _onWindowUnload: function PageRequestManager$_onWindowUnload(evt) {

    1482. 

  1482.         this.dispose();

    1483. 

  1483.     },

    1484. 

  1484. 

    1485. 

  1485.     _pageLoaded: function PageRequestManager$_pageLoaded(initialLoad, data) {

    1486. 

  1486.         Sys.Observer.raiseEvent(this, "pageLoaded", this._getPageLoadedEventArgs(initialLoad, data));

    1487. 

  1487.         if (!initialLoad) {

    1488. 

  1488.             Sys.Application.raiseLoad();

    1489. 

  1489.         }

    1490. 

  1490.     },

    1491. 

  1491. 

    1492. 

  1492.     _pageLoadedInitialLoad: function PageRequestManager$_pageLoadedInitialLoad(evt) {

    1493. 

  1493.         this._pageLoaded(true, null);

    1494. 

  1494.     },

    1495. 

  1495.     

    1496. 

  1496.     _parseDelta: function PageRequestManager$_parseDelta(executor) {

    1497. 

  1497.         var reply = executor.get_responseData();

    1498. 

  1498.         var delimiterIndex, len, type, id, content;

    1499. 

  1499.         var replyIndex = 0;

    1500. 

  1500.         var parserErrorDetails = null;

    1501. 

  1501.         var delta = [];

    1502. 

  1502. 

    1503. 

  1503.         while (replyIndex < reply.length) {

    1504. 

  1504.             delimiterIndex = reply.indexOf('|', replyIndex);

    1505. 

  1505.             if (delimiterIndex === -1) {

    1506. 

  1506.                 parserErrorDetails = this._findText(reply, replyIndex);

    1507. 

  1507.                 break;

    1508. 

  1508.             }

    1509. 

  1509.             len = parseInt(reply.substring(replyIndex, delimiterIndex), 10);

    1510. 

  1510.             if ((len % 1) !== 0) {

    1511. 

  1511.                 parserErrorDetails = this._findText(reply, replyIndex);

    1512. 

  1512.                 break;

    1513. 

  1513.             }

    1514. 

  1514.             replyIndex = delimiterIndex + 1;

    1515. 

  1515. 

    1516. 

  1516.             delimiterIndex = reply.indexOf('|', replyIndex);

    1517. 

  1517.             if (delimiterIndex === -1) {

    1518. 

  1518.                 parserErrorDetails = this._findText(reply, replyIndex);

    1519. 

  1519.                 break;

    1520. 

  1520.             }

    1521. 

  1521.             type = reply.substring(replyIndex, delimiterIndex);

    1522. 

  1522.             replyIndex = delimiterIndex + 1;

    1523. 

  1523. 

    1524. 

  1524.             delimiterIndex = reply.indexOf('|', replyIndex);

    1525. 

  1525.             if (delimiterIndex === -1) {

    1526. 

  1526.                 parserErrorDetails = this._findText(reply, replyIndex);

    1527. 

  1527.                 break;

    1528. 

  1528.             }

    1529. 

  1529.             id = reply.substring(replyIndex, delimiterIndex);

    1530. 

  1530.             replyIndex = delimiterIndex + 1;

    1531. 

  1531. 

    1532. 

  1532.             if ((replyIndex + len) >= reply.length) {

    1533. 

  1533.                 parserErrorDetails = this._findText(reply, reply.length);

    1534. 

  1534.                 break;

    1535. 

  1535.             }

    1536. 

  1536.             content = reply.substr(replyIndex, len);

    1537. 

  1537.             replyIndex += len;

    1538. 

  1538. 

    1539. 

  1539.             if (reply.charAt(replyIndex) !== '|') {

    1540. 

  1540.                 parserErrorDetails = this._findText(reply, replyIndex);

    1541. 

  1541.                 break;

    1542. 

  1542.             }

    1543. 

  1543. 

    1544. 

  1544.             replyIndex++;

    1545. 

  1545. 

    1546. 

  1546.             Array.add(delta, {type: type, id: id, content: content});

    1547. 

  1547.         }

    1548. 

  1548. 

    1549. 

  1549.         if (parserErrorDetails) {

    1550. 

  1550.             this._endPostBack(this._createPageRequestManagerParserError(String.format(Sys.WebForms.Res.PRM_ParserErrorDetails, parserErrorDetails)), executor, null);

    1551. 

  1551.             return null;

    1552. 

  1552.         }

    1553. 

  1553. 

    1554. 

  1554.         var updatePanelNodes = [];

    1555. 

  1555.         var hiddenFieldNodes = [];

    1556. 

  1556.         var arrayDeclarationNodes = [];

    1557. 

  1557.         var scriptBlockNodes = [];

    1558. 

  1558.         var scriptStartupNodes = [];

    1559. 

  1559.         var expandoNodes = [];

    1560. 

  1560.         var onSubmitNodes = [];

    1561. 

  1561.         var dataItemNodes = [];

    1562. 

  1562.         var dataItemJsonNodes = [];

    1563. 

  1563.         var scriptDisposeNodes = [];

    1564. 

  1564.         var asyncPostBackControlIDsNode, postBackControlIDsNode,

    1565. 

  1565.             updatePanelIDsNode, asyncPostBackTimeoutNode,

    1566. 

  1566.             childUpdatePanelIDsNode, panelsToRefreshNode, formActionNode,

    1567. 

  1567.             versionNode;

    1568. 

  1568. 

    1569. 

  1569.         for (var i = 0, l = delta.length; i < l; i++) {

    1570. 

  1570.             var deltaNode = delta[i];

    1571. 

  1571.             switch (deltaNode.type) {

    1572. 

  1572.                 case "#":

    1573. 

  1573.                     versionNode = deltaNode;

    1574. 

  1574.                     break;

    1575. 

  1575.                 case "updatePanel":

    1576. 

  1576.                     Array.add(updatePanelNodes, deltaNode);

    1577. 

  1577.                     break;

    1578. 

  1578.                 case "hiddenField":

    1579. 

  1579.                     Array.add(hiddenFieldNodes, deltaNode);

    1580. 

  1580.                     break;

    1581. 

  1581.                 case "arrayDeclaration":

    1582. 

  1582.                     Array.add(arrayDeclarationNodes, deltaNode);

    1583. 

  1583.                     break;

    1584. 

  1584.                 case "scriptBlock":

    1585. 

  1585.                     Array.add(scriptBlockNodes, deltaNode);

    1586. 

  1586.                     break;

    1587. 

  1587.                 case "scriptStartupBlock":

    1588. 

  1588.                     Array.add(scriptStartupNodes, deltaNode);

    1589. 

  1589.                     break;

    1590. 

  1590.                 case "expando":

    1591. 

  1591.                     Array.add(expandoNodes, deltaNode);

    1592. 

  1592.                     break;

    1593. 

  1593.                 case "onSubmit":

    1594. 

  1594.                     Array.add(onSubmitNodes, deltaNode);

    1595. 

  1595.                     break;

    1596. 

  1596.                 case "asyncPostBackControlIDs":

    1597. 

  1597.                     asyncPostBackControlIDsNode = deltaNode;

    1598. 

  1598.                     break;

    1599. 

  1599.                 case "postBackControlIDs":

    1600. 

  1600.                     postBackControlIDsNode = deltaNode;

    1601. 

  1601.                     break;

    1602. 

  1602.                 case "updatePanelIDs":

    1603. 

  1603.                     updatePanelIDsNode = deltaNode;

    1604. 

  1604.                     break;

    1605. 

  1605.                 case "asyncPostBackTimeout":

    1606. 

  1606.                     asyncPostBackTimeoutNode = deltaNode;

    1607. 

  1607.                     break;

    1608. 

  1608.                 case "childUpdatePanelIDs":

    1609. 

  1609.                     childUpdatePanelIDsNode = deltaNode;

    1610. 

  1610.                     break;

    1611. 

  1611.                 case "panelsToRefreshIDs":

    1612. 

  1612.                     panelsToRefreshNode = deltaNode;

    1613. 

  1613.                     break;

    1614. 

  1614.                 case "formAction":

    1615. 

  1615.                     formActionNode = deltaNode;

    1616. 

  1616.                     break;

    1617. 

  1617.                 case "dataItem":

    1618. 

  1618.                     Array.add(dataItemNodes, deltaNode);

    1619. 

  1619.                     break;

    1620. 

  1620.                 case "dataItemJson":

    1621. 

  1621.                     Array.add(dataItemJsonNodes, deltaNode);

    1622. 

  1622.                     break;

    1623. 

  1623.                 case "scriptDispose":

    1624. 

  1624.                     Array.add(scriptDisposeNodes, deltaNode);

    1625. 

  1625.                     break;

    1626. 

  1626.                 case "pageRedirect":

    1627. 

  1627.                     if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {

    1628. 

  1628.                         var anchor = document.createElement("a");

    1629. 

  1629.                         anchor.style.display = 'none';

    1630. 

  1630.                         anchor.attachEvent("onclick", cancelBubble);

    1631. 

  1631.                         anchor.href = deltaNode.content;

    1632. 

  1632.                         this._form.parentNode.insertBefore(anchor, this._form);

    1633. 

  1633.                         anchor.click();

    1634. 

  1634.                         anchor.detachEvent("onclick", cancelBubble);

    1635. 

  1635.                         this._form.parentNode.removeChild(anchor);

    1636. 

  1636.                         

    1637. 

  1637.                         function cancelBubble(e) {

    1638. 

  1638.                             e.cancelBubble = true;

    1639. 

  1639.                         }

    1640. 

  1640.                     }

    1641. 

  1641.                     else {

    1642. 

  1642.                         window.location.href = deltaNode.content;

    1643. 

  1643.                     }

    1644. 

  1644.                     return null;

    1645. 

  1645.                 case "error":

    1646. 

  1646.                     this._endPostBack(this._createPageRequestManagerServerError(Number.parseInvariant(deltaNode.id), deltaNode.content), executor, null);

    1647. 

  1647.                     return null;

    1648. 

  1648.                 case "pageTitle":

    1649. 

  1649.                     document.title = deltaNode.content;

    1650. 

  1650.                     break;

    1651. 

  1651.                 case "focus":

    1652. 

  1652.                     this._controlIDToFocus = deltaNode.content;

    1653. 

  1653.                     break;

    1654. 

  1654.                 default:

    1655. 

  1655.                     this._endPostBack(this._createPageRequestManagerParserError(String.format(Sys.WebForms.Res.PRM_UnknownToken, deltaNode.type)), executor, null);

    1656. 

  1656.                     return null;

    1657. 

  1657.             } // switch

    1658. 

  1658.         } // for (var i = 0, l = delta.length; i < l; i++)

    1659. 

  1659.         return {

    1660. 

  1660.             version4: versionNode ? (parseFloat(versionNode.content) >= 4) : false,

    1661. 

  1661.             executor: executor,

    1662. 

  1662.             updatePanelNodes: updatePanelNodes,

    1663. 

  1663.             hiddenFieldNodes: hiddenFieldNodes,

    1664. 

  1664.             arrayDeclarationNodes: arrayDeclarationNodes,

    1665. 

  1665.             scriptBlockNodes: scriptBlockNodes,

    1666. 

  1666.             scriptStartupNodes: scriptStartupNodes,

    1667. 

  1667.             expandoNodes: expandoNodes,

    1668. 

  1668.             onSubmitNodes: onSubmitNodes,

    1669. 

  1669.             dataItemNodes: dataItemNodes,

    1670. 

  1670.             dataItemJsonNodes: dataItemJsonNodes,

    1671. 

  1671.             scriptDisposeNodes: scriptDisposeNodes,

    1672. 

  1672.             asyncPostBackControlIDsNode: asyncPostBackControlIDsNode,

    1673. 

  1673.             postBackControlIDsNode: postBackControlIDsNode,

    1674. 

  1674.             updatePanelIDsNode: updatePanelIDsNode,

    1675. 

  1675.             asyncPostBackTimeoutNode: asyncPostBackTimeoutNode,

    1676. 

  1676.             childUpdatePanelIDsNode: childUpdatePanelIDsNode,

    1677. 

  1677.             panelsToRefreshNode: panelsToRefreshNode,

    1678. 

  1678.             formActionNode: formActionNode };

    1679. 

  1679.     },

    1680. 

  1680.     

    1681. 

  1681.     _processUpdatePanelArrays: function PageRequestManager$_processUpdatePanelArrays(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, version4) {

    1682. 

  1682.         var newUpdatePanelIDs, newUpdatePanelClientIDs, newUpdatePanelHasChildrenAsTriggers;

    1683. 

  1683.         

    1684. 

  1684.         if (updatePanelIDs) {

    1685. 

  1685.             var l = updatePanelIDs.length,

    1686. 

  1686.                 m = version4 ? 2 : 1;

    1687. 

  1687.             newUpdatePanelIDs = new Array(l/m);

    1688. 

  1688.             newUpdatePanelClientIDs = new Array(l/m);

    1689. 

  1689.             newUpdatePanelHasChildrenAsTriggers = new Array(l/m);

    1690. 

  1690.             

    1691. 

  1691.             for (var i = 0, j = 0; i < l; i += m, j++) {

    1692. 

  1692.                 var ct,

    1693. 

  1693.                     uniqueID = updatePanelIDs[i],

    1694. 

  1694.                     clientID = version4 ? updatePanelIDs[i+1] : "";

    1695. 

  1695.                 ct = (uniqueID.charAt(0) === 't');

    1696. 

  1696.                 uniqueID = uniqueID.substr(1);

    1697. 

  1697.                 if (!clientID) {

    1698. 

  1698.                     clientID = this._uniqueIDToClientID(uniqueID);

    1699. 

  1699.                 }

    1700. 

  1700.                 newUpdatePanelHasChildrenAsTriggers[j] = ct;

    1701. 

  1701.                 newUpdatePanelIDs[j] = uniqueID;

    1702. 

  1702.                 newUpdatePanelClientIDs[j] = clientID;

    1703. 

  1703.             }

    1704. 

  1704.         }

    1705. 

  1705.         else {

    1706. 

  1706.             newUpdatePanelIDs = [];

    1707. 

  1707.             newUpdatePanelClientIDs = [];

    1708. 

  1708.             newUpdatePanelHasChildrenAsTriggers = [];

    1709. 

  1709.         }

    1710. 

  1710. 

    1711. 

  1711.         var newAsyncPostBackControlIDs = [];

    1712. 

  1712.         var newAsyncPostBackControlClientIDs = [];

    1713. 

  1713.         this._convertToClientIDs(asyncPostBackControlIDs, newAsyncPostBackControlIDs, newAsyncPostBackControlClientIDs, version4);

    1714. 

  1714. 

    1715. 

  1715.         var newPostBackControlIDs = [];

    1716. 

  1716.         var newPostBackControlClientIDs = [];

    1717. 

  1717.         this._convertToClientIDs(postBackControlIDs, newPostBackControlIDs, newPostBackControlClientIDs, version4);

    1718. 

  1718.         

    1719. 

  1719.         return {

    1720. 

  1720.             updatePanelIDs: newUpdatePanelIDs,

    1721. 

  1721.             updatePanelClientIDs: newUpdatePanelClientIDs,

    1722. 

  1722.             updatePanelHasChildrenAsTriggers: newUpdatePanelHasChildrenAsTriggers,

    1723. 

  1723.             asyncPostBackControlIDs: newAsyncPostBackControlIDs,

    1724. 

  1724.             asyncPostBackControlClientIDs: newAsyncPostBackControlClientIDs,

    1725. 

  1725.             postBackControlIDs: newPostBackControlIDs,

    1726. 

  1726.             postBackControlClientIDs: newPostBackControlClientIDs

    1727. 

  1727.         };

    1728. 

  1728.     },

    1729. 

  1729.     

    1730. 

  1730.     _queueScripts: function PageRequestManager$_queueScripts(scriptLoader, scriptBlockNodes, queueIncludes, queueBlocks) {

    1731. 

  1731.         for (var i = 0, l = scriptBlockNodes.length; i < l; i++) {

    1732. 

  1732.             var scriptBlockType = scriptBlockNodes[i].id;

    1733. 

  1733.             switch (scriptBlockType) {

    1734. 

  1734.                 case "ScriptContentNoTags":

    1735. 

  1735.                     if (!queueBlocks) {

    1736. 

  1736.                         continue;

    1737. 

  1737.                     }

    1738. 

  1738.                     scriptLoader.queueScriptBlock(scriptBlockNodes[i].content);

    1739. 

  1739.                     break;

    1740. 

  1740.                 case "ScriptContentWithTags":

    1741. 

  1741.                     var scriptTagAttributes = window.eval("(" + scriptBlockNodes[i].content + ")");

    1742. 

  1742. 

    1743. 

  1743.                     if (scriptTagAttributes.src) {

    1744. 

  1744.                         if (!queueIncludes || Sys._ScriptLoader.isScriptLoaded(scriptTagAttributes.src)) {

    1745. 

  1745.                             continue;

    1746. 

  1746.                         }

    1747. 

  1747.                     }

    1748. 

  1748.                     else if (!queueBlocks) {

    1749. 

  1749.                         continue;

    1750. 

  1750.                     }

    1751. 

  1751. 

    1752. 

  1752.                     scriptLoader.queueCustomScriptTag(scriptTagAttributes);

    1753. 

  1753.                     break;

    1754. 

  1754.                 case "ScriptPath":

    1755. 

  1755.                     if (!queueIncludes || Sys._ScriptLoader.isScriptLoaded(scriptBlockNodes[i].content)) {

    1756. 

  1756.                         continue;

    1757. 

  1757.                     }

    1758. 

  1758. 

    1759. 

  1759.                     scriptLoader.queueScriptReference(scriptBlockNodes[i].content);

    1760. 

  1760.                     break;

    1761. 

  1761.             }

    1762. 

  1762.         }        

    1763. 

  1763.     },

    1764. 

  1764. 

    1765. 

  1765.     _registerDisposeScript: function PageRequestManager$_registerDisposeScript(panelID, disposeScript) {

    1766. 

  1766.         if (!this._scriptDisposes[panelID]) {

    1767. 

  1767.             this._scriptDisposes[panelID] = [disposeScript];

    1768. 

  1768.         }

    1769. 

  1769.         else {

    1770. 

  1770.             Array.add(this._scriptDisposes[panelID], disposeScript);

    1771. 

  1771.         }

    1772. 

  1772.     },

    1773. 

  1773.     

    1774. 

  1774.     _scriptIncludesLoadComplete: function PageRequestManager$_scriptIncludesLoadComplete(scriptLoader, data) {

    1775. 

  1775.         if (data.executor.get_webRequest() !== this._request) {

    1776. 

  1776.             return;

    1777. 

  1777.         }

    1778. 

  1778.         

    1779. 

  1779.         this._commitControls(data.updatePanelData,

    1780. 

  1780.             data.asyncPostBackTimeoutNode ? data.asyncPostBackTimeoutNode.content : null);

    1781. 

  1781. 

    1782. 

  1782.         if (data.formActionNode) {

    1783. 

  1783.             this._form.action = data.formActionNode.content;

    1784. 

  1784.         }

    1785. 

  1785.         

    1786. 

  1786.         var i, l, node;

    1787. 

  1787. 

    1788. 

  1788.         for (i = 0, l = data.updatePanelNodes.length; i < l; i++) {

    1789. 

  1789.             node = data.updatePanelNodes[i];

    1790. 

  1790.             var updatePanelElement = document.getElementById(node.id);

    1791. 

  1791. 

    1792. 

  1792.             if (!updatePanelElement) {

    1793. 

  1793.                 this._endPostBack(Error.invalidOperation(String.format(Sys.WebForms.Res.PRM_MissingPanel, node.id)), data.executor, data);

    1794. 

  1794.                 return;

    1795. 

  1795.             }

    1796. 

  1796. 

    1797. 

  1797.             this._updatePanel(updatePanelElement, node.content);

    1798. 

  1798.         }

    1799. 

  1799. 

    1800. 

  1800.         for (i = 0, l = data.scriptDisposeNodes.length; i < l; i++) {

    1801. 

  1801.             node = data.scriptDisposeNodes[i];

    1802. 

  1802.             this._registerDisposeScript(node.id, node.content);

    1803. 

  1803.         }

    1804. 

  1804. 

    1805. 

  1805.         for (i = 0, l = this._transientFields.length; i < l; i++) {

    1806. 

  1806.             var field = document.getElementById(this._transientFields[i]);

    1807. 

  1807.             if (field) {

    1808. 

  1808.                 var toRemove = field._isContained ? field.parentNode : field;

    1809. 

  1809.                 toRemove.parentNode.removeChild(toRemove);

    1810. 

  1810.             }

    1811. 

  1811.         }

    1812. 

  1812.         for (i = 0, l = data.hiddenFieldNodes.length; i < l; i++) {

    1813. 

  1813.             node = data.hiddenFieldNodes[i];

    1814. 

  1814.             this._createHiddenField(node.id, node.content);

    1815. 

  1815.         }

    1816. 

  1816.         

    1817. 

  1817.         if (data.scriptsFailed) {

    1818. 

  1818.             throw Sys._ScriptLoader._errorScriptLoadFailed(data.scriptsFailed.src, data.scriptsFailed.multipleCallbacks);

    1819. 

  1819.         }

    1820. 

  1820.         

    1821. 

  1821. 

    1822. 

  1822.         this._queueScripts(scriptLoader, data.scriptBlockNodes, false, true);

    1823. 

  1823. 

    1824. 

  1824.         var arrayScript = '';

    1825. 

  1825.         for (i = 0, l = data.arrayDeclarationNodes.length; i < l; i++) {

    1826. 

  1826.             node = data.arrayDeclarationNodes[i];

    1827. 

  1827.             arrayScript += "Sys.WebForms.PageRequestManager._addArrayElement('" + node.id + "', " + node.content + ");\r\n";

    1828. 

  1828.         }

    1829. 

  1829. 

    1830. 

  1830.         var expandoScript = '';

    1831. 

  1831.         for (i = 0, l = data.expandoNodes.length; i < l; i++) {

    1832. 

  1832.             node = data.expandoNodes[i];

    1833. 

  1833.             expandoScript += node.id + " = " + node.content + "\r\n";

    1834. 

  1834.         }

    1835. 

  1835. 

    1836. 

  1836.         if (arrayScript.length) {

    1837. 

  1837.             scriptLoader.queueScriptBlock(arrayScript);

    1838. 

  1838.         }

    1839. 

  1839.         if (expandoScript.length) {

    1840. 

  1840.             scriptLoader.queueScriptBlock(expandoScript);

    1841. 

  1841.         }

    1842. 

  1842.         

    1843. 

  1843.         this._queueScripts(scriptLoader, data.scriptStartupNodes, true, true);

    1844. 

  1844. 

    1845. 

  1845.         var onSubmitStatementScript = '';

    1846. 

  1846.         for (i = 0, l = data.onSubmitNodes.length; i < l; i++) {

    1847. 

  1847.             if (i === 0) {

    1848. 

  1848.                 onSubmitStatementScript = 'Array.add(Sys.WebForms.PageRequestManager.getInstance()._onSubmitStatements, function() {\r\n';

    1849. 

  1849.             }

    1850. 

  1850.             onSubmitStatementScript += data.onSubmitNodes[i].content + "\r\n";

    1851. 

  1851.         }

    1852. 

  1852.         if (onSubmitStatementScript.length) {

    1853. 

  1853.             onSubmitStatementScript += "\r\nreturn true;\r\n});\r\n";

    1854. 

  1854.             scriptLoader.queueScriptBlock(onSubmitStatementScript);

    1855. 

  1855.         }

    1856. 

  1856. 

    1857. 

  1857.         scriptLoader.loadScripts(0,

    1858. 

  1858.             Function.createDelegate(this, Function.createCallback(this._scriptsLoadComplete, data)), null, null);

    1859. 

  1859. 

    1860. 

  1860.     },

    1861. 

  1861.     

    1862. 

  1862.     _scriptIncludesLoadFailed: function PageRequestManager$_scriptIncludesLoadFailed(scriptLoader, scriptElement, multipleCallbacks, data) {

    1863. 

  1863.         data.scriptsFailed = { src: scriptElement.src, multipleCallbacks: multipleCallbacks };

    1864. 

  1864.         this._scriptIncludesLoadComplete(scriptLoader, data);

    1865. 

  1865.     },

    1866. 

  1866. 

    1867. 

  1867.     _scriptsLoadComplete: function PageRequestManager$_scriptsLoadComplete(scriptLoader, data) {

    1868. 

  1868.         var response = data.executor;

    1869. 

  1869. 

    1870. 

  1870.         if (window.__theFormPostData) {

    1871. 

  1871.             window.__theFormPostData = "";

    1872. 

  1872.         }

    1873. 

  1873.         if (window.__theFormPostCollection) {

    1874. 

  1874.             window.__theFormPostCollection = [];

    1875. 

  1875.         }

    1876. 

  1876.         if (window.WebForm_InitCallback) {

    1877. 

  1877.             window.WebForm_InitCallback();

    1878. 

  1878.         }

    1879. 

  1879. 

    1880. 

  1880.         if (this._scrollPosition) {

    1881. 

  1881.             if (window.scrollTo) {

    1882. 

  1882.                 window.scrollTo(this._scrollPosition.x, this._scrollPosition.y);

    1883. 

  1883.             }

    1884. 

  1884.             this._scrollPosition = null;

    1885. 

  1885.         }

    1886. 

  1886. 

    1887. 

  1887.         Sys.Application.endCreateComponents();

    1888. 

  1888. 

    1889. 

  1889.         this._pageLoaded(false, data);

    1890. 

  1890. 

    1891. 

  1891.         this._endPostBack(null, response, data);

    1892. 

  1892. 

    1893. 

  1893.         if (this._controlIDToFocus) {

    1894. 

  1894.             var focusTarget;

    1895. 

  1895.             var oldContentEditableSetting;

    1896. 

  1896.             if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {

    1897. 

  1897.                 var targetControl = $get(this._controlIDToFocus);

    1898. 

  1898. 

    1899. 

  1899.                 focusTarget = targetControl;

    1900. 

  1900.                 if (targetControl && (!WebForm_CanFocus(targetControl))) {

    1901. 

  1901.                     focusTarget = WebForm_FindFirstFocusableChild(targetControl);

    1902. 

  1902.                 }

    1903. 

  1903.                 if (focusTarget && (typeof(focusTarget.contentEditable) !== "undefined")) {

    1904. 

  1904.                     oldContentEditableSetting = focusTarget.contentEditable;

    1905. 

  1905.                     focusTarget.contentEditable = false;

    1906. 

  1906.                 }

    1907. 

  1907.                 else {

    1908. 

  1908.                     focusTarget = null;

    1909. 

  1909.                 }

    1910. 

  1910.             }

    1911. 

  1911.             WebForm_AutoFocus(this._controlIDToFocus);

    1912. 

  1912.             if (focusTarget) {

    1913. 

  1913.                 focusTarget.contentEditable = oldContentEditableSetting;

    1914. 

  1914.             }

    1915. 

  1915.             this._controlIDToFocus = null;

    1916. 

  1916.         }

    1917. 

  1917.     },

    1918. 

  1918. 

    1919. 

  1919.     _splitNodeIntoArray: function PageRequestManager$_splitNodeIntoArray(node) {

    1920. 

  1920.         var str = node.content;

    1921. 

  1921.         var arr = str.length ? str.split(',') : [];

    1922. 

  1922.         return arr;

    1923. 

  1923.     },

    1924. 

  1924. 

    1925. 

  1925.     _uniqueIDToClientID: function PageRequestManager$_uniqueIDToClientID(uniqueID) {

    1926. 

  1926.         return uniqueID.replace(/\$/g, '_');

    1927. 

  1927.     },

    1928. 

  1928.     

    1929. 

  1929.     _updateControls: function PageRequestManager$_updateControls(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, asyncPostBackTimeout, version4) {

    1930. 

  1930.         this._commitControls(

    1931. 

  1931.             this._processUpdatePanelArrays(updatePanelIDs, asyncPostBackControlIDs, postBackControlIDs, version4),

    1932. 

  1932.             asyncPostBackTimeout);

    1933. 

  1933.     },

    1934. 

  1934.     

    1935. 

  1935.     _updatePanel: function PageRequestManager$_updatePanel(updatePanelElement, rendering) {

    1936. 

  1936.         for (var updatePanelID in this._scriptDisposes) {

    1937. 

  1937.             if (this._elementContains(updatePanelElement, document.getElementById(updatePanelID))) {

    1938. 

  1938.                 var disposeScripts = this._scriptDisposes[updatePanelID];

    1939. 

  1939.                 for (var i = 0, l = disposeScripts.length; i < l; i++) {

    1940. 

  1940.                     window.eval(disposeScripts[i]);

    1941. 

  1941.                 }

    1942. 

  1942. 

    1943. 

  1943.                 delete this._scriptDisposes[updatePanelID];

    1944. 

  1944.             }

    1945. 

  1945.         }

    1946. 

  1946. 

    1947. 

  1947.         Sys.Application.disposeElement(updatePanelElement, true);

    1948. 

  1948. 

    1949. 

  1949.         updatePanelElement.innerHTML = rendering;

    1950. 

  1950.     },

    1951. 

  1951. 

    1952. 

  1952.     _validPosition: function PageRequestManager$_validPosition(position) {

    1953. 

  1953.         return (typeof(position) !== "undefined") && (position !== null) && (position !== 0);

    1954. 

  1954.     }

    1955. 

  1955. }

    1956. 

  1956. 

    1957. 

  1957. $type.getInstance = function PageRequestManager$getInstance() {

    1958. 

  1958.     /// <summary locid="M:J#Sys.WebForms.PageRequestManager.getInstance">Gets the current instance of the PageRequestManager.</summary>

    1959. 

  1959.     /// <returns type="Sys.WebForms.PageRequestManager"></returns>

    1960. 

  1960.     if (arguments.length !== 0) throw Error.parameterCount();

    1961. 

  1961.     var prm = Sys.WebForms.PageRequestManager._instance;

    1962. 

  1962.     if (!prm) {

    1963. 

  1963.         prm = Sys.WebForms.PageRequestManager._instance = new Sys.WebForms.PageRequestManager();

    1964. 

  1964.     }

    1965. 

  1965.     return prm;

    1966. 

  1966. }

    1967. 

  1967. 

    1968. 

  1968. $type._addArrayElement = function PageRequestManager$_addArrayElement(arrayName) {

    1969. 

  1969.     if (!window[arrayName]) {

    1970. 

  1970.         window[arrayName] = new Array();

    1971. 

  1971.     }

    1972. 

  1972. 

    1973. 

  1973.     for (var i = 1, l = arguments.length; i < l; i++) {

    1974. 

  1974.         Array.add(window[arrayName], arguments[i]);

    1975. 

  1975.     }

    1976. 

  1976. }

    1977. 

  1977. 

    1978. 

  1978. $type._initialize = function PageRequestManager$_initialize() {

    1979. 

  1979.     var prm = Sys.WebForms.PageRequestManager.getInstance();

    1980. 

  1980.     prm._initializeInternal.apply(prm, arguments);

    1981. 

  1981. }

    1982. 

  1982. 

    1983. 

  1983. $type.registerClass('Sys.WebForms.PageRequestManager');

    1984. 

  1984. $type = Sys.UI._UpdateProgress = function _UpdateProgress(element) {

    1985. 

  1985.     Sys.UI._UpdateProgress.initializeBase(this,[element]);

    1986. 

  1986.     this._displayAfter = 500;

    1987. 

  1987.     this._dynamicLayout = true;

    1988. 

  1988.     this._associatedUpdatePanelId = null;

    1989. 

  1989.     this._beginRequestHandlerDelegate = null;

    1990. 

  1990.     this._startDelegate = null;

    1991. 

  1991.     this._endRequestHandlerDelegate = null;

    1992. 

  1992.     this._pageRequestManager = null;

    1993. 

  1993.     this._timerCookie = null;

    1994. 

  1994. }

    1995. 

  1995. $type.prototype = {

    1996. 

  1996.     get_displayAfter: function _UpdateProgress$get_displayAfter() {

    1997. 

  1997.         /// <value type="Number" locid="P:J#Sys.UI._UpdateProgress.displayAfter"></value>

    1998. 

  1998.         if (arguments.length !== 0) throw Error.parameterCount();

    1999. 

  1999.         return this._displayAfter;

    2000. 

  2000.     },

    2001. 

  2001.     set_displayAfter: function _UpdateProgress$set_displayAfter(value) {

    2002. 

  2002.         var e = Function._validateParams(arguments, [{name: "value", type: Number}]);

    2003. 

  2003.         if (e) throw e;

    2004. 

  2004.         this._displayAfter = value;

    2005. 

  2005.     },

    2006. 

  2006.     get_dynamicLayout: function _UpdateProgress$get_dynamicLayout() {

    2007. 

  2007.         /// <value type="Boolean" locid="P:J#Sys.UI._UpdateProgress.dynamicLayout"></value>

    2008. 

  2008.         if (arguments.length !== 0) throw Error.parameterCount();

    2009. 

  2009.         return this._dynamicLayout;

    2010. 

  2010.     },

    2011. 

  2011.     set_dynamicLayout: function _UpdateProgress$set_dynamicLayout(value) {

    2012. 

  2012.         var e = Function._validateParams(arguments, [{name: "value", type: Boolean}]);

    2013. 

  2013.         if (e) throw e;

    2014. 

  2014.         this._dynamicLayout = value;

    2015. 

  2015.     },

    2016. 

  2016.     get_associatedUpdatePanelId: function _UpdateProgress$get_associatedUpdatePanelId() {

    2017. 

  2017.         /// <value type="String" mayBeNull="true" locid="P:J#Sys.UI._UpdateProgress.associatedUpdatePanelId"></value>

    2018. 

  2018.         if (arguments.length !== 0) throw Error.parameterCount();

    2019. 

  2019.         return this._associatedUpdatePanelId;

    2020. 

  2020.     },

    2021. 

  2021.     set_associatedUpdatePanelId: function _UpdateProgress$set_associatedUpdatePanelId(value) {

    2022. 

  2022.         var e = Function._validateParams(arguments, [{name: "value", type: String, mayBeNull: true}]);

    2023. 

  2023.         if (e) throw e;

    2024. 

  2024.         this._associatedUpdatePanelId = value;

    2025. 

  2025.     },

    2026. 

  2026.     get_role: function _UpdateProgress$get_role() {

    2027. 

  2027.         /// <value type="String" locid="P:J#Sys.UI._UpdateProgress.role"></value>

    2028. 

  2028.         if (arguments.length !== 0) throw Error.parameterCount();

    2029. 

  2029.         return "status";

    2030. 

  2030.     },

    2031. 

  2031.     _clearTimeout: function _UpdateProgress$_clearTimeout() {

    2032. 

  2032.         if (this._timerCookie) {

    2033. 

  2033.             window.clearTimeout(this._timerCookie);

    2034. 

  2034.             this._timerCookie = null;

    2035. 

  2035.         }

    2036. 

  2036.     },

    2037. 

  2037.     _getUniqueID: function _UpdateProgress$_getUniqueID(clientID) {

    2038. 

  2038.         var i = Array.indexOf(this._pageRequestManager._updatePanelClientIDs, clientID);

    2039. 

  2039.         return i === -1 ? null : this._pageRequestManager._updatePanelIDs[i];

    2040. 

  2040.     },

    2041. 

  2041.     _handleBeginRequest: function _UpdateProgress$_handleBeginRequest(sender, arg) {

    2042. 

  2042.         var curElem = arg.get_postBackElement(),

    2043. 

  2043.             showProgress = true,

    2044. 

  2044.             upID = this._associatedUpdatePanelId;

    2045. 

  2045.         if (this._associatedUpdatePanelId) {

    2046. 

  2046.             var updating = arg.get_updatePanelsToUpdate();

    2047. 

  2047.             if (updating && updating.length) {

    2048. 

  2048.                 showProgress = (Array.contains(updating, upID) || Array.contains(updating, this._getUniqueID(upID)))

    2049. 

  2049.             }

    2050. 

  2050.             else {

    2051. 

  2051.                 showProgress = false;

    2052. 

  2052.             }

    2053. 

  2053.         }

    2054. 

  2054.         while (!showProgress && curElem) {

    2055. 

  2055.             if (curElem.id && this._associatedUpdatePanelId === curElem.id) {

    2056. 

  2056.                 showProgress = true; 

    2057. 

  2057.             }

    2058. 

  2058.             curElem = curElem.parentNode; 

    2059. 

  2059.         } 

    2060. 

  2060.         if (showProgress) {

    2061. 

  2061.             this._timerCookie = window.setTimeout(this._startDelegate, this._displayAfter);

    2062. 

  2062.         }

    2063. 

  2063.     },

    2064. 

  2064.     _startRequest: function _UpdateProgress$_startRequest() {

    2065. 

  2065.         if (this._pageRequestManager.get_isInAsyncPostBack()) {

    2066. 

  2066.             var element = this.get_element();

    2067. 

  2067.             if (this._dynamicLayout) {

    2068. 

  2068.                 element.style.display = 'block';

    2069. 

  2069.             }

    2070. 

  2070.             else {

    2071. 

  2071.                 element.style.visibility = 'visible';

    2072. 

  2072.             }

    2073. 

  2073.             if (this.get_role() === "status") {

    2074. 

  2074.                 element.setAttribute("aria-hidden", "false");

    2075. 

  2075.             }

    2076. 

  2076.         }

    2077. 

  2077.         this._timerCookie = null;

    2078. 

  2078.     },

    2079. 

  2079.     _handleEndRequest: function _UpdateProgress$_handleEndRequest(sender, arg) {

    2080. 

  2080.         var element = this.get_element();

    2081. 

  2081.         if (this._dynamicLayout) {

    2082. 

  2082.             element.style.display = 'none';

    2083. 

  2083.         }

    2084. 

  2084.         else {

    2085. 

  2085.             element.style.visibility = 'hidden';

    2086. 

  2086.         }

    2087. 

  2087.         if (this.get_role() === "status") {

    2088. 

  2088.             element.setAttribute("aria-hidden", "true");

    2089. 

  2089.         }

    2090. 

  2090.         this._clearTimeout();

    2091. 

  2091.     },

    2092. 

  2092.     dispose: function _UpdateProgress$dispose() {

    2093. 

  2093.         if (this._beginRequestHandlerDelegate !== null) {

    2094. 

  2094.             this._pageRequestManager.remove_beginRequest(this._beginRequestHandlerDelegate);

    2095. 

  2095.             this._pageRequestManager.remove_endRequest(this._endRequestHandlerDelegate);

    2096. 

  2096.             this._beginRequestHandlerDelegate = null;

    2097. 

  2097.             this._endRequestHandlerDelegate = null;

    2098. 

  2098.         }

    2099. 

  2099.         this._clearTimeout();

    2100. 

  2100.         Sys.UI._UpdateProgress.callBaseMethod(this,"dispose");

    2101. 

  2101.     },

    2102. 

  2102.     initialize: function _UpdateProgress$initialize() {

    2103. 

  2103.         Sys.UI._UpdateProgress.callBaseMethod(this, 'initialize');

    2104. 

  2104.         if (this.get_role() === "status") {

    2105. 

  2105.             this.get_element().setAttribute("aria-hidden", "true");

    2106. 

  2106.         }

    2107. 

  2107.     	this._beginRequestHandlerDelegate = Function.createDelegate(this, this._handleBeginRequest);

    2108. 

  2108.     	this._endRequestHandlerDelegate = Function.createDelegate(this, this._handleEndRequest);

    2109. 

  2109.     	this._startDelegate = Function.createDelegate(this, this._startRequest);

    2110. 

  2110.     	if (Sys.WebForms && Sys.WebForms.PageRequestManager) {

    2111. 

  2111.            this._pageRequestManager = Sys.WebForms.PageRequestManager.getInstance();

    2112. 

  2112.     	}

    2113. 

  2113.     	if (this._pageRequestManager !== null ) {

    2114. 

  2114.     	    this._pageRequestManager.add_beginRequest(this._beginRequestHandlerDelegate);

    2115. 

  2115.     	    this._pageRequestManager.add_endRequest(this._endRequestHandlerDelegate);

    2116. 

  2116.     	}

    2117. 

  2117.     }

    2118. 

  2118. }

    2119. 

  2119. $type.registerClass('Sys.UI._UpdateProgress', Sys.UI.Control);

    2120. 

  2120. 

    2121. 

  2121. }

    2122. 

  2122. 

    2123. 

  2123. if (window.Sys && Sys.loader) {

    2124. 

  2124. 	Sys.loader.registerScript("WebForms", ["ComponentModel", "Serialization", "Network"], execute);

    2125. 

  2125. }

    2126. 

  2126. else {

    2127. 

  2127. 	execute();

    2128. 

  2128. }

    2129. 

  2129. 

    2130. 

  2130. })();

    2131. 

  2131.