https://wandelroutenetwerk.nl/DXR.axd?r=1_10,1_253,1_21-Rkqku&order=0

1ASPx.IS(function(ASPx, dx, DevExpress){
2(function module(ASPx, options) {
3ASPx.modules.Classes = module;
4ASPx.classesScriptParsed = false;
5ASPx.documentLoaded = false; 
6ASPx.CallbackType = {
7 Data: "d",
8 Common: "c"
9};
10ASPx.callbackState = {
11 aborted: "aborted",
12 inTurn: "inTurn",
13 sent: "sent"
14};
15var ASPxClientEvent = ASPx.CreateClass(null, {
16 constructor: function() {
17  this.handlerInfoList = [];
18  this.firingIndex = -1;
19 },
20 AddHandler: function(handler, executionContext) {
21  if(typeof(executionContext) == "undefined")
22   executionContext = null;
23  this.RemoveHandler(handler, executionContext);
24  var handlerInfo = ASPxClientEvent.CreateHandlerInfo(handler, executionContext);
25  this.handlerInfoList.push(handlerInfo);
26 },
27 RemoveHandler: function(handler, executionContext) {
28  this.removeHandlerByCondition(function(handlerInfo) {
29   return handlerInfo.handler == handler && 
30    (!executionContext || handlerInfo.executionContext == executionContext);
31  });
32 },
33 removeHandlerByCondition: function(predicate) {
34   for(var i = this.handlerInfoList.length - 1; i >= 0; i--) {
35   var handlerInfo = this.handlerInfoList[i];
36   if(predicate(handlerInfo)) {
37    ASPx.Data.ArrayRemoveAt(this.handlerInfoList, i);
38    if(i <= this.firingIndex)
39     this.firingIndex--;
40   }
41  }
42 },
43 removeHandlerByControlName: function(controlName) {
44  this.removeHandlerByCondition(function(handlerInfo) {
45   return handlerInfo.executionContext &&  
46    handlerInfo.executionContext.name === controlName;
47  });
48 },
49 ClearHandlers: function() {
50  this.handlerInfoList.length = 0;
51 },
52 FireEvent: function(obj, args) {
53  for(this.firingIndex = 0; this.firingIndex < this.handlerInfoList.length; this.firingIndex++) {
54   var handlerInfo = this.handlerInfoList[this.firingIndex];
55   handlerInfo.handler.call(handlerInfo.executionContext, obj, args);
56  }
57 },
58 InsertFirstHandler: function(handler, executionContext){
59  if(typeof(executionContext) == "undefined")
60   executionContext = null;
61  var handlerInfo = ASPxClientEvent.CreateHandlerInfo(handler, executionContext);
62  ASPx.Data.ArrayInsert(this.handlerInfoList, handlerInfo, 0);
63 },
64 IsEmpty: function() {
65  return this.handlerInfoList.length == 0;
66 }
67});
68ASPxClientEvent.CreateHandlerInfo = function(handler, executionContext) {
69 return {
70  handler: handler,
71  executionContext: executionContext
72 };
73};
74var ASPxClientEventArgs = ASPx.CreateClass(null, {
75 constructor: function() {
76 }
77});
78ASPxClientEventArgs.Empty = new ASPxClientEventArgs();
79var ASPxClientCancelEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
80 constructor: function(){
81  this.constructor.prototype.constructor.call(this);
82  this.cancel = false;
83 }
84});
85var ASPxClientProcessingModeEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
86 constructor: function(processOnServer){
87  this.constructor.prototype.constructor.call(this);
88  this.processOnServer = !!processOnServer;
89 }
90});
91var ASPxClientProcessingModeCancelEventArgs = ASPx.CreateClass(ASPxClientProcessingModeEventArgs, {
92 constructor: function(processOnServer){
93  this.constructor.prototype.constructor.call(this, processOnServer);
94  this.cancel = false;
95 }
96});
97var OrderedMap = ASPx.CreateClass(null, {
98 constructor: function(){
99  this.entries = {};
100  this.firstEntry = null;
101  this.lastEntry = null;
102 },
103 add: function(key, element) {
104  var entry = this.addEntry(key, element);
105  this.entries[key] = entry;
106 },
107 remove: function(key) {
108  var entry = this.entries[key];
109  if(entry === undefined)
110   return;
111  this.removeEntry(entry);
112  delete this.entries[key];
113 },
114 clear: function() {
115  this.markAllEntriesAsRemoved();
116  this.entries = {};
117  this.firstEntry = null;
118  this.lastEntry = null;
119 },
120 get: function(key) {
121  var entry = this.entries[key];
122  return entry ? entry.value : undefined;
123 },
124 forEachEntry: function(processFunc, context) {
125  context = context || this;
126  for(var entry = this.firstEntry; entry; entry = entry.next) {
127   if(entry.removed)
128    continue;
129   if(processFunc.call(context, entry.key, entry.value))
130    return;
131  }
132 },
133 addEntry: function(key, element) {
134  var entry = { key: key, value: element, next: null, prev: null };
135  if(!this.firstEntry)
136   this.firstEntry = entry;
137  else {
138   entry.prev = this.lastEntry;
139   this.lastEntry.next = entry;
140  }
141  this.lastEntry = entry;
142  return entry;
143 },
144 removeEntry: function(entry) {
145  if(this.firstEntry == entry)
146   this.firstEntry = entry.next;
147  if(this.lastEntry == entry)
148   this.lastEntry = entry.prev;
149  if(entry.prev)
150   entry.prev.next = entry.next;
151  if(entry.next)
152   entry.next.prev = entry.prev;
153  entry.removed = true;
154 },
155 markAllEntriesAsRemoved: function() {
156  for(var entry = this.firstEntry; entry; entry = entry.next)
157   entry.removed = true;
158 }
159});
160var CollectionBase = ASPx.CreateClass(null, {
161 constructor: function(){
162  this.elementsMap = new OrderedMap();
163  this.isASPxClientCollection = true;
164 },
165 Add: function(key, element) {
166  this.elementsMap.add(key, element);
167 },
168 Remove: function(key) {
169  this.elementsMap.remove(key);
170 },
171 Clear: function(){
172  this.elementsMap.clear();
173 },
174 Get: function(key){
175  return this.elementsMap.get(key);
176 }
177});
178(function garbageCollector(ASPx, options) {
179 ASPx.modules.garbageCollector = garbageCollector;
180 var interval = options.GCCheckInterval;
181 window.setInterval(collectObjects, interval);
182 function canCollectObjects() {
183  if (!ASPx.GetControlCollection) return false;
184  var collection = ASPx.GetControlCollection();
185  return collection && !collection.InCallback();
186 }
187 function collectObjects() {
188  if (!canCollectObjects()) return;
189  ASPx.GetControlCollectionCollection().RemoveDisposedControls();
190  if(typeof(ASPx.GetStateController) != "undefined")
191   ASPx.GetStateController().RemoveDisposedItems();

192  if(ASPx.TableScrollHelperCollection)
193   ASPx.TableScrollHelperCollection.RemoveDisposedObjects();
194  if(ASPx.Ident.scripts.ASPxClientRatingControl)
195   ASPxClientRatingControl.RemoveDisposedElementUnderCursor();
196  var postHandler = ASPx.GetPostHandler();
197  if(postHandler)
198   postHandler.RemoveDisposedFormsFromCache();
199 }
200})(ASPx, options);
201var ControlTree = ASPx.CreateClass(null, {
202 constructor: function(controlCollection, container, controlFilter) {
203  this.container = container;
204  this.domMap = { };
205  this.rootNode = this.createNode(null, null);
206  this.createControlTree(controlCollection, container, controlFilter);
207 },
208 createControlTree: function(controlCollection, container, controlFilter) {
209  controlCollection.ProcessControlsInContainer(container, function(control) {
210   control.RegisterInControlTree(this);
211  }.aspxBind(this), controlFilter);
212  var fixedNodes = [];
213  var fixedNodesChildren = [];
214  for(var domElementID in this.domMap) {
215   if(!this.domMap.hasOwnProperty(domElementID)) continue;
216   var node = this.domMap[domElementID];
217   var controlOwner = node.control ? node.control.controlOwner : null;
218   if(controlOwner && this.domMap[controlOwner.name])
219    continue;
220   if(this.isFixedNode(node))
221    fixedNodes.push(node);
222   else {
223    var parentNode = this.findParentNode(domElementID);
224    parentNode = parentNode || this.rootNode;
225    if(this.isFixedNode(parentNode))
226     fixedNodesChildren.push(node);
227    else {
228     var childNode = node.mainNode || node;
229     this.addChildNode(parentNode, childNode);
230    }
231   }
232  }
233  for(var i = fixedNodes.length - 1; i >= 0; i--)
234   this.insertChildNode(this.rootNode, fixedNodes[i], 0);
235  for(var i = fixedNodesChildren.length - 1; i >= 0; i--)
236   this.insertChildNode(this.rootNode, fixedNodesChildren[i], 0);
237 },
238 findParentNode: function(id) {
239  var element = document.getElementById(id).parentNode;
240  while(element && element.tagName !== "BODY") {
241   if(element.id) {
242    var parentNode = this.domMap[element.id];
243    if(parentNode)
244     return parentNode;
245   }
246   element = element.parentNode;
247  }
248  return null;
249 },
250 addChildNode: function(node, childNode) {
251  if(!childNode.parentNode) {
252   node.children.push(childNode);
253   childNode.parentNode = node;
254  }
255 },
256 insertChildNode: function(node, childNode, index) {
257  if(!childNode.parentNode) {
258   ASPx.Data.ArrayInsert(node.children, childNode, index);
259   childNode.parentNode = node;
260  }
261 },
262 addRelatedNode: function(node, relatedNode) {
263  this.addChildNode(node, relatedNode);
264  relatedNode.mainNode = node;
265 },
266 isFixedNode: function(node) {
267  var control = node.mainNode ? node.mainNode.control : node.control;
268  return control && control.HasFixedPosition();
269 },
270 createNode: function(domElementID, control) {
271  var node = {
272   control: control,
273   children: [],
274   parentNode: null,
275   mainNode: null
276  };
277  if(domElementID)
278   this.domMap[domElementID] = node;
279  return node;
280 }
281});
282var ControlAdjuster = ASPx.CreateClass(null, {
283 constructor: function() {
284 },
285 adjustControlsInHierarchy: function(controlCollection, adjustFunc, container, collapseControls, controlFilter) {
286  var controlTree = new ASPx.ControlTree(controlCollection, container, controlFilter);
287  this.adjustControlsInTree(controlTree.rootNode, adjustFunc, container, collapseControls);
288 },
289 adjustControlsInTree: function(treeNode, adjustFunc, container, collapseControls) {
290  var observer = _aspxGetDomObserver();
291  observer.pause(container, true);
292  var documentScrollInfo;
293  if(collapseControls) {
294   documentScrollInfo = ASPx.GetOuterScrollPosition(document.body);
295   this.collapseControls(treeNode);
296  }
297  var adjustNodes = [], 
298   autoHeightNodes = [];
299  var requireReAdjust = this.forEachControlCore(treeNode, collapseControls, adjustFunc, adjustNodes, autoHeightNodes);
300  if(requireReAdjust)
301   this.forEachControlsBackward(adjustNodes, collapseControls, adjustFunc);
302  else {
303   for(var i = 0, node; node = autoHeightNodes[i]; i++)
304    node.control.AdjustAutoHeight();
305  }
306  if(collapseControls)
307   ASPx.RestoreOuterScrollPosition(documentScrollInfo);
308  observer.resume(container, true);
309 },
310 forEachControlCore: function(node, collapseControls, processFunc, adju

310stNodes, autoHeightNodes) {
311  var requireReAdjust = false,
312   size, newSize;
313  if(node.control) {
314   var checkReadjustment = collapseControls && node.control.IsControlCollapsed() && node.control.CanCauseReadjustment();
315   if(checkReadjustment)
316    size = node.control.GetControlPercentMarkerSize(false, true);
317   if(node.control.IsControlCollapsed() && !node.control.IsExpandableByAdjustment())
318    node.control.ExpandControl();
319   node.control.isInsideHierarchyAdjustment = true;
320   processFunc(node.control);
321   node.control.isInsideHierarchyAdjustment = false;
322   if(checkReadjustment) {
323    newSize = node.control.GetControlPercentMarkerSize(false, true);
324    requireReAdjust = size.width !== newSize.width;
325   }
326   if(node.control.sizingConfig.supportAutoHeight)
327    autoHeightNodes.push(node);
328   node.control.ResetControlPercentMarkerSize();
329  }
330  for(var childNode, i = 0; childNode = node.children[i]; i++)
331   requireReAdjust = this.forEachControlCore(childNode, collapseControls, processFunc, adjustNodes, autoHeightNodes) || requireReAdjust;
332  adjustNodes.push(node);
333  return requireReAdjust;
334 },
335 forEachControlsBackward: function(adjustNodes, collapseControls, processFunc) {
336  for(var i = 0, node; node = adjustNodes[i]; i++)
337   this.forEachControlsBackwardCore(node, collapseControls, processFunc);
338 },
339 forEachControlsBackwardCore: function(node, collapseControls, processFunc) {
340  if(node.control)
341   processFunc(node.control);
342  if(node.children.length > 1) {
343   for(var i = 0, childNode; childNode = node.children[i]; i++) {
344    if(childNode.control)
345     processFunc(childNode.control);
346   }
347  }
348 },
349 collapseControls: function(node) {
350  for(var childNode, i = 0; childNode = node.children[i]; i++)
351   this.collapseControls(childNode);
352  if(node.control && node.control.NeedCollapseControl())
353   node.control.CollapseControl();
354 }
355});
356var controlAdjuster = null;
357function GetControlAdjuster() {
358 if(!controlAdjuster)
359  controlAdjuster = new ControlAdjuster();
360 return controlAdjuster;
361}
362function _aspxFunctionIsInCallstack(currentCallee, targetFunction, depthLimit) {
363 var candidate = currentCallee;
364 var depth = 0;
365 while(candidate && depth <= depthLimit) {
366  candidate = candidate.caller;
367  if(candidate == targetFunction)
368   return true;
369  depth++;
370 }
371 return false;
372}
373ASPx.attachToReady(aspxClassesWindowOnLoad);
374function aspxClassesWindowOnLoad(){
375 ASPx.documentLoaded = true;
376 _aspxMoveLinkElements();
377 _aspxSweepDuplicatedLinks();
378 ResourceManager.SynchronizeResources();
379 var externalScriptProcessor = GetExternalScriptProcessor();
380 if(externalScriptProcessor)
381  externalScriptProcessor.ShowErrorMessages();
382 ASPx.AccessibilityUtils.initialize();
383 ASPx.GetControlCollection().Initialize();
384 _aspxInitializeScripts();
385 _aspxInitializeLinks();
386 _aspxInitializeFocus();
387 ASPx.GetControlCollection().FinalizeInitialization();
388}
389Ident = { };
390Ident.IsDate = function(obj) {
391 return obj && (obj.constructor == Date || obj.constructor.name == "Date");
392};
393Ident.IsRegExp = function(obj) {
394 return obj && obj.constructor === RegExp;
395};
396Ident.IsArray = function(obj) {
397 return obj && obj.constructor == Array;
398};
399Ident.IsASPxClientCollection = function(obj) {
400 return obj && obj.isASPxClientCollection;
401};
402Ident.IsASPxClientControl = function(obj) {
403 return obj && obj instanceof ASPxClientControlBase;
404};
405Ident.IsASPxClientEdit = function(obj) {
406 return obj && obj.isASPxClientEdit;
407};
408Ident.IsFocusableElementRegardlessTabIndex = function (element) {
409 var tagName = element.tagName;
410 return tagName == "TEXTAREA" || tagName == "INPUT" || tagName == "A" ||
411  tagName == "SELECT" || tagName == "IFRAME" || tagName == "OBJECT" || tagName == "BUTTON";
412};
413Ident.isDialogInvisibleControl = function(control) {
414 return !!ASPx.Dialog && ASPx.Dialog.isDialogInvisibleControl(control);
415};
416Ident.isBatchEditUnusedEditor = function(control) {
417 return !!ASPx.BatchEditHelper && ASPx.BatchEditHelper.isBatchEditUnusedEditor(control);
418};
419Ident.scripts = {};
420if(ASPx.IsFunction(window.WebForm_InitCallbackAddField)) {
421 (function() {
422  var original = window.WebForm_InitCallbackAddField;
423  window.WebForm_InitCallbackAddField = function(name, value) {
424   if(typeof(name) == "string" && name)
425    original.apply(null, arguments);
426  };
427 })();
428}
429ASPx.FireDefaultButton = function(evt, buttonID) {
430 if(_aspxIsDefaultButtonEvent(evt, buttonID)) {
431  var defaultButton = ASPx.GetElementById(buttonID);

432  if(defaultButton && defaultButton.click) {
433   if(ASPx.IsFocusable(defaultButton))
434    defaultButton.focus();
435   ASPx.Evt.DoElementClick(defaultButton);
436   ASPx.Evt.PreventEventAndBubble(evt);
437   return false;
438  }
439 }
440 return true;
441};
442function _aspxIsDefaultButtonEvent(evt, defaultButtonID) {
443 if(evt.keyCode != ASPx.Key.Enter)
444  return false;
445 var srcElement = ASPx.Evt.GetEventSource(evt);
446 if(!srcElement || srcElement.id === defaultButtonID)
447  return true;
448 var tagName = srcElement.tagName;
449 var type = srcElement.type;
450 return tagName != "TEXTAREA" && tagName != "BUTTON" && tagName != "A" &&
451  (tagName != "INPUT" || type != "checkbox" && type != "radio" && type != "button" && type != "submit" && type != "reset");
452}
453var PostHandler = ASPx.CreateClass(null, {
454 constructor: function() {
455  this.Post = new ASPxClientEvent();
456  this.PostFinalization = new ASPxClientEvent();
457  this.observableForms = [];
458  this.dxCallbackTriggers = {};
459  this.lastSubmitElementName = null;
460  this.beforeOnSubmit = function() { };
461  this.ReplaceGlobalPostFunctions();
462  this.HandleDxCallbackBeginning();
463  this.HandleMSAjaxRequestBeginning();
464 },
465 Update: function() {
466  this.ReplaceFormsSubmit(true);
467 },
468 ProcessPostRequest: function(ownerID, isCallback, isMSAjaxRequest, isDXCallback) {
469  this.cancelPostProcessing = false;
470  this.isMSAjaxRequest = isMSAjaxRequest;
471  if(this.SkipRaiseOnPost(ownerID, isCallback, isDXCallback))
472   return;
473  var args = new PostHandlerOnPostEventArgs(ownerID, isCallback, isMSAjaxRequest, isDXCallback);
474  this.Post.FireEvent(this, args);
475  this.cancelPostProcessing = args.cancel;
476  if(!args.cancel)
477   this.PostFinalization.FireEvent(this, args);
478 },
479 SkipRaiseOnPost: function(ownerID, isCallback, isDXCallback) { 
480  if(!isCallback)
481   return false;
482  var dxOwner = isDXCallback && ASPx.GetControlCollection().GetByName(ownerID);
483  if(dxOwner) {
484   this.dxCallbackTriggers[dxOwner.uniqueID] = true;
485   return false;
486  }
487  if(this.dxCallbackTriggers[ownerID]) {
488   this.dxCallbackTriggers[ownerID] = false;
489   return true;
490  }
491  return false;
492 },
493 ReplaceGlobalPostFunctions: function() {
494  if(ASPx.IsFunction(window.__doPostBack))
495   this.ReplaceDoPostBack();
496  if(ASPx.IsFunction(window.WebForm_DoCallback))
497   this.ReplaceDoCallback();
498  if(ASPx.IsFunction(window.WebForm_ExecuteCallback))
499   this.ReplaceExecuteCallback();
500  this.ReplaceFormsSubmit();
501 },
502 HandleDxCallbackBeginning: function() {
503  ASPx.GetControlCollection().BeforeInitCallback.AddHandler(function(s, e) {
504   aspxRaisePostHandlerOnPost(e.callbackOwnerID, true, false, true); 
505  });
506 },
507 HandleMSAjaxRequestBeginning: function() {
508  var pageRequestManager = ASPx.GetMSAjaxRequestManager();
509  if(pageRequestManager != null && Ident.IsArray(pageRequestManager._onSubmitStatements)) {
510   pageRequestManager._onSubmitStatements.unshift(function() {
511    var postbackSettings = Sys.WebForms.PageRequestManager.getInstance()._postBackSettings;
512    var postHandler = aspxGetPostHandler();
513    aspxRaisePostHandlerOnPost(postbackSettings.asyncTarget, true, true);
514    return !postHandler.cancelPostProcessing;
515   });
516  }
517 },
518 ReplaceDoPostBack: function() {
519  var original = __doPostBack;
520  __doPostBack = function(eventTarget, eventArgument) {
521   var postHandler = aspxGetPostHandler();
522   aspxRaisePostHandlerOnPost(eventTarget);
523   if(postHandler.cancelPostProcessing)
524    return;
525   ASPxClientControl.postHandlingLocked = true;
526   original(eventTarget, eventArgument);
527   delete ASPxClientControl.postHandlingLocked;
528  };
529 },
530 ReplaceDoCallback: function() {
531  var original = WebForm_DoCallback;
532  WebForm_DoCallback = function(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync) {
533   var postHandler = aspxGetPostHandler();
534   aspxRaisePostHandlerOnPost(eventTarget, true);
535   if(postHandler.cancelPostProcessing)
536    return;
537   return original(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync);
538  };
539 },
540 ReplaceExecuteCallback: function() {
541  var original = WebForm_ExecuteCallback;
542  var handler = this;
543  WebForm_ExecuteCallback = function(callbackObject) {
544   var isDxCallback = callbackObject && callbackObject.context && ASPx.GetControlCollection().Get(callbackObject.context) !== null;
545   ASPx.callbackProcessed = false;
546   original(callbackObject);
547   if(ASPx.Browser.Firefox && document.getElementById("__EVENTVALIDATION")) {
548    var viewStateField = document.getElementById("__VIEWSTATE");
549    if(viewStateField) {
550     var response = callbackObject.xmlRequest.responseText;
551     var separatorIndex = response.indexOf("|");

552     var validationFieldLength = separatorIndex > 0 ? response.substring(0, separatorIndex) : null;
553     if(ASPx.IsNumber(validationFieldLength))
554      viewStateField.value = viewStateField.value; 
555    }
556   }
557   if(isDxCallback && !ASPx.callbackProcessed) {
558    var request = callbackObject.xmlRequest;
559    if(ASPxClientUtils.IsExists(callbackObject.eventCallback)) {
560     if (handler.HasAppErrorOnCallback(request))
561      callbackObject.eventCallback(handler.GetServerErrorText(), callbackObject.context);
562     else if (handler.HasNetworkErrorOnCallback(request))
563      callbackObject.eventCallback(handler.GetNetworkError(), callbackObject.context);
564    }
565   }
566  };
567 },
568 HasAppErrorOnCallback: function(request) {
569  if(!request) return false;
570  var isServerError = request.status && request.status == 500;
571  var pattern = /<html[^>]*>([\w|\W]*)<\/html>/im;
572  var text = request.responseText;
573  return isServerError && !!text && pattern.test(text);
574 },
575 GetServerErrorText: function() {
576  return "Internal Server Error";
577 },
578 HasNetworkErrorOnCallback: function(request) {
579  if (!request) return false;
580  return request.readyState == 4 && request.status == 0;
581 },
582 GetNetworkError: function() {
583  return new NetworkError();
584 },
585 ReplaceFormsSubmit: function(checkObservableCollection) {
586  for(var i = 0; i < document.forms.length; i++) { 
587   var form = document.forms[i];
588   if(checkObservableCollection && ASPx.Data.ArrayIndexOf(this.observableForms, form) >= 0)
589    continue;
590   if(form.submit)
591    this.ReplaceFormSubmit(form);
592   this.ReplaceFormOnSumbit(form);
593   this.observableForms.push(form);
594  }
595 },
596 ReplaceFormSubmit: function(form) {
597  var originalSubmit = form.submit;
598  form.submit = function() {
599   var postHandler = aspxGetPostHandler();
600   aspxRaisePostHandlerOnPost();
601   if(postHandler.cancelPostProcessing)
602    return false;
603   var callee = arguments.callee;
604   this.submit = originalSubmit;
605   var submitResult = this.submit();
606   this.submit = callee;
607   return submitResult;
608  };
609  form = null;
610 },
611 ReplaceFormOnSumbit: function(form) {
612  var originalSubmit = form.onsubmit;
613  form.onsubmit = function() {
614   var postHandler = aspxGetPostHandler();
615   postHandler.beforeOnSubmit();
616   if(postHandler.isMSAjaxRequest)
617    postHandler.isMsAjaxRequest = false;
618   else
619    aspxRaisePostHandlerOnPost(postHandler.GetLastSubmitElementName());
620   if(postHandler.cancelPostProcessing)
621    return false;
622   return ASPx.IsFunction(originalSubmit)
623    ? originalSubmit.apply(this, arguments)
624    : true;
625  };
626  form = null;
627 },
628 SetBeforeOnSubmit: function(action) {
629  this.beforeOnSubmit = action;
630 },
631 SetLastSubmitElementName: function(elementName) {
632  this.lastSubmitElementName = elementName;
633 },
634 GetLastSubmitElementName: function() {
635  return this.lastSubmitElementName;
636 },
637 RemoveDisposedFormsFromCache: function(){
638  for(var i = 0; this.observableForms && i < this.observableForms.length; i++){
639   var form = this.observableForms[i];
640   if(!ASPx.IsExistsElement(form)){
641    ASPx.Data.ArrayRemove(this.observableForms, form);
642    i--;
643   }
644  }
645 }
646});
647var NetworkError = ASPx.CreateClass(null, {
648 constructor: function () {
649  this.message = "Network Error";
650 }
651});
652function aspxRaisePostHandlerOnPost(ownerID, isCallback, isMSAjaxRequest, isDXCallback) {
653 if(ASPxClientControl.postHandlingLocked) return;
654 var postHandler = aspxGetPostHandler();
655 if(postHandler)
656  postHandler.ProcessPostRequest(ownerID, isCallback, isMSAjaxRequest, isDXCallback);
657}
658var aspxPostHandler;
659function aspxGetPostHandler() {
660 if(!aspxPostHandler)
661  aspxPostHandler = new PostHandler();
662 return aspxPostHandler;
663}
664var PostHandlerOnPostEventArgs = ASPx.CreateClass(ASPxClientCancelEventArgs, {
665 constructor: function(ownerID, isCallback, isMSAjaxCallback, isDXCallback){
666  this.constructor.prototype.constructor.call(this);
667  this.ownerID = ownerID;
668  this.isCallback = !!isCallback;
669  this.isDXCallback = !!isDXCallback;
670  this.isMSAjaxCallback = !!isMSAjaxCallback;
671 }
672});
673var ResourceManager = {
674 HandlerStr: "DXR.axd?r=",
675 ResourceHashes: {},
676 SynchronizeResources: function(method){

677  if(!method){
678   method = function(name, resource) { 
679    this.UpdateInputElements(name, resource); 
680   }.aspxBind(this);
681  }
682  var resources = this.GetResourcesData();
683  for(var name in resources)
684   if(resources.hasOwnProperty(name))
685    method(name, resources[name]);
686 },
687 GetResourcesData: function(){
688  return {
689   DXScript: this.GetResourcesElementsString(_aspxGetIncludeScripts(), "src", "DXScript"),
690   DXCss: this.GetResourcesElementsString(_aspxGetLinks(), "href", "DXCss")
691  };
692 },
693 ParseBundleSrc: function(elements, urlAttr){
694  var timeStamp = "";
695  var resourceUrlArray = [];
696  for(var i = 0; i < elements.length; i++) {
697   var resourceUrl = ASPx.Attr.GetAttribute(elements[i], urlAttr);
698   if(resourceUrl) {
699    var pos = resourceUrl.indexOf(this.HandlerStr);
700    if(pos > -1){
701     var list = resourceUrl.substr(pos + this.HandlerStr.length);
702     var ampPos = list.lastIndexOf("-");
703     if(ampPos > -1) {
704      timeStamp = list.substr(ampPos);
705      list = list.substr(0, ampPos);
706     }
707     var indexes = list.split(",");
708     for(var j = 0; j < indexes.length; j++) {
709      resourceUrlArray.push(indexes[j]);
710     }
711    }
712    else
713     resourceUrlArray.push(resourceUrl);
714   }
715  }
716  return {
717   'resourceUrlArray': resourceUrlArray,
718   'timeStamp': timeStamp
719  };
720 },
721 GetResourceHashes: function (id) {
722  if (!this.ResourceHashes[id])
723   this.ResourceHashes[id] = {};
724  return this.ResourceHashes[id];
725 },
726 GetResourcesElementsString: function (elements, urlAttr, id) {
727  var hash = this.GetResourceHashes(id);
728  var resourceUrlArray = this.ParseBundleSrc(elements, urlAttr).resourceUrlArray;
729  for(var i = 0; i < resourceUrlArray.length; i++) {
730   hash[resourceUrlArray[i]] = resourceUrlArray[i];
731  }
732  var array = [];
733  for(var key in hash)
734   if(hash.hasOwnProperty(key))
735    array.push(key);
736  return array.join(",");
737 },
738 GetNewResourcesElementString: function (element, urlAttr, id) {
739  var originalUrl = ASPx.Attr.GetAttribute(element, urlAttr);
740  var handlerStrIndex = originalUrl.indexOf(this.HandlerStr);
741  var dxResources = handlerStrIndex > -1;
742  if(!dxResources) return element[urlAttr];
743  var hash = this.GetResourceHashes(id);
744  var srcInfo = this.ParseBundleSrc([element], urlAttr);
745  var resourceUrlArray = srcInfo.resourceUrlArray;
746  var timeStamp = srcInfo.timeStamp;
747  var newResourceArray = [];
748  for(var i = 0; i < resourceUrlArray.length; i++) {
749    if(!hash[resourceUrlArray[i]])
750    newResourceArray.push(resourceUrlArray[i]);
751  }
752  var newResources = "";
753  if(newResourceArray.length > 0) {
754   var baseUrl = originalUrl.substr(0, handlerStrIndex);
755   newResources = baseUrl + this.HandlerStr + newResourceArray.join(",") + timeStamp;
756  }
757  return newResources;
758 },
759 UpdateInputElements: function(typeName, list){
760  for(var i = 0; i < document.forms.length; i++){
761   var inputElement = document.forms[i][typeName];
762   if(!inputElement)
763    inputElement = this.CreateInputElement(document.forms[i], typeName);
764   inputElement.value = list;
765  }
766 },
767 CreateInputElement: function(form, typeName){
768  var inputElement = ASPx.CreateHiddenField(typeName);
769  form.appendChild(inputElement);
770  return inputElement;
771 }
772};
773ASPx.includeScriptPrefix = "dxis_";
774ASPx.startupScriptPrefix = "dxss_";
775var includeScriptsCache = {};
776var createdIncludeScripts = [];
777var appendedScriptsCount = 0;
778var callbackOwnerNames = [];
779var scriptsRestartHandlers = { };
780function _aspxIsKnownIncludeScript(script) {
781 return !!includeScriptsCache[script.src];
782}
783function _aspxCacheIncludeScript(script) {
784 includeScriptsCache[script.src] = 1;
785}
786function _aspxProcessScriptsAndLinks(ownerName, isCallback) {
787 if(!ASPx.documentLoaded) return; 
788 _aspxProcessScripts(ownerName, isCallback);
789 getLinkProcessor().process();
790 ASPx.ClearCachedCssRules();
791}
792function _aspxGetStartupScripts(container) {
793 return _aspxGetScriptsCore(ASPx.startupScriptPrefix, container);
794}
795function _aspxGetIncludeScripts() {
796 return _aspxGetScriptsCore(ASPx.includeScriptPrefix);
797}
798function _aspxGetScriptsCore(prefix, container) {
799 var result = [];
800 var scripts;
801 if(ASPx.IsExists(container))
802  scripts = ASPx.GetNodesByTagName(container, "SCRIPT");
803 else

804  scripts = document.getElementsByTagName("SCRIPT");
805 for(var i = 0; i < scripts.length; i++) {
806  if(scripts[i].id.indexOf(prefix) == 0)
807   result.push(scripts[i]);
808 }
809 return result;
810}
811function _aspxIsResourceLink(link) {
812 if(typeof link !== "string")
813  link = link.href;
814 return link.toLowerCase().indexOf(ResourceManager.HandlerStr.toLowerCase()) >= 0;
815}
816function _aspxGetLinks(allLinks) {
817 var result = [];
818 var links = document.getElementsByTagName("LINK");
819 for(var i = 0; i < links.length; i++) {
820  if(allLinks || _aspxIsResourceLink(links[i]))
821   result.push(links[i]);
822 }
823 return result;
824}
825function _aspxIsLinksLoaded() {
826 var links = _aspxGetLinks(true);
827 for(var i = 0, link; link = links[i]; i++)
828  if(link.readyState && link.readyState.toLowerCase() == "loading")
829    return false;
830 return true;
831}
832function _aspxInitializeLinks() {
833 var links = _aspxGetLinks(true);
834 for(var i = 0; i < links.length; i++)
835  links[i].loaded = true; 
836}
837var scriptExecutedAttrName = "data-executed";
838var scriptDelayedExecutionAttrName = "data-dx-delayedeval";
839ASPx.MarkInnerScriptBlocksAsDelayedExecution = function(scriptsContainer) {
840 var scripts = scriptsContainer.querySelectorAll("script[id^=" + ASPx.startupScriptPrefix + "]");
841 for(var i = 0; i < scripts.length; i++)
842  ASPx.Attr.SetAttribute(scripts[i], scriptDelayedExecutionAttrName, true);
843};
844function isScriptExecuted(script) {
845 return ASPx.Attr.GetAttribute(script, scriptExecutedAttrName);
846}
847function markScriptAsExecuted(script) {
848 if(ASPx.Attr.GetAttribute(script, scriptDelayedExecutionAttrName))
849  ASPx.Attr.RemoveAttribute(script, scriptDelayedExecutionAttrName);
850 else
851  ASPx.Attr.SetAttribute(script, scriptExecutedAttrName, true);
852}
853function _aspxInitializeScripts() {
854 var scripts = _aspxGetIncludeScripts();
855 for(var i = 0; i < scripts.length; i++)
856  _aspxCacheIncludeScript(scripts[i]);   
857 var startupScripts = _aspxGetStartupScripts();
858 for(var i = 0; i < startupScripts.length; i++)
859  markScriptAsExecuted(startupScripts[i]);
860}
861function _aspxSweepDuplicatedLinks() {
862 var hash = { };
863 var links = _aspxGetLinks();
864 for(var i = 0; i < links.length; i++) {
865  var href = links[i].href;
866  if(!href)
867   continue;
868  if(hash[href]){
869   if(!hash[href].loaded && links[i].loaded) {
870    ASPx.RemoveElement(hash[href]);
871    hash[href] = links[i];
872   }
873   else
874    ASPx.RemoveElement(links[i]);
875  }
876  else
877   hash[href] = links[i];
878 }
879}
880function _aspxSweepDuplicatedScripts() {
881 var hash = { };
882 var scripts = _aspxGetIncludeScripts();
883 for(var i = 0; i < scripts.length; i++) {
884  var src = scripts[i].src;
885  if(!src) continue;
886  if(hash[src])
887   ASPx.RemoveElement(scripts[i]);
888  else
889   hash[src] = scripts[i];
890 }
891}
892function _aspxAreScriptsEqual(script1, script2) {
893 return script1.src == script2.src;
894}
895function _aspxProcessScripts(ownerName, isCallback) {
896 var scripts = _aspxGetIncludeScripts();
897 var previousCreatedScript = null;
898 var firstCreatedScript = null;
899 for(var i = 0; i < scripts.length; i++) {
900  var script = scripts[i];
901  if(script.src == "") continue; 
902  if(_aspxIsKnownIncludeScript(script))
903   continue;
904  var getOnlyNewResources = true;
905  var onlyNewScripts = ResourceManager.GetNewResourcesElementString(script, "src", "DXScript", getOnlyNewResources);
906  if (onlyNewScripts == "")
907   continue;
908  var createdScript = document.createElement("script");
909  ASPx.Attr.AppendScriptType(createdScript);
910  createdScript.src = onlyNewScripts;
911  createdScript.id = script.id;
912  if(ASPx.Data.ArrayIndexOf(createdIncludeScripts, createdScript, _aspxAreScriptsEqual) >= 0)
913   continue;
914  createdIncludeScripts.push(createdScript);
915  ASPx.RemoveElement(script);
916  if(ASPx.Browser.Edge || ASPx.Browser.WebKitFamily || (ASPx.Browser.Firefox && ASPx.Browser.Version >= 4) || ASPx.Browser.IE) {
917   createdScript.onload = new Function("ASPx.OnScriptLoadCallback(this, " + isCallback + ");");
918   if(firstCreatedScript == null)
919    firstCreatedScript = createdScript;
920   createdScript.nextCreatedScript = null;
921   if(previousCreatedScript != null)
922    previousCreatedScript.nextCreatedScript = createdScript;
923   previousCreatedScript = createdScript;
924  } else {
925   createdScript.onload = new Function("ASPx.OnScriptLoadCallback(this);");
926   ASPx.AppendScript(createdScript);
927   _aspxCacheIncludeScript(createdScript);
928  }
929 }
930 if(firstCreatedScript != null) {
931  ASPx.AppendScript(firstCreatedScript);
932  _aspxCacheIncludeScript(firstCreatedScript);
933 }
934 if(isCallback)

935  callbackOwnerNames.push(ownerName);
936 if(createdIncludeScripts.length == 0) {
937  var newLinks = ASPx.GetNodesByTagName(document.body, "link");
938  var needProcessLinks = isCallback && newLinks.length > 0;
939  if(needProcessLinks)
940   needProcessLinks = getLinkProcessor().addLinks(newLinks);
941  if(!needProcessLinks)
942   ASPx.FinalizeScriptProcessing(isCallback);
943 }
944}
945ASPx.FinalizeScriptProcessing = function(isCallback) {
946 createdIncludeScripts = [];
947 appendedScriptsCount = 0;
948 var linkProcessor = getLinkProcessor();
949 if(linkProcessor.hasLinks())
950  _aspxSweepDuplicatedLinks();
951 linkProcessor.reset();
952 _aspxSweepDuplicatedScripts();
953 ResourceManager.SynchronizeResources();
954 _aspxRunStartupScripts(isCallback);
955};
956var startupScriptsRunning = false;
957function _aspxRunStartupScripts(isCallback, container) {
958 startupScriptsRunning = true;
959 try {
960  _aspxRunStartupScriptsCore(container);
961 }
962 finally {
963  startupScriptsRunning = false;
964 }
965 if(ASPx.documentLoaded) {
966  ASPx.GetControlCollection().ProcessActionByPredicate(
967   function(collection) { collection.InitializeElements(isCallback); },
968   function(control) { return !ASPx.IsExists(container) || ASPx.GetIsParent(container, control.GetMainElement()); }
969  );
970  for(var key in scriptsRestartHandlers)
971   if(scriptsRestartHandlers.hasOwnProperty(key))
972    scriptsRestartHandlers[key]();
973  if(isCallback)
974   _aspxRunEndCallbackScript();
975 }
976}
977function _aspxIsStartupScriptsRunning(isCallback) {
978 return startupScriptsRunning;
979}
980function _aspxRunStartupScriptsCore(container) {
981 var scripts = _aspxGetStartupScripts(container);
982 var code;
983 for(var i = 0; i < scripts.length; i++){
984  var script = scripts[i];
985  if(!isScriptExecuted(script)) {
986   _aspxEnsureStartupScriptIsUnique(script.id); 
987   code = ASPx.GetScriptCode(script);
988   eval(code);
989   markScriptAsExecuted(script);
990  }
991 }
992}
993function _aspxEnsureStartupScriptIsUnique(scriptId) {
994 if(!scriptId)
995  return;
996 var scriptExecutedSelector = "script[" + scriptExecutedAttrName + "='true']#" + scriptId;
997 ASPx.RemoveElement(document.querySelector(scriptExecutedSelector));
998}
999function _aspxRunEndCallbackScript() {
1000 while(callbackOwnerNames.length > 0) {
1001  var callbackOwnerName = callbackOwnerNames.pop();
1002  var callbackOwner = ASPx.GetControlCollection().Get(callbackOwnerName);
1003  if(callbackOwner)
1004   callbackOwner.DoEndCallback();
1005 }
1006}
1007ASPx.RunStartupScriptsCreatedOnClient = function(container) {
1008 _aspxRunStartupScriptsCore(container);
1009};
1010ASPx.OnScriptReadyStateChangedCallback = function(scriptElement, isCallback) {
1011 if(scriptElement.readyState == "loaded") {
1012  _aspxCacheIncludeScript(scriptElement);
1013  for(var i = 0; i < createdIncludeScripts.length; i++) {
1014   var script = createdIncludeScripts[i];
1015   if(_aspxIsKnownIncludeScript(script)) {
1016    if(!isScriptExecuted(script)) {
1017     markScriptAsExecuted(script);
1018     ASPx.AppendScript(script);
1019     appendedScriptsCount++;
1020    }
1021   } else
1022    break;
1023  }
1024  if(createdIncludeScripts.length == appendedScriptsCount)
1025   ASPx.FinalizeScriptProcessing(isCallback);
1026 }
1027};
1028ASPx.OnScriptLoadCallback = function(scriptElement, isCallback) {
1029 appendedScriptsCount++;
1030 if(scriptElement.nextCreatedScript) {
1031  ASPx.AppendScript(scriptElement.nextCreatedScript);
1032  _aspxCacheIncludeScript(scriptElement.nextCreatedScript);
1033 }
1034 if(createdIncludeScripts.length == appendedScriptsCount)
1035  ASPx.FinalizeScriptProcessing(isCallback);
1036};
1037function _aspxAddScriptsRestartHandler(objectName, handler) {
1038 scriptsRestartHandlers[objectName] = handler;
1039}
1040function _aspxMoveLinkElements() {
1041 var head = ASPx.GetNodesByTagName(document, "head")[0];
1042 var bodyLinks = ASPx.GetNodesByTagName(document.body, "link");
1043 if(head && bodyLinks.length > 0){
1044  var headLinks = ASPx.GetNodesByTagName(head, "link");
1045  var dxLinkAnchor = head.firstChild;
1046  for(var i = 0; i < headLinks.length; i++){
1047   if(_aspxIsResourceLink(headLinks[i]))
1048    dxLinkAnchor = headLinks[i].nextSibling;
1049  }
1050  while(bodyLinks.length > 0) 
1051   head.insertBefore(bodyLinks[0], dxLinkAnchor);
1052 }
1053}
1054var LinkProcessor = ASPx.CreateClass(null, {
1055 constructor: function() {
1056  this.linkInfos = [];
1057  this.loadingObservationTimerID = -1;
1058 },
1059 process: function() {
1060  if(this.hasLinks()) {
1061   if(this.isLinkLoadEventSupported())
1062    this.processViaLoadEvent();
1063   else
1064    this.processViaTimer();
1065  }
1066  else
1067   _aspxSweepDuplicatedLinks();

1068  _aspxMoveLinkElements();
1069 },
1070 addLinks: function(links) {
1071  var prevLinkCount = this.linkInfos.length;
1072  for(var i = 0; i < links.length; i++) {
1073   var link = links[i];
1074   if(link.loaded || link.rel != "stylesheet" || !_aspxIsResourceLink(link))
1075    continue;
1076   var linkInfo = {
1077    link: link,
1078    href: link.href
1079   };
1080   this.linkInfos.push(linkInfo);
1081  }
1082  return prevLinkCount != this.linkInfos.length;
1083 },
1084 hasLinks: function() {
1085  return this.linkInfos.length > 0;
1086 },
1087 reset: function() {
1088  this.linkInfos = [];
1089 },
1090 processViaLoadEvent: function() {
1091  for(var i = 0, linkInfo; linkInfo = this.linkInfos[i]; i++)
1092   linkInfo.link.onload = this.onLinkLoad.bind(this);
1093 },
1094 isLinkLoadEventSupported: function() {
1095  return !(ASPx.Browser.Chrome && ASPx.Browser.MajorVersion < 19 || ASPx.Browser.Firefox && ASPx.Browser.MajorVersion < 9 ||
1096   ASPx.Browser.Safari && ASPx.Browser.MajorVersion < 6 || ASPx.Browser.AndroidDefaultBrowser && ASPx.Browser.MajorVersion < 4.4);
1097 },
1098 processViaTimer: function() {
1099  if(this.loadingObservationTimerID == -1)
1100   this.onLinksLoadingObserve();
1101 },
1102 onLinksLoadingObserve: function() {
1103  if(this.getIsAllLinksLoaded()) {
1104   this.loadingObservationTimerID = -1;
1105   this.onAllLinksLoad();
1106  }
1107  else
1108   this.loadingObservationTimerID = window.setTimeout(this.onLinksLoadingObserve.aspxBind(this), 100);
1109 },
1110 getIsAllLinksLoaded: function() {
1111  var styleSheets = document.styleSheets;
1112  var loadedLinkHrefs = { };
1113  for(var i = 0; i < styleSheets.length; i++) {
1114   var styleSheet = styleSheets[i];
1115   try {
1116    if(styleSheet.cssRules)
1117     loadedLinkHrefs[styleSheet.href] = 1;
1118   }
1119   catch(ex) { }
1120  }
1121  var loadedLinksCount = 0;
1122  for(var i = 0, linkInfo; linkInfo = this.linkInfos[i]; i++) {
1123   if(loadedLinkHrefs[linkInfo.href])
1124    loadedLinksCount++;
1125  }
1126  return loadedLinksCount == this.linkInfos.length;
1127 },
1128 onAllLinksLoad: function() {
1129  this.reset();
1130  _aspxSweepDuplicatedLinks();
1131  if(createdIncludeScripts.length == 0)
1132   ASPx.FinalizeScriptProcessing(true);
1133 },
1134 onLinkReadyStateChanged: function(linkElement) {
1135  if(linkElement.readyState == "complete")
1136   this.onLinkLoadCore(linkElement);
1137 },
1138 onLinkLoad: function(evt) {
1139  var linkElement = ASPx.Evt.GetEventSource(evt);
1140  this.onLinkLoadCore(linkElement);
1141 },
1142 onLinkLoadCore: function(linkElement) {
1143  var linkInfo = this.getLinkInfo(linkElement);
1144  if(!linkInfo) return;
1145  linkInfo.loaded = true;
1146  var notLoadedLinks = this.linkInfos.filter(function(info) { return !info.loaded; });
1147  if(notLoadedLinks.length == 0)
1148   this.onAllLinksLoad();
1149 },
1150 getLinkInfo: function(linkElement) {
1151  for(var i = 0, linkInfo; linkInfo = this.linkInfos[i]; i++) {
1152   if(linkInfo.link == linkElement)
1153    return linkInfo;
1154  }
1155 }
1156});
1157var linkProcessor = null;
1158function getLinkProcessor() {
1159 if(linkProcessor == null)
1160  linkProcessor = new LinkProcessor();
1161 return linkProcessor;
1162}
1163ASPx.LinkProcessor = LinkProcessor;
1164var IFrameHelper = ASPx.CreateClass(null, {
1165 constructor: function(params) {
1166  this.params = params || {};
1167  this.params.src = this.params.src || "";
1168  this.CreateElements();
1169 },
1170 CreateElements: function() {
1171  var elements = IFrameHelper.Create(this.params);
1172  this.containerElement = elements.container;
1173  this.iframeElement = elements.iframe;
1174  this.AttachOnLoadHandler(this, this.iframeElement);
1175  this.SetLoading(true);
1176  if(this.params.onCreate)
1177   this.params.onCreate(this.containerElement, this.iframeElement);
1178 },
1179 AttachOnLoadHandler: function(instance, element) {
1180  ASPx.Evt.AttachEventToElement(element, "load", function() {
1181   instance.OnLoad(element);
1182  });
1183 },
1184 OnLoad: function(element) {
1185  this.SetLoading(false, element);
1186  if(!element.preventCustomOnLoad && this.params.onLoad)
1187   this.params.onLoad();
1188 },
1189 IsLoading: function(element) {
1190  element = element || this.iframeElement;
1191  if(element)
1192   return element.loading;
1193  return false;
1194 },
1195 SetLoading: function(value, element) {
1196  element = element || this.iframeElement;
1197  if(element)
1198   element.loading = value;
1199 },
1200 GetContentUrl: function() {
1201  return this.params.src;
1202 },
1203 SetContentUrl: function(url, preventBrowserCaching) {
1204  if(url) {
1205   this.params.src = url;
1206   if(preventBrowserCaching)
1207    url = IFrameHelper.AddRandomParamToUrl(url);

1208   this.SetLoading(true);
1209   this.iframeElement.src = url;
1210  }
1211 },
1212 RefreshContentUrl: function() {
1213  if(this.IsLoading())
1214   return;
1215  this.SetLoading(true);
1216  var oldContainerElement = this.containerElement;
1217  var oldIframeElement = this.iframeElement;
1218  var postfix = "_del" + Math.floor(Math.random()*100000).toString();
1219  if(this.params.id)
1220   oldIframeElement.id = this.params.id + postfix;
1221  if(this.params.name)
1222   oldIframeElement.name = this.params.name + postfix;
1223  ASPx.SetStyles(oldContainerElement, { height: 0 });
1224  this.CreateElements();
1225  oldIframeElement.preventCustomOnLoad = true;
1226  oldIframeElement.src = ASPx.BlankUrl;
1227  window.setTimeout(function() {
1228   oldContainerElement.parentNode.removeChild(oldContainerElement);
1229  }, 10000); 
1230 }
1231});
1232IFrameHelper.Create = function(params) {
1233 var iframeHtmlStringParts = [ "<iframe frameborder='0'" ];
1234 if(params) {
1235  if(params.id)
1236   iframeHtmlStringParts.push(" id='", params.id, "'");
1237  if(params.name)
1238   iframeHtmlStringParts.push(" name='", params.name, "'");
1239  if(params.title)
1240   iframeHtmlStringParts.push(" title='", params.title, "'");
1241  if(params.scrolling)
1242   iframeHtmlStringParts.push(" scrolling='", params.scrolling, "'");
1243  if(params.src)
1244   iframeHtmlStringParts.push(" src='", params.src, "'");
1245 }
1246 iframeHtmlStringParts.push("></iframe>");
1247 var containerElement = ASPx.CreateHtmlElementFromString("<div style='border-width: 0px; padding: 0px; margin: 0px'></div>");
1248 var iframeElement = ASPx.CreateHtmlElementFromString(iframeHtmlStringParts.join(""));
1249 containerElement.appendChild(iframeElement);
1250 return {
1251  container: containerElement,
1252  iframe: iframeElement
1253 };
1254};
1255IFrameHelper.AddRandomParamToUrl = function(url) {
1256 var prefix = url.indexOf("?") > -1
1257  ? "&"
1258  : "?";
1259 var param = prefix + Math.floor(Math.random()*100000).toString();
1260 var anchorIndex = url.indexOf("#");
1261 return anchorIndex == -1
1262  ? url + param
1263  : url.substr(0, anchorIndex) + param + url.substr(anchorIndex);
1264};
1265IFrameHelper.GetWindow = function(name) {
1266 var frameElement = document.getElementById(name);
1267 return (frameElement != null) ? frameElement.contentWindow : null;
1268};
1269IFrameHelper.GetDocument = function(name) {
1270 var frameElement = document.getElementById(name);
1271 return (frameElement != null) ? frameElement.contentDocument : null;
1272};
1273IFrameHelper.GetDocumentBody = function(name) {
1274 var doc = IFrameHelper.GetDocument(name);
1275 return (doc != null) ? doc.body : null;
1276};
1277IFrameHelper.GetDocumentHead = function (name) {
1278 var doc = IFrameHelper.GetDocument(name);
1279 return (doc != null) ? doc.head || doc.getElementsByTagName('head')[0] : null;
1280};
1281IFrameHelper.GetElement = function(name) {
1282 return document.getElementById(name);
1283};
1284var KbdHelper = ASPx.CreateClass(null, {
1285 constructor: function(control) {
1286  this.control = control;
1287  this.ready = false;
1288  this.clickHandler = this.HandleClick.bind(this);
1289  this.focusHandler = this.onElementFocus.bind(this);
1290  this.blurHandler = this.onBlur.bind(this);
1291 },
1292 Init: function() {
1293  if(!this.ready){
1294   KbdHelper.GlobalInit();
1295   var elements = this.getFocusableElements();
1296   for(var i = 0; i < elements.length; i++) {
1297    var element = elements[i];
1298    element.tabIndex = Math.max(element.tabIndex, 0);
1299    ASPx.Evt.AttachEventToElement(element, "click", this.clickHandler);
1300    ASPx.Evt.AttachEventToElement(element, "focus", this.focusHandler);
1301    ASPx.Evt.AttachEventToElement(element, "blur", this.blurHandler);
1302   }
1303   this.ready = true;
1304  }
1305 },
1306 Dispose: function() {
1307  if(this.ready) {
1308   var elements = this.getFocusableElements();
1309   for(var i = 0; i < elements.length; i++) {
1310    var element = elements[i];
1311    element.tabIndex = -1;
1312    ASPx.Evt.DetachEventFromElement(element, "click", this.clickHandler);
1313    ASPx.Evt.DetachEventFromElement(element, "focus", this.focusHandler);
1314    ASPx.Evt.DetachEventFromElement(element, "blur", this.blurHandler);
1315   }
1316   this.ready = false;
1317  }
1318 },
1319 onElementFocus: function(e) {
1320  if(!this.CanFocus(e))
1321   return true;
1322  KbdHelper.active = this;
1323 },
1324 getFocusableElements: function() {
1325  return [this.GetFocusableElement()]; 
1326 },
1327 GetFocusableElement: function() { return this.control.GetMainElement(); },
1328 canHandleNoFocusAction: function() { 
1329  var focusableElements = this.getFocusableElements();
1330  for(var i = 0; i < focusableElements.length; i++) {
1331   if(focusableElements[i] === _aspxGetFocusedElement())
1332    return false;
1333  }
1334  return true;
1335 },
1336 RequirePreventScrollOnFocus: function() { return false; },
1337 CanFocus: function(e) {
1338  var tag = ASPx.Evt.GetEventSource(e).tagName;
1339  return !(tag === "A" || tag === "TEXTAREA" || tag === "INPUT" || tag === "SELECT" || tag === "IFRAME" || tag === "OBJECT");
1340 },
1341 HandleClick: function(e) {
1342  if(!this.CanFocus(e))
1343   return;
1344  this.Focus();
1345 },
1346 Focus: function() {
1347  var preventScroll = this.RequirePreventScrollOnFocus();
1348  var savedDocumentScrollTop = preventScroll ? ASPx.GetDocumentScrollTop() : -1;
1349  try {
1350   this.GetFocusableElement().focus({ preventScroll: preventScroll });
1351  } catch(e) { }
1352  if(preventScroll && !this.IsNativePreventScrollOnFocusSupported() && savedDocumentScrollTop !== ASPx.GetDocumentScrollTop())
1353   ASPx.SetDocumentScrollTop(savedDocumentScrollTop);
1354 },
1355 IsNativePreventScrollOnFocusSupported: function() {
1356  if(this.isNativePreventScrollOnFocusSupported === undefined)
1357   this.isNativePreventScrollOnFocusSupported = this.CalcIsNativePreventScrollOnFocusSupported();
1358  return this.isNativePreventScrollOnFocusSupported;
1359 },
1360 CalcIsNativePreventScrollOnFocusSupported: function() {
1361  var result = false;
1362  try {
1363   ASPx.GetActiveElement().focus(Object.defineProperty({}, "preventScroll", { get: function() { result = true; } }));
1364  } catch(e) { result = false; }
1365  return result;
1366 },
1367 onBlur: function(){
1368  delete KbdHelper.active;
1369 },
1370 HandleKeyDown: function(e) { }, 
1371 HandleKeyPress: function(e) { }, 
1372 HandleKeyUp: function (e) { },
1373 HandleNoFocusAction: function(e) { },
1374 FocusByAccessKey: function () { }
1375});
1376KbdHelper.GlobalInit = function() {
1377 if(KbdHelper.ready)
1378  return;
1379 ASPx.Evt.AttachEventToDocument("keydown", KbdHelper.OnKeyDown);
1380 ASPx.Evt.AttachEventToDocument("keypress", KbdHelper.OnKeyPress);
1381 ASPx.Evt.AttachEventToDocument("keyup", KbdHelper.OnKeyUp);
1382 KbdHelper.ready = true; 
1383};
1384KbdHelper.swallowKey = false;
1385KbdHelper.accessKeys = { };
1386KbdHelper.ProcessKey = function(e, actionName) {
1387 if(!KbdHelper.active) 
1388  return;
1389 if (KbdHelper.active.canHandleNoFocusAction()) {
1390  KbdHelper.active["HandleNoFocusAction"](e, actionName);
1391  return;
1392 }
1393 var ctl = KbdHelper.active.control;
1394 if(ctl !== ASPx.GetControlCollection().Get(ctl.name)) {
1395  delete KbdHelper.active;
1396  return;
1397 }
1398 if(!KbdHelper.swallowKey) 
1399  KbdHelper.swallowKey = KbdHelper.active[actionName](e);
1400 if(KbdHelper.swallowKey)
1401  ASPx.Evt.PreventEvent(e);
1402};

1403KbdHelper.OnKeyDown = function(e) {
1404 KbdHelper.swallowKey = false;
1405 if(KbdHelper.TryAccessKey(KbdHelper.getKeyName(e)))
1406  ASPx.Evt.PreventEvent(e);
1407 else 
1408  KbdHelper.ProcessKey(e, "HandleKeyDown"); 
1409};
1410KbdHelper.OnKeyPress = function(e) { KbdHelper.ProcessKey(e, "HandleKeyPress"); };
1411KbdHelper.OnKeyUp = function(e) { KbdHelper.ProcessKey(e, "HandleKeyUp"); };
1412KbdHelper.RegisterAccessKey = function(obj) {
1413 var key;
1414 if(obj.accessKey)
1415  key = "CtrlShift" + obj.accessKey;
1416 else if(obj.keyTipModeShortcut)
1417  key = obj.keyTipModeShortcut;
1418 if(!key) return;
1419 KbdHelper.accessKeys[key.toLowerCase()] = obj.name;
1420};
1421KbdHelper.TryAccessKey = function(code) {
1422 var key = code.toLowerCase ? code.toLowerCase() : String.fromCharCode(code).toLowerCase();
1423 var name = KbdHelper.accessKeys[key];
1424 if(!name) return false;
1425 var obj = ASPx.GetControlCollection().Get(name);
1426 return KbdHelper.ClickAccessKey(obj);
1427};
1428KbdHelper.ClickAccessKey = function (control) {
1429 if (!control) return false;
1430 var el = control.GetMainElement();
1431 if (!el) return false;
1432 el.focus();
1433 setTimeout(function () {
1434  if (KbdHelper.active && KbdHelper.active.FocusByAccessKey)
1435   KbdHelper.active.FocusByAccessKey();
1436 }.aspxBind(this), ASPx.FOCUS_TIMEOUT);
1437 return true;
1438};
1439KbdHelper.getKeyName = function(e) {
1440 var name = "";
1441 if(e.altKey)
1442  name += "Alt";
1443 if(e.ctrlKey)
1444  name += "Ctrl";
1445 if(e.shiftKey)
1446  name += "Shift";
1447 var keyCode = e.key || e.code || String.fromCharCode(ASPx.Evt.GetKeyCode(e));
1448 if(keyCode.match(/key/i))
1449  name += keyCode.replace(/key/i, "");
1450 else if(keyCode.match(/digit/i))
1451  name += keyCode.replace(/digit/i, "");
1452 else if(keyCode.match(/arrow/i))
1453  name += keyCode.replace(/arrow/i, "");
1454 else if(keyCode.match(/ins/i))
1455  name += "Ins";
1456 else if(keyCode.match(/del/i))
1457  name += "Del";
1458 else if(keyCode.match(/back/i))
1459  name += "Back";
1460 else if(!keyCode.match(/alt/i) && !keyCode.match(/control/i) && !keyCode.match(/shift/i))
1461  name += keyCode;
1462 return name.replace(/^a-zA-Z0-9/, "");
1463};
1464AccessKeysHelper = ASPx.CreateClass(KbdHelper, {
1465 constructor: function (control) {
1466  this.constructor.prototype.constructor.call(this, control);
1467  this.accessKeysVisible = false;
1468  this.activeKey = null;
1469  this.accessKey = control.createAccessKey ? control.createAccessKey(control.accessKey) : new AccessKey(control.accessKey);
1470  this.accessKeys = this.accessKey.accessKeys;
1471  this.charIndex = 0;
1472  this.onFocusByAccessKey = null;
1473  this.onClose = null;
1474  this.manualStopProcessing = false;
1475  this.isActive = false;
1476  this.areAccessKeysShown = false;
1477 },
1478 Init: function (control) {
1479  KbdHelper.prototype.Init.call(this);
1480  KbdHelper.RegisterAccessKey(control);   
1481 },
1482 Add: function (accessKey) {
1483  this.accessKey.Add(accessKey);
1484 },
1485 HandleKeyDown: function (e) {
1486  var keyCode = ASPx.Evt.GetKeyCode(e);
1487  var stopProcessing = this.processKeyDown(keyCode);
1488  if (stopProcessing.value) {
1489   this.stopProcessing();
1490   if(this.onClosedOnEscape && (keyCode == ASPx.Key.Esc || stopProcessing.fireEvent))
1491    this.onClosedOnEscape();
1492  }
1493  return stopProcessing;
1494 },
1495 HandleNoFocusAction: function (e, actionName) {
1496  var keyCode = ASPx.Evt.GetKeyCode(e);
1497  if (this.onClosedOnEscape && keyCode == ASPx.Key.Esc && actionName == "HandleKeyDown")
1498   this.onClosedOnEscape();
1499 },
1500 Activate: function () {
1501  KbdHelper.ClickAccessKey(this.control);
1502  this.areAccessKeysShown = true;
1503 },
1504 Stop: function() {
1505  this.stopProcessing();
1506 },
1507 stopProcessing: function () {
1508  this.HideAccessKeys();
1509  if (KbdHelper.active && this.isActive) {
1510   this.isActive = false;
1511   KbdHelper.active.control.GetMainElement().blur();
1512   delete KbdHelper.active;
1513  }
1514 },
1515 onBlur: function() {
1516  if (this.manualStopProcessing) {
1517   this.manualStopProcessing = false;
1518   return;
1519  }
1520  this.HideAccessKeys();
1521  KbdHelper.prototype.onBlur.call(this);
1522 },
1523 processKeyDown: function (keyCode) {
1524  switch (keyCode) {
1525   case ASPx.Key.Left:
1526    this.TryMoveFocusLeft();
1527    return { value: false };
1528   case ASPx.Key.Right:
1529    this.TryMoveFocusRight();
1530    return { value: false };
1531   case ASPx.Key.Esc:
1532    if(this.control.hideAllPopups)
1533     this.control.hideAllPopups(true, true);
1534    if(this.activeKey)
1535     this.activeKey = this.activeKey.Return();
1536    this.charIndex = 0;
1537    if (!this.activeKey)
1538     return { value: true };
1539    break;
1540   case ASPx.Key.Enter:
1541    return { value: true };
1542   default:
1543    if (!ASPx.IsPrintableKey(keyCode))
1544     return { value: false };
1545    var char = String.fromCharCode(keyCode).toUpperCase();
1546    var needToContinue = { value: false };
1547    var keyResult;
1548    if(this.activeKey)

1549     keyResult = this.activeKey.TryAccessKey(char, this.charIndex, needToContinue);
1550    if (needToContinue.value) {
1551     this.charIndex++;
1552     return { value: false };
1553    }
1554    this.charIndex = 0;
1555    if(keyResult !== undefined)
1556     this.activeKey = keyResult;
1557    else
1558     return { value: true, fireEvent: true };
1559    if (!this.activeKey || !this.activeKey.accessKeys || this.activeKey.accessKeys.length == 0) {
1560     if (this.activeKey && this.activeKey.manualStopProcessing) {
1561      this.manualStopProcessing = true;
1562      break;
1563     }
1564     return { value: true, fireEvent: true };
1565    }
1566  }
1567  return { value: false };
1568 },
1569 TryMoveFocusLeft: function (modifier) {},
1570 TryMoveFocusRight: function (modifier) {},
1571 TryMoveFocusUp: function (modifier) {},
1572 TryMoveFocusDown: function (modifier) {},
1573 FocusByAccessKey: function() {
1574  if (this.onFocusByAccessKey)
1575   this.onFocusByAccessKey();
1576  this.HideAccessKeys();
1577  KbdHelper.prototype.FocusByAccessKey.call(this);
1578  this.activeKey = this.accessKey;
1579  this.activeKey.execute();
1580  this.isActive = true;
1581  this.areAccessKeysShown = true;
1582 },
1583 HideAccessKeys: function() {
1584  this.areAccessKeysShown = false;
1585  this.hideAccessKeys(this.accessKey);
1586 },
1587 Update: function() {
1588  this.throttleMethod(this.refresh, 100);
1589 },
1590 refresh: function() {
1591  if(this.activeKey && this.areAccessKeysShown) {
1592   this.activeKey.execute();
1593  }
1594 },
1595 throttleMethod: function(method, delay) {
1596  clearTimeout(method.timerId);
1597  method.timerId = setTimeout(function() {
1598   method.call(this);
1599  }.aspxBind(this), delay);
1600 },
1601 AreAccessKeysShown: function() {
1602  return this.areAccessKeysShown;
1603 },
1604 hideAccessKeys: function (accessKey) {
1605  for (var i = 0, ak; ak = accessKey.accessKeys[i]; i++) {
1606   this.hideAccessKeys(ak);
1607  }
1608  if (accessKey)
1609   accessKey.hide();
1610 },
1611 HandleClick: function(e) {
1612  KbdHelper.prototype.HandleClick.call(this, e);
1613  this.stopProcessing();
1614 }
1615});
1616AccessKey = ASPx.CreateClass(null, {
1617 constructor: function (popupItem, getPopupElement, keyTipElement, key, onlyClick, manualStopProcessing) {
1618  this.key = key ? key : keyTipElement ? ASPxClientUtils.Trim(ASPx.GetInnerText(keyTipElement)) : null;
1619  this.popupItem = popupItem;
1620  this.getPopupElement = getPopupElement;
1621  this.keyTipElement = keyTipElement;
1622  this.accessKeys = [];
1623  this.needShowChilds = true;
1624  this.parent = null;
1625  this.onlyClick = onlyClick;
1626  this.manualStopProcessing = manualStopProcessing;
1627 },
1628 Add: function (accessKey) {
1629  this.accessKeys.push(accessKey);
1630  accessKey.parent = this;
1631 },
1632 TryAccessKey: function (char, index, needToContinue) {
1633  if (!this.accessKeys || this.accessKeys.length == 0)
1634   return;
1635  for (var i = 0, accessKey; accessKey = this.accessKeys[i]; i++) {
1636   if (accessKey.key[index] == char && accessKey.isVisible()) {
1637    if (accessKey.key[index + 1]) {
1638     needToContinue.value = true;
1639    }
1640    else {
1641     accessKey.execute();
1642     return accessKey;
1643    }
1644   } else {
1645    accessKey.hide();
1646   }
1647  }
1648  for (var i = 0, accessKey; accessKey = this.accessKeys[i]; i++) {
1649   var key = accessKey.TryAccessKey(char, index, needToContinue);
1650   if (key)
1651    return key;
1652  }
1653  return;
1654 },
1655 isVisible: function(){
1656  return ASPx.GetElementVisibility(this.keyTipElement);
1657 },
1658 Return: function () {
1659  this.hideChildAccessKeys();
1660  if (this.parent) {
1661   this.parent.showAccessKeys(true);
1662  }  
1663  return this.parent;
1664 },
1665 execute: function () {
1666  this.hideAll();
1667  if (this.popupItem && this.popupItem.accessKeyClick && !this.onlyClick)
1668   this.popupItem.accessKeyClick();
1669  if (this.getPopupElement && this.onlyClick)
1670   ASPx.Evt.EmulateMouseClick(this.getPopupElement(this.popupItem));
1671  if (this.accessKeys)
1672   setTimeout(function () {
1673    this.showAccessKeys(true);
1674   }.aspxBind(this), 100);
1675 },
1676 showAccessKeys: function(directShow) {
1677  if (!directShow && !this.needShowChilds)
1678   return;
1679  for (var i = 0; i < this.accessKeys.length; i++) {
1680   var accessKey = this.accessKeys[i];
1681   if (accessKey) {
1682    var popupElement = accessKey.getPopupElement ? accessKey.getPopupElement(accessKey.popupItem) : null;
1683    if (popupElement && this.isElementVisible(popupElement)) {
1684     this.show(accessKey);
1685    }
1686    accessKey.showAccessKeys();
1687   }
1688  }
1689 },
1690 isElementVisible: function (el) { return ASPx.IsElementVisible(el, true); },
1691 show: function(accessKey) {
1692  var keyTipElement = accessKey.keyTipElement;
1693  var popupElement = accessKey.getPopupElement(accessKey.popupItem);
1694  this.showKeyTipElement(keyTipElement, this.calculateCoordinates(accessKey, keyTipElement, popupElement));
1695 },
1696 showKeyTipElement: function (keyTipElement, coordinates) {
1697  ASPx.SetAbsoluteY(keyTipElement, coordinates.top);
1698  ASPx.SetAbsoluteX(keyTipElement, coordinates.left);
1699  ASPx.SetElementVisibility(keyTipElement, true); 
1700 },
1701 calculateCoordinates: function (accessKey, keyTipElement, popupElement) {
1702  var top = ASPx.GetAbsolutePositionY(popupElement);
1703  var left = ASPx.GetAbsolutePositionX(popupElement);
1704  if (accessKey.popupItem.getAccessKeyPosition)
1705   switch (accessKey.popupItem.getAccessKeyPosition()) {
1706    case "AboveRight":
1707     left = left + popupElement.offsetWidth - keyTipElement.offsetWidth / 3;
1708     top = top - keyTipElement.offsetHeight / 2;
1709     break;
1710    case "Right":
1711     left = left + popupElement.offsetWidth - keyTipElement.offsetWidth / 3;

1712     top = top + popupElement.offsetHeight / 2 - keyTipElement.offsetHeight / 2;
1713     break;
1714    case "BelowRight":
1715     left = left + popupElement.offsetWidth - keyTipElement.offsetWidth / 3;
1716     top = top + keyTipElement.offsetHeight / 2;
1717     break;
1718    default:
1719     top = top + popupElement.offsetHeight;
1720     left = left + popupElement.offsetWidth / 2 - keyTipElement.offsetWidth / 2;
1721     break;
1722   }
1723  else {
1724   top = top + popupElement.offsetHeight;
1725   left = left + popupElement.offsetWidth / 2 - keyTipElement.offsetWidth / 2;
1726  }
1727  return { top: top, left: left };
1728 },
1729 hide: function() {
1730  if (this.keyTipElement)
1731   ASPx.SetElementVisibility(this.keyTipElement, false);
1732 },
1733 hideChildAccessKeys: function () {
1734  this.hideAccessKeys(this.accessKeys);
1735 },
1736 hideAccessKeys: function (accessKeys) {
1737  if (accessKeys) {
1738   for (var i = 0, accessKey; accessKey = accessKeys[i]; i++) {
1739    if (accessKey.keyTipElement)
1740     accessKey.hide();
1741    accessKey.hideChildAccessKeys();
1742   }
1743  }
1744 },
1745 hideAll: function () {
1746  this.getRoot(this).hideChildAccessKeys();
1747 },
1748 getRoot: function (accessKey) {
1749  if (!accessKey.parent)
1750   return accessKey;
1751  return this.getRoot(accessKey.parent);
1752 }
1753});
1754var focusedElement = null;
1755function aspxOnElementFocused(evt) {
1756 evt = ASPx.Evt.GetEvent(evt);
1757 if(evt && evt.target)
1758  focusedElement = evt.target;
1759}
1760function _aspxInitializeFocus() {
1761 if(!ASPx.GetActiveElement())
1762  ASPx.Evt.AttachEventToDocument("focus", aspxOnElementFocused);
1763}
1764function _aspxGetFocusedElement() {
1765 var activeElement = ASPx.GetActiveElement();
1766 return activeElement ? activeElement : focusedElement;
1767}
1768CheckBoxCheckState = {
1769 Checked : "Checked",
1770 Unchecked : "Unchecked",
1771 Indeterminate : "Indeterminate"
1772};
1773CheckBoxInputKey = { 
1774 Checked : "C",
1775 Unchecked : "U",
1776 Indeterminate : "I"
1777};
1778var CheckableElementStateController = ASPx.CreateClass(null, {
1779 constructor: function(imageProperties) {
1780  this.checkBoxStates = [];
1781  this.imageProperties = imageProperties;
1782  this.customImageMarkerClassName = "dxcbCI";
1783 },
1784 GetValueByInputKey: function(inputKey) {
1785  return this.GetFirstValueBySecondValue("Value", "StateInputKey", inputKey);
1786 },
1787 GetInputKeyByValue: function(value) {
1788  return this.GetFirstValueBySecondValue("StateInputKey", "Value", value);
1789 },
1790 GetImagePropertiesNumByInputKey: function(value) {
1791  return this.GetFirstValueBySecondValue("ImagePropertiesNumber", "StateInputKey", value);
1792 },
1793 GetNextCheckBoxValue: function(currentValue, allowGrayed) {
1794  var currentInputKey = this.GetInputKeyByValue(currentValue);
1795  var nextInputKey = '';
1796  switch(currentInputKey) {
1797   case CheckBoxInputKey.Checked:
1798    nextInputKey = CheckBoxInputKey.Unchecked; break;
1799   case CheckBoxInputKey.Unchecked:
1800    nextInputKey = allowGrayed ? CheckBoxInputKey.Indeterminate : CheckBoxInputKey.Checked; break;
1801   case CheckBoxInputKey.Indeterminate:
1802    nextInputKey = CheckBoxInputKey.Checked; break;
1803  }
1804  return this.GetValueByInputKey(nextInputKey);
1805 },
1806 GetCheckStateByInputKey: function(inputKey) {
1807  switch(inputKey) {
1808   case CheckBoxInputKey.Checked: 
1809    return CheckBoxCheckState.Checked;
1810   case CheckBoxInputKey.Unchecked: 
1811    return CheckBoxCheckState.Unchecked;
1812   case CheckBoxInputKey.Indeterminate: 
1813    return CheckBoxCheckState.Indeterminate;
1814  }
1815 },
1816 GetValueByCheckState: function(checkState) {
1817  switch(checkState) {
1818   case CheckBoxCheckState.Checked: 
1819    return this.GetValueByInputKey(CheckBoxInputKey.Checked);
1820   case CheckBoxCheckState.Unchecked: 
1821    return this.GetValueByInputKey(CheckBoxInputKey.Unchecked);
1822   case CheckBoxCheckState.Indeterminate: 
1823    return this.GetValueByInputKey(CheckBoxInputKey.Indeterminate);
1824  }
1825 },
1826 GetFirstValueBySecondValue: function(firstValueName, secondValueName, secondValue) {
1827  return this.GetValueByFunc(firstValueName, 
1828   function(checkBoxState) { return checkBoxState[secondValueName] === secondValue; });
1829 },
1830 GetValueByFunc: function(valueName, func) {
1831  for(var i = 0; i < this.checkBoxStates.length; i++) {
1832   if(func(this.checkBoxStates[i]))
1833    return this.checkBoxStates[i][valueName];
1834  }  
1835 },
1836 AssignElementClassName: function(element, cssClassPropertyKey, disabledCssClassPropertyKey, assignedClassName) {
1837  var classNames = [ ];
1838  for(var i = 0; i < this.imageProperties[cssClassPropertyKey].length; i++) {
1839   classNames.push(this.imageProperties[disabledCssClassPropertyKey][i]);
1840   classNames.push(this.imageProperties[cssClassPropertyKey][i]);
1841  }
1842  var elementClassName = element.className;
1843  for(var i = 0; i < classNames.length; i++) {
1844   var className = classNames[i];
1845   var index = elementClassName.indexOf(className);
1846   if(index > -1)
1847    elementClassName = elementClassName.replace((index == 0 ? '' : ' ') + className, "");
1848  }
1849  elementClassName += " " + assignedClassName;
1850  element.className = elementClassName;
1851 },
1852 UpdateInternalCheckBoxDecoration: function(mainElement, inputKey, enabled) {
1853  var imagePropertiesNumber = this.GetImagePropertiesNumByInputKey(inputKey);
1854  for(var imagePropertyKey in this.imageProperties) {
1855   if(this.imageProperties.hasOwnProperty(imagePropertyKey)) {
1856    var propertyValue = this.imageProperties[imagePropertyKey][imagePropertiesNumber];
1857    propertyValue = propertyValue || !isNaN(propertyValue) ? propertyValue : "";
1858    switch(imagePropertyKey) {

1859     case "0" : mainElement.title = propertyValue; break;
1860     case "1" : mainElement.style.width = propertyValue + (propertyValue != "" ? "px" : ""); break;
1861     case "2" : mainElement.style.height = propertyValue + (propertyValue != "" ? "px" : ""); break;
1862    }
1863    if(enabled) {
1864     switch(imagePropertyKey) {
1865      case "3" : this.SetImageSrc(mainElement, propertyValue); break;
1866      case "4" : 
1867       this.AssignElementClassName(mainElement, "4", "8", propertyValue);
1868       break;
1869      case "5" : this.SetBackgroundPosition(mainElement, propertyValue, true); break;
1870      case "6" : this.SetBackgroundPosition(mainElement, propertyValue, false); break;
1871     }
1872    } else {
1873     switch(imagePropertyKey) {
1874      case "7" : this.SetImageSrc(mainElement, propertyValue); break;
1875      case "8" : 
1876       this.AssignElementClassName(mainElement, "4", "8", propertyValue);
1877       break;
1878      case "9" : this.SetBackgroundPosition(mainElement, propertyValue, true); break;
1879      case "10" : this.SetBackgroundPosition(mainElement, propertyValue, false); break;
1880     }
1881    }
1882   }
1883  }
1884 },
1885 SetImageSrc: function(mainElement, src) {
1886  if(src === ""){
1887   mainElement.style.backgroundImage = "";
1888   mainElement.style.backgroundPosition = "";
1889   ASPx.RemoveClassNameFromElement(mainElement, this.customImageMarkerClassName);
1890  }
1891  else{
1892   mainElement.style.backgroundImage = "url('" + src + "')";
1893   this.SetBackgroundPosition(mainElement, 0, true);
1894   this.SetBackgroundPosition(mainElement, 0, false);
1895   ASPx.AddClassNameToElement(mainElement, this.customImageMarkerClassName);
1896  }
1897 },
1898 SetBackgroundPosition: function(element, value, isX) {
1899  if(value === "") {
1900   element.style.backgroundPosition = value;
1901   return;
1902  }
1903  if(element.style.backgroundPosition === "")
1904   element.style.backgroundPosition = isX ? "-" + value.toString() + "px 0px" : "0px -" + value.toString() + "px";
1905  else {
1906   var position = element.style.backgroundPosition.split(' ');
1907   element.style.backgroundPosition = isX ? '-' + value.toString() + "px " + position[1] :  position[0] + " -" + value.toString() + "px";
1908  }
1909 },
1910 AddState: function(value, stateInputKey, imagePropertiesNumber) {
1911  this.checkBoxStates.push({
1912   "Value" : value, 
1913   "StateInputKey" : stateInputKey, 
1914   "ImagePropertiesNumber" : imagePropertiesNumber
1915  });
1916 },
1917 GetAriaCheckedValue: function(state) {
1918  switch(state) {
1919   case ASPx.CheckBoxCheckState.Checked: return "true";
1920   case ASPx.CheckBoxCheckState.Unchecked: return "false";
1921   case ASPx.CheckBoxCheckState.Indeterminate: return "mixed";
1922   default: return "";
1923  }
1924 },
1925 GetAriaSelectedValue: function(state) {
1926  switch(state) {
1927   case ASPx.CheckBoxCheckState.Checked: return "true";
1928   case ASPx.CheckBoxCheckState.Unchecked: return "false";
1929   case ASPx.CheckBoxCheckState.Indeterminate: return "undefined";
1930   default: return "";
1931  }
1932 },
1933 SetAriaCheckedSelectedAttributes: function(mainElement, state) {
1934  if(mainElement.attributes["aria-checked"] !== undefined) {
1935   var ariaCheckedValue = this.GetAriaCheckedValue(state);
1936   mainElement.setAttribute("aria-checked", ariaCheckedValue);
1937  }
1938  if(mainElement.attributes["aria-selected"] !== undefined) {
1939   var ariaSelectedValue = this.GetAriaSelectedValue(state);
1940   mainElement.setAttribute("aria-selected", ariaSelectedValue);
1941  }
1942 }
1943});
1944CheckableElementStateController.Create = function(imageProperties, valueChecked, valueUnchecked, valueGrayed, allowGrayed) {
1945 var stateController = new CheckableElementStateController(imageProperties);
1946 stateController.AddState(valueChecked, CheckBoxInputKey.Checked, 0);
1947 stateController.AddState(valueUnchecked, CheckBoxInputKey.Unchecked, 1);
1948 if(typeof(valueGrayed) != "undefined")
1949  stateController.AddState(valueGrayed, CheckBoxInputKey.Indeterminate, allowGrayed ? 2 : 1);
1950 stateController.allowGrayed = allowGrayed;
1951 return stateController;
1952};
1953var CheckableElementHelper = ASPx.CreateClass(null, {
1954 InternalCheckBoxInitialize: function(internalCheckBox) {
1955  this.AttachToMainElement(internalCheckBox);
1956  this.AttachToInputElement(internalCheckBox);
1957 },
1958 AttachToMainElement: function(internalCheckBox) {
1959  var instance = this;
1960  if(internalCheckBox.mainElement) {
1961    var toggleEvent = internalCheckBox.displaySwitch ? ASPx.TouchUIHelper.touchMouseDownEventName : "click";
1962    ASPx.Evt.AttachEventToElement(internalCheckBox.mainElement, toggleEvent,
1963    function (evt) {
1964     if(ASPx.Evt.IsRightButtonPressed(evt))
1965      return;
1966     instance.InvokeClick(internalCheckBox, evt);
1967     if(!internalCheckBox.disableCancelBubble)
1968      return ASPx.Evt.PreventEventAndBubble(evt);
1969    }
1970   );
1971   ASPx.Evt.AttachEventToElement(internalCheckBox.mainElement, "mousedown",
1972    function (evt) {
1973     internalCheckBox.Refocus();
1974    }
1975   );
1976   ASPx.Evt.PreventElementDragAndSelect(internalCheckBox.mainElement, true);
1977  }
1978 },
1979 AttachToInputElement: function(internalCheckBox) {
1980  var instance = this;
1981  if(internalCheckBox.inputElement && internalCheckBox.mainElement) {
1982   var checkableElement = internalCheckBox.accessibilityCompliant ? internalCheckBox.mainElement : internalCheckBox.inputElement;
1983   ASPx.Evt.AttachEventToElement(checkableElement, "focus",
1984    function (evt) { 
1985     if(!internalCheckBox.enabled)
1986      checkableElement.blur();
1987     else
1988      internalCheckBox.OnFocus();
1989    }
1990   );
1991   ASPx.Evt.AttachEventToElement(checkableElement, "blur", 
1992    function (evt) { 
1993     internalCheckBox.OnLostFocus();
1994    }
1995   );
1996   ASPx.Evt.AttachEventToElement(checkableElement, "keyup",
1997    function (evt) { 
1998     if(ASPx.Evt.GetKeyCode(evt) == ASPx.Key.Space)
1999      instance.InvokeClick(internalCheckBox, evt);
2000    }
2001   );
2002   ASPx.Evt.AttachEventToElement(checkableElement, "keydown",
2003    function (evt) { 
2004     if(ASPx.Evt.GetKeyCode(evt) == ASPx.Key.Space)
2005      return ASPx.Evt.PreventEvent(evt);
2006    }
2007   );
2008  }
2009 },
2010 IsKBSInputWrapperExist: function() {
2011  return ASPx.Browser.Opera || ASPx.Browser.WebKitFamily;
2012 },
2013 GetICBMainElementByInput: function(icbInputElement) {
2014  return this.IsKBSInputWrapperExist() ? icbInputElement.parentNode.parentNode : icbInputElement.parentNode;
2015 },
2016 RequirePreventFocus: function() { return false; },
2017 InvokeClick: function(internalCheckBox, evt) {
2018  if(internalCheckBox.enabled && !internalCheckBox.GetReadOnly()) {
2019   var inputElementValue = internalCheckBox.inputElement.value;
2020   var focusableElement = internalCheckBox.accessibilityCompliant ? internalCheckBox.mainElement : internalCheckBox.inputElement; 
2021   if(!this.RequirePreventFocus())
2022    focusableElement.focus();
2023   internalCheckBox.inputElement.value = inputElementValue; 
2024   this.InvokeClickCore(internalCheckBox, evt);
2025   }
2026 },
2027 InvokeClickCore: function(internalCheckBox, evt) {
2028  internalCheckBox.OnClick(evt);
2029 }
2030});
2031CheckableElementHelper.Instance = new CheckableElementHelper();
2032var CheckBoxInternal = ASPx.CreateClass(null, {
2033 constructor: function(inputElement, stateController, allowGrayed, allowGrayedByClick, helper, container, storeValueInInput, key, disableCancelBubble,
2034  accessibilityCompliant, displaySwitch) {
2035  this.inputElement = inputElement;
2036  this.mainElement = helper.GetICBMainElementByInput(this.inputElement);
2037  this.name = (key ? key : this.inputElement.id) + CheckBoxInternal.GetICBMainElementPostfix();
2038  this.mainElement.id = this.name;
2039  this.stateController = stateController;
2040  this.container = container;
2041  this.allowGrayed = allowGrayed;
2042  this.allowGrayedByClick = allowGrayedByClick;
2043  this.autoSwitchEnabled = true;
2044  this.displaySwitch = displaySwitch;
2045  this.storeValueInInput = !!storeValueInInput;
2046  this.storedInputKey = !this.storeValueInInput ? this.inputElement.value : null;
2047  this.disableCancelBubble = !!disableCancelBubble;
2048  this.accessibilityCompliant = accessibilityCompliant;
2049  this.focusDecoration = null;
2050  this.focused = false;
2051  this.focusLocked = false;
2052  this.enabled = !this.mainElement.className.match(/dxWeb_\w+Disabled(\b|_)/);
2053  this.readOnly = false;
2054  this.preventFocus = helper.RequirePreventFocus();
2055  this.CheckedChanged = new ASPxClientEvent();
2056  this.Focus = new ASPxClientEvent();
2057  this.LostFocus = new ASPxClientEvent();
2058  helper.InternalCheckBoxInitialize(this);
2059 },
2060 GetReadOnly: function() {
2061  return this.readOnly;
2062 },
2063 ChangeInputElementTabIndex: function() {  
2064  var changeMethod = this.enabled ? ASPx.Attr.RestoreTabIndexAttribute : ASPx.Attr.SaveTabIndexAttributeAndReset;
2065  changeMethod(this.inputElement);
2066 },
2067 CreateFocusDecoration: function(focusedStyle) {
2068   this.focusDecoration = new FocusedStyleDecoration(this);
2069   this.focusDecoration.AddStyle('F', focusedStyle[0], focusedStyle[1]);
2070   this.focusDecoration.AddPostfix("");
2071 },
2072 UpdateFocusDecoration: function() {
2073  this.focusDecoration.Update();
2074 },  
2075 StoreInputKey: function(inputKey) {
2076  if(this.storeValueInInput)
2077   this.inputElement.value = inputKey;
2078  else
2079   this.storedInputKey = inputKey;
2080 },
2081 GetStoredInputKey: function() {
2082  if(this.storeValueInInput)
2083   return this.inputElement.value;
2084  else
2085   return this.storedInputKey;
2086 },
2087 OnClick: function(e) {
2088  if(this.autoSwitchEnabled) {
2089   var currentValue = this.GetValue();
2090   var value = this.stateController.GetNextCheckBoxValue(currentValue, this.allowGrayedByClick && this.allowGrayed);
2091   this.SetValue(value);
2092  }
2093  this.CheckedChanged.FireEvent(this, e);
2094 },
2095 OnFocus: function() {
2096  if(!this.IsFocusLocked()) {
2097   this.focused = true;
2098   this.UpdateFocusDecoration();
2099   this.Focus.FireEvent(this, null);
2100  } else
2101   this.UnlockFocus();
2102 },
2103 OnLostFocus: function() {
2104  if(!this.IsFocusLocked()) {
2105   this.focused = false;
2106   this.UpdateFocusDecoration();
2107   this.LostFocus.FireEvent(this, null);
2108  }
2109 },
2110 Refocus: function() {
2111  if(this.preventFocus) return;
2112  if(this.focused) {

2113   this.LockFocus();
2114   this.inputElement.blur();
2115   if(ASPx.Browser.MacOSMobilePlatform) {
2116    window.setTimeout(function() {
2117     ASPx.SetFocus(this.inputElement);
2118    }, ASPx.FOCUS_TIMEOUT);
2119   } else {
2120    ASPx.SetFocus(this.inputElement);
2121   }
2122  }
2123 },
2124 LockFocus: function() {
2125  this.focusLocked = true;
2126 },
2127 UnlockFocus: function() {
2128  this.focusLocked = false;
2129 },
2130 IsFocusLocked: function() {
2131  if(!!ASPx.Attr.GetAttribute(this.mainElement, ASPx.Attr.GetTabIndexAttributeName()))
2132   return false;
2133  return this.focusLocked;
2134 },
2135 SetValue: function(value, force) {
2136  var currentValue = this.GetValue();
2137  if(currentValue !== value || force) {
2138   var newInputKey = this.stateController.GetInputKeyByValue(value);
2139   if(newInputKey) {
2140    this.StoreInputKey(newInputKey);   
2141    this.stateController.UpdateInternalCheckBoxDecoration(this.mainElement, newInputKey, this.enabled);
2142   }
2143  }
2144  if(this.accessibilityCompliant) {
2145   var state = this.GetCurrentCheckState();
2146   this.stateController.SetAriaCheckedSelectedAttributes(this.mainElement, state);
2147  }
2148 },
2149 GetValue: function() {
2150  return this.stateController.GetValueByInputKey(this.GetCurrentInputKey());
2151 },
2152 GetCurrentCheckState: function() {
2153  return this.stateController.GetCheckStateByInputKey(this.GetCurrentInputKey());
2154 },
2155 GetCurrentInputKey: function() {
2156  return this.GetStoredInputKey();
2157 },
2158 GetChecked: function() {
2159  return this.GetCurrentInputKey() === CheckBoxInputKey.Checked;
2160 },
2161 SetChecked: function(checked) {
2162  var newValue = this.stateController.GetValueByCheckState(checked ? CheckBoxCheckState.Checked : CheckBoxCheckState.Unchecked);
2163  this.SetValue(newValue);
2164 },
2165 SetEnabled: function(enabled) {
2166  if(this.enabled != enabled) {
2167   this.enabled = enabled;
2168   this.stateController.UpdateInternalCheckBoxDecoration(this.mainElement, this.GetCurrentInputKey(), this.enabled);
2169   this.ChangeInputElementTabIndex();
2170  }
2171 },
2172 GetEnabled: function() {
2173  return this.enabled;
2174 }
2175});
2176CheckBoxInternal.GetICBMainElementPostfix = function() {
2177 return "_D";
2178};
2179var CheckBoxInternalCollection = ASPx.CreateClass(CollectionBase, {
2180 constructor: function(imageProperties, allowGrayed, storeValueInInput, helper, disableCancelBubble, accessibilityCompliant) {
2181  this.constructor.prototype.constructor.call(this);
2182  this.stateController = allowGrayed 
2183   ? CheckableElementStateController.Create(imageProperties, CheckBoxInputKey.Checked, CheckBoxInputKey.Unchecked, CheckBoxInputKey.Indeterminate, true)
2184   : CheckableElementStateController.Create(imageProperties, CheckBoxInputKey.Checked, CheckBoxInputKey.Unchecked);
2185  this.helper = helper || CheckableElementHelper.Instance;
2186  this.storeValueInInput = !!storeValueInInput;
2187  this.disableCancelBubble = !!disableCancelBubble;
2188  this.accessibilityCompliant = accessibilityCompliant;
2189 },
2190 Add: function(key, inputElement, container) {
2191  this.Remove(key);
2192  var checkBox = this.CreateInternalCheckBox(key, inputElement, container);
2193  CollectionBase.prototype.Add.call(this, key, checkBox);
2194  return checkBox;
2195 },
2196 SetImageProperties: function(imageProperties) {
2197  this.stateController.imageProperties = imageProperties;
2198 },
2199 CreateInternalCheckBox: function(key, inputElement, container) {
2200  return new CheckBoxInternal(inputElement, this.stateController, this.stateController.allowGrayed, false, this.helper, container, 
2201   this.storeValueInInput, key, this.disableCancelBubble, this.accessibilityCompliant);
2202 }
2203});
2204var FocusedStyleDecoration = ASPx.CreateClass(null, {
2205 constructor: function(editor) {
2206  this.editor = editor;
2207  this.postfixList = [];
2208  this.styles = {};
2209  this.innerStyles = {};
2210 },
2211 AddPostfix: function(value) {
2212  this.postfixList.push(value);
2213 },
2214 AddStyle: function(key, className, cssText) {
2215  this.styles[key] = this.CreateRule(className, cssText);
2216  this.innerStyles[key] = this.CreateRule("", this.FilterInnerCss(cssText));
2217 },
2218 CreateRule: function(className, cssText) {
2219  return ASPx.Str.Trim(className + " " + ASPx.CreateImportantStyleRule(this.GetStyleSheet(), cssText));
2220 },
2221 GetStyleSheet: function() {
2222  return ASPx.GetCurrentStyleSheet();
2223 },
2224 FilterInnerCss: function(css) {
2225  return css.replace(/(border|background-image)[^:]*:[^;]+/gi, "");
2226 },
2227 Update: function() {
2228  for(var i = 0; i < this.postfixList.length; i++) {
2229   var postfix = this.postfixList[i];
2230   var inner = postfix.length > 0;

2231   var element = this.GetElementByPostfix(postfix);
2232   if(element)
2233    this.ApplyStyles(element, inner);
2234  }
2235 },
2236 GetElementByPostfix: function(postfix) {
2237  return ASPx.GetElementById(this.editor.name + postfix);
2238 },
2239 ApplyStyles: function(element, inner) {
2240  this.ApplyFocusedStyle(element, inner);
2241 },
2242 ApplyFocusedStyle: function(element, inner) {
2243  if(this.HasDecoration("F"))
2244   this.ApplyDecoration("F", element, inner, this.editor.focused);
2245 },
2246 HasDecoration: function(key) {
2247  return !!this.styles[key];
2248 },
2249 ApplyDecoration: function(key, element, inner, active) {
2250  var value = inner ? this.innerStyles[key] : this.styles[key];
2251  this.RemoveDecoration(element, value);
2252  if(active)
2253   ASPx.AddClassNameToElement(element, value);
2254 },
2255 RemoveDecoration: function(element, value) {
2256  ASPx.RemoveClassNameFromElement(element, value);
2257 },
2258 ApplyDecorationCore: function() {
2259 },
2260 EnsureElementBorder: function(element) {
2261  var border = parseInt(element.border) || 0;
2262  element.border = 1;
2263  element.border = border;
2264 }
2265});
2266var EditorStyleDecoration = ASPx.CreateClass(FocusedStyleDecoration, {
2267 constructor: function(editor) {
2268  this.constructor.prototype.constructor.call(this, editor);
2269  this.lockUpdate = false;
2270 },
2271 LockUpdate: function() {
2272  this.lockUpdate = true;
2273 },
2274 UnlockUpdate: function() {
2275  this.lockUpdate = false;
2276 },
2277 IsUpdateLocked: function() {
2278  return this.lockUpdate;
2279 },
2280 Update: function () {
2281  if(this.IsUpdateLocked())
2282   return;
2283  ASPx.FocusedStyleDecoration.prototype.Update.call(this);
2284 },
2285 ApplyStyles: function (element, inner) {
2286  this.ApplyInvalidStyle(element, inner);
2287  ASPx.FocusedStyleDecoration.prototype.ApplyStyles.call(this, element, inner);
2288 },
2289 ApplyInvalidStyle: function (element, inner) {
2290  if(this.HasDecoration("I")) {
2291   var isValid = this.editor.GetIsValid();
2292   this.ApplyDecoration("I", element, inner, !isValid);
2293  }
2294 }
2295});
2296var TextEditorStyleDecoration = ASPx.CreateClass(EditorStyleDecoration, {
2297 constructor: function(editor) {
2298  this.constructor.prototype.constructor.call(this, editor);
2299  this.nullTextClassName = "";
2300 },
2301 ApplyStyles: function(element, inner) {
2302  ASPx.EditorStyleDecoration.prototype.ApplyStyles.call(this, element, inner);
2303  this.ApplyNullTextStyle(element, inner);
2304 },
2305 ApplyNullTextStyle: function(element, inner) {
2306  if(!this.HasDecoration("N"))
2307   return;
2308  var apply = !this.editor.focused && this.editor.CanApplyNullTextDecoration();
2309  this.EnsureSpellcheckAttribute(element, apply);
2310  this.ApplyDecoration("N", element, inner, apply);
2311 },
2312 EnsureSpellcheckAttribute: function(element, apply) {
2313  if(apply)
2314   ASPx.Attr.ChangeAttribute(element, "spellcheck", "false");
2315  else
2316   ASPx.Attr.RestoreAttribute(element, "spellcheck");
2317 },
2318 ApplyNullTextClassName: function(active) {
2319  var nullTextClassName = this.GetNullTextClassName();
2320  var editorMainElement = this.editor.GetMainElement();
2321  if(active)
2322   ASPx.AddClassNameToElement(editorMainElement, nullTextClassName);
2323  else
2324   ASPx.RemoveClassNameFromElement(editorMainElement, nullTextClassName);
2325 },
2326 GetNullTextClassName: function() {
2327  if (!this.nullTextClassName)
2328   this.InitializeNullTextClassName();
2329  return this.nullTextClassName;
2330 },
2331 InitializeNullTextClassName: function() {
2332  var nullTextStyle = this.styles["N"];
2333  if (nullTextStyle) {
2334   var nullTextStyleClassNames = nullTextStyle.split(" ");
2335   for (var i = 0; i < nullTextStyleClassNames.length; i++)
2336    if (nullTextStyleClassNames[i].match("dxeNullText"))
2337     this.nullTextClassName = nullTextStyleClassNames[i];
2338  }
2339 }
2340});
2341var touchUIHelperUsePointerEvents = (ASPx.Browser.Edge || ASPx.Browser.EdgeWebKit) && ASPx.Browser.MSTouchUI && !!window.PointerEvent;
2342var TouchUIHelper = {
2343 isGesture: false,
2344 isMouseEventFromScrolling: false,
2345 isNativeScrollingAllowed: true,
2346 clickSensetivity: 10,
2347 documentTouchHandlers: {},
2348 documentEventAttachingAllowed: true,
2349 msTouchDraggableClassName: "dxMSTouchDraggable",
2350 touchMouseDownEventName: ASPx.Browser.WebKitTouchUI ? "touchstart" : (touchUIHelperUsePointerEvents ? "pointerdown" : "mousedown"),
2351 touchMouseUpEventName: ASPx.Browser.WebKitTouchUI ? "touchend" : (touchUIHelperUsePointerEvents ? "pointerup" : "mouseup"),
2352 touchMouseMoveEventName: ASPx.Browser.WebKitTouchUI ? "touchmove" : (touchUIHelperUsePointerEvents ? "pointermove" : "mousemove"),
2353 startPreventingTouchMove: function() {
2354  if(touchUIHelperUsePointerEvents)
2355   ASPx.Evt.AttachEventToDocument("touchmove", ASPx.Evt.PreventEvent);
2356 },
2357 stopPreventingTouchMove: function() {
2358  if(touchUIHelperUsePointerEvents)
2359   ASPx.Evt.DetachEventFromDocument("touchmove", ASPx.Evt.PreventEvent);
2360 },
2361 isTouchEvent: function(evt) {
2362  if(!evt) return false;
2363  return ASPx.Browser.WebKitTouchUI && ASPx.IsExists(evt.changedTouches); 
2364 },
2365 isTouchEventName: function(eventName) {
2366  return ASPx.Browser.WebKitTouchUI && (eventName.indexOf("touch") > -1 || eventName.indexOf("gesture") > -1);
2367 },
2368 getEventX: function(evt) {
2369  var touchPoint = null;
2370  if(evt.changedTouches.length > 0)
2371   touchPoint = evt.changedTouches;
2372  else if(evt.targetTouches.length > 0)
2373   touchPoint = evt.targetTouches;
2374  return touchPoint ? touchPoint[0].pageX : 0;
2375 },
2376 getEventY: function(evt) { 
2377  var touchPoint = null;
2378  if(evt.changedTouches.length > 0)
2379   touchPoint = evt.changedTouches;
2380  else if(evt.targetTouches.length > 0)
2381   touchPoint = evt.targetTouches;
2382  return touchPoint ? touchPoint[0].pageY : 0;
2383 },
2384 getWebkitMajorVersion: function(){
2385  if(!this.webkitMajorVersion){
2386   var regExp = new RegExp("applewebkit/(\\d+)", "i");
2387   var matches = regExp.exec(ASPx.Browser.UserAgent);
2388   if(matches && matches.index >= 1)
2389    this.webkitMajorVersion = matches[1];
2390  }
2391  return this.webkitMajorVersion;
2392 },
2393 getIsLandscapeOrientation: function(){
2394  if(ASPx.Browser.MacOSMobilePlatform || ASPx.Browser.AndroidMobilePlatform)
2395   return Math.abs(window.orientation) == 90;
2396  return ASPx.GetDocumentClientWidth() > ASPx.GetDocumentClientHeight();
2397 },
2398 nativeScrollingSupported: function() {
2399  var allowedSafariVersion = ASPx.Browser.Version >= 5.1 && ASPx.Browser.Version < 8; 
2400  var webkitMajorVersion = this.getWebkitMajorVersion();
2401  var allowedWebKitVersion = webkitMajorVersion > 533 && webkitMajorVersion < 600;
2402  return (ASPx.Browser.MacOSMobilePlatform && (allowedSafariVersion || allowedWebKitVersion))
2403   || (ASPx.Browser.AndroidMobilePlatform && ASPx.Browser.PlaformMajorVersion >= 3) || (ASPx.Browser.MSTouchUI);
2404 },
2405 makeScrollableIfRequired: function(element, options) {
2406  if(ASPx.Browser.WebKitTouchUI && element) {
2407   var overflow = ASPx.GetCurrentStyle(element).overflow;
2408   if(element.tagName == "DIV" &&  overflow != "hidden" && overflow != "visible" ){
2409    return this.MakeScrollable(element);
2410   }
2411  }
2412 },
2413 preventScrollOnEvent: function(evt){
2414 },
2415 handleFastTapIfRequired: function(evt, action, preventCommonClickEvents) {
2416  if(ASPx.Browser.WebKitTouchUI && evt.type == 'touchstart' && action) {
2417   this.FastTapHelper.HandleFastTap(evt, action, preventCommonClickEvents);
2418   return true;
2419  }
2420  return false;
2421 },
2422 ensureDocumentSizesCorrect: function (){
2423  return (document.documentElement.clientWidth - document.documentElement.clientHeight) / (screen.width - screen.height) > 0;

2424 },
2425 ensureOrientationChanged: function(onOrientationChangedFunction){
2426  if(ASPxClientUtils.iOSPlatform || this.ensureDocumentSizesCorrect())
2427   onOrientationChangedFunction();
2428  else {
2429   window.setTimeout(function(){
2430    this.ensureOrientationChanged(onOrientationChangedFunction);
2431   }.aspxBind(this), 100);
2432  }
2433 },
2434 onEventAttachingToDocument: function(eventName, func){
2435  if(ASPx.Browser.MacOSMobilePlatform && this.isTouchEventName(eventName)) {
2436   if(!this.documentTouchHandlers[eventName])
2437    this.documentTouchHandlers[eventName] = [];
2438   this.documentTouchHandlers[eventName].push(func);
2439   return this.documentEventAttachingAllowed;
2440  }
2441  return true;
2442 },
2443 onEventDettachedFromDocument: function(eventName, func){
2444  if(ASPx.Browser.MacOSMobilePlatform && this.isTouchEventName(eventName)) {
2445   var handlers = this.documentTouchHandlers[eventName];
2446   if(handlers)
2447    ASPx.Data.ArrayRemove(handlers, func);
2448  }
2449 },
2450 processDocumentTouchEventHandlers: function(proc) {
2451  var touchEventNames = ["touchstart", "touchend", "touchmove", "gesturestart", "gestureend"];
2452  for(var i = 0; i < touchEventNames.length; i++) {
2453   var eventName = touchEventNames[i];
2454   var handlers = this.documentTouchHandlers[eventName];
2455   if(handlers) {
2456    for(var j = 0; j < handlers.length; j++) {
2457     proc(eventName,handlers[j]);
2458    }
2459   }
2460  }
2461 },
2462 removeDocumentTouchEventHandlers: function() {
2463  if(ASPx.Browser.MacOSMobilePlatform) {
2464   this.documentEventAttachingAllowed = false;
2465   this.processDocumentTouchEventHandlers(ASPx.Evt.DetachEventFromDocumentCore);
2466  }
2467 },
2468 restoreDocumentTouchEventHandlers: function () {
2469  if(ASPx.Browser.MacOSMobilePlatform) {
2470   this.documentEventAttachingAllowed = true;
2471   this.processDocumentTouchEventHandlers(ASPx.Evt.AttachEventToDocumentCore);
2472  }
2473 },
2474 IsNativeScrolling: function() {
2475  return TouchUIHelper.nativeScrollingSupported() && TouchUIHelper.isNativeScrollingAllowed;
2476 },
2477 pointerEnabled: !!(window.PointerEvent || window.MSPointerEvent),
2478 pointerDownEventName: window.PointerEvent ? "pointerdown" : "MSPointerDown",
2479 pointerUpEventName: window.PointerEvent ? "pointerup" : "MSPointerUp",
2480 pointerCancelEventName: window.PointerEvent ? "pointercancel" : "MSPointerCancel",
2481 pointerMoveEventName: window.PointerEvent ? "pointermove" : "MSPointerMove",
2482 pointerOverEventName: window.PointerEvent ? "pointerover" : "MSPointerOver",
2483 pointerOutEventName: window.PointerEvent ? "pointerout" : "MSPointerOut",
2484 pointerType: {
2485  Touch: "touch",
2486  Pen: "pen",
2487  Mouse: "mouse"
2488 },
2489 msGestureEnabled: !!(window.PointerEvent || window.MSPointerEvent) && typeof(MSGesture) != "undefined",
2490 msTouchCreateGesturesWrapper: function(element, onTap){
2491  if(!TouchUIHelper.msGestureEnabled) 
2492   return;
2493  var gesture = new MSGesture();
2494  gesture.target = element;
2495  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.pointerDownEventName, function(evt){
2496   gesture.addPointer(evt.pointerId);
2497  });
2498  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.pointerUpEventName, function(evt){
2499   gesture.stop();
2500  });
2501  if(onTap)
2502   ASPx.Evt.AttachEventToElement(element, "MSGestureTap", onTap);
2503  return gesture;
2504 },
2505 useLongTapHelper: function () {
2506  return ASPx.Browser.Safari && ASPx.Browser.TouchUI;
2507 },
2508 attachLongTapHandler: function(element, handler, onlyBubbling) {
2509  var timerID = -1;
2510  var timeout = 1000;
2511  var event = null;
2512  var preventClickEvent = false;
2513  var startX = -1;
2514  var startY = -1;
2515  var pixelLimit = 5;
2516  function onTouchMouseDown(evt) {
2517   abortWating();
2518   event = evt;
2519   startX = evt.pageX;
2520   startY = evt.pageY;
2521   preventClickEvent = false;
2522   timerID = window.setTimeout(onTimeout, timeout);
2523  }
2524  function onTouchMouseMove(evt) {
2525   if (!isUnderTouch())
2526    return;
2527   var shiftX = Math.abs(startX - evt.pageX),
2528    shiftY = Math.abs(startY - evt.pageY),
2529    maxShift = Math.max(shiftX, shiftY);
2530   if (maxShift > pixelLimit)
2531    abortWating();
2532  }
2533  function onTouchMouseUp(evt) {
2534   abortWating();
2535   if (preventClickEvent) {
2536    ASPx.Evt.PreventEventAndBubble(evt);
2537    preventClickEvent = false;
2538   }
2539  }
2540  function onTimeout() {
2541   handler(event);
2542   preventClickEvent = true;
2543   abortWatingInternal();
2544  }
2545  function isUnderTouch() {
2546   return timerID !== -1;
2547  }
2548  function abortWating() {
2549   if (isUnderTouch()) {
2550    window.clearTimeout(timerID);
2551    abortWatingInternal();
2552   }
2553  }
2554  function abortWatingInternal() {
2555   timerID = -1;
2556   event = null;
2557  }
2558  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.touchMouseDownEventName, onTouchMouseDown, onlyBubbling);
2559  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.touchMouseMoveEventName, onTouchMouseMove, onlyBubbling);
2560  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.touchMouseUpEventName, onTouchMouseUp, onlyBubbling);
2561  element.style["-webkit-user-select"] = "none";
2562  return function () {
2563   ASPx.Evt.DetachEventFromElement(element, TouchUIHelper.touchMouseDownEventName, onTouchMouseDown);

2564   ASPx.Evt.DetachEventFromElement(element, TouchUIHelper.touchMouseMoveEventName, onTouchMouseMove);
2565   ASPx.Evt.DetachEventFromElement(element, TouchUIHelper.touchMouseUpEventName, onTouchMouseUp);
2566   element.style["-webkit-user-select"] = "";
2567  };
2568 }
2569};
2570var CacheHelper = {};
2571CacheHelper.GetCachedValueCore = function(obj, key, func, cacheObj, fillValueMethod) {
2572 if(!cacheObj)
2573  cacheObj = obj;
2574 if(!cacheObj.cache)
2575  cacheObj.cache = {};
2576 if(!key) 
2577  key = "default";
2578 fillValueMethod(obj, key, func, cacheObj);
2579 return cacheObj.cache[key];
2580};
2581CacheHelper.GetCachedValue = function(obj, key, func, cacheObj) {
2582 return CacheHelper.GetCachedValueCore(obj, key, func, cacheObj, 
2583  function(obj, key, func, cacheObj) {
2584   if(!ASPx.IsExists(cacheObj.cache[key]))
2585    cacheObj.cache[key] = func.apply(obj, []);
2586  });
2587};
2588CacheHelper.GetCachedElement = function(obj, key, func, cacheObj) {
2589 return CacheHelper.GetCachedValueCore(obj, key, func, cacheObj, 
2590  function(obj, key, func, cacheObj) {
2591   if(!ASPx.IsValidElement(cacheObj.cache[key]))
2592    cacheObj.cache[key] = func.apply(obj, []);
2593  });
2594};
2595CacheHelper.GetCachedElements = function(obj, key, func, cacheObj) {
2596 return CacheHelper.GetCachedValueCore(obj, key, func, cacheObj, 
2597  function(obj, key, func, cacheObj) {
2598   if(!ASPx.IsValidElements(cacheObj.cache[key])){
2599    var elements = func.apply(obj, []);
2600    if(!Ident.IsArray(elements))
2601     elements = [elements];
2602    cacheObj.cache[key] = elements;
2603   }
2604  });
2605};
2606CacheHelper.GetCachedElementById = function(obj, id, cacheObj) {
2607 return CacheHelper.GetCachedElement(obj, id, function() { return ASPx.GetElementById(id); }, cacheObj);
2608};
2609CacheHelper.GetCachedChildById = function(obj, parent, id, cacheObj) {
2610 return CacheHelper.GetCachedElement(obj, id, function() { return ASPx.GetChildById(parent, id); }, cacheObj);
2611};
2612CacheHelper.DropCachedValue = function(cacheObj, key) {
2613 cacheObj.cache[key] = null;
2614};  
2615CacheHelper.DropCache = function(cacheObj) {
2616 cacheObj.cache = null;
2617};  
2618var DomObserver = ASPx.CreateClass(null, {
2619 constructor: function() {
2620  this.items = { };
2621 },
2622 subscribe: function(elementID, callbackFunc) {
2623  var item = this.items[elementID];
2624  if(item)
2625   this.unsubscribe(elementID);
2626  item = {
2627   elementID: elementID,
2628   callbackFunc: callbackFunc,
2629   pauseCount: 0
2630  };
2631  this.prepareItem(item);
2632  this.items[elementID] = item;
2633 },
2634 prepareItem: function(item) {
2635 },
2636 unsubscribe: function(elementID) {
2637  this.items[elementID] = null;
2638 },
2639 getItemElement: function(item) {
2640  var element = this.getElementById(item.elementID);
2641  if(element)
2642   return element;
2643  this.unsubscribe(item.elementID);
2644  return null;
2645 },
2646 getElementById: function(elementID) {
2647  var element = document.getElementById(elementID);
2648  return element && ASPx.IsValidElement(element) ? element : null;
2649 },
2650 pause: function(element, includeSubtree) {
2651  this.changeItemsState(element, includeSubtree, true);
2652 },
2653 resume: function(element, includeSubtree) {
2654  this.changeItemsState(element, includeSubtree, false);
2655 },
2656 forEachItem: function(processFunc, context) {
2657  context = context || this;
2658  for(var itemName in this.items) {
2659   if(!this.items.hasOwnProperty(itemName))
2660    continue;
2661   var item = this.items[itemName];
2662   if(item) {
2663    var needBreak = processFunc.call(context, item);
2664    if(needBreak)
2665     return;
2666   }
2667  }
2668 },
2669 changeItemsState: function(element, includeSubtree, pause) {
2670  this.forEachItem(function(item) {
2671   if(!element)
2672    this.changeItemState(item, pause);
2673   else {
2674    var itemElement = this.getItemElement(item);
2675    if(itemElement && (element == itemElement || (includeSubtree && ASPx.GetIsParent(element, itemElement)))) {
2676     this.changeItemState(item, pause);
2677     if(!includeSubtree)
2678      return true;
2679    }
2680   }
2681  }.aspxBind(this));
2682 },
2683 changeItemState: function(item, pause) {
2684  if(pause)
2685   this.pauseItem(item);
2686  else
2687   this.resumeItem(item);
2688 },
2689 pauseItem: function(item) {
2690  item.paused = true;
2691  item.pauseCount++;
2692 },
2693 resumeItem: function(item) {
2694  if(item.pauseCount > 0) {
2695   if(item.pauseCount == 1)
2696    item.paused = false;
2697   item.pauseCount--;
2698  }
2699 }
2700});
2701DomObserver.IsMutationObserverAvailable = function() {
2702 return !!window.MutationObserver;
2703};
2704var TimerObserver = ASPx.CreateClass(DomObserver, {
2705 constructor: function() {
2706  this.constructor.prototype.constructor.call(this);
2707  this.timerID = -1;
2708  this.observationTimeout = 300;
2709 },
2710 subscribe: function(elementID, callbackFunc) {
2711  DomObserver.prototype.subscribe.call(this, elementID, callbackFunc);
2712  if(!this.isActivated())
2713   this.startObserving();
2714 },
2715 isActivated: function() {
2716  return this.timerID !== -1;
2717 },
2718 startObserving: function() {
2719  if(this.isActivated())
2720   window.clearTimeout(this.timerID);
2721  this.timerID = window.setTimeout(this.onTimeout, this.observationTimeout);
2722 },
2723 onTimeout: function() {
2724  var observer = _aspxGetDomObserver();
2725  observer.doObserve();
2726  observer.startObserving();
2727 },
2728 doObserve: function() {
2729  if(!ASPx.documentLoaded) return;
2730  this.forEachItem(function(item) {
2731   if(!item.paused)
2732    this.doObserveForItem(item);
2733  }.aspxBind(this));
2734 },
2735 doObserveForItem: function(item) {
2736  var element = this.getItemElement(item);
2737  if(element)
2738   item.callbackFunc.call(this, element);
2739 }
2740});
2741var MutationObserver = ASPx.CreateClass(DomObserver, {
2742 constructor: function() {
2743  this.constructor.prototype.constructor.call(this);
2744  this.callbackTimeout = 10;
2745 },
2746 prepareItem: function(item) {
2747  item.callbackTimerID = -1;
2748  var target = this.getElementById(item.elementID);
2749  if(!target)
2750   return;
2751  var observerCallbackFunc = function() {
2752   if(item.callbackTimerID === -1) {
2753    var timeoutHander = function() {
2754     item.callbackTimerID = -1;
2755     item.callbackFunc.call(this, target);
2756    }.aspxBind(this);
2757    item.callbackTimerID = window.setTimeout(timeoutHander, this.callbackTimeout);
2758   }
2759  }.aspxBind(this);
2760  var observer = new window.MutationObserver(observerCallbackFunc);
2761  var config = { attributes: true, childList: true, characterData: true, subtree: true };
2762  observer.observe(target, config);
2763  item.observer = observer;
2764  item.config = config;
2765 },
2766 unsubscribe: function(elementID) {
2767  var item = this.items[elementID];
2768  if(item) {
2769   item.observer.disconnect();
2770   item.observer = null;
2771  }
2772  DomObserver.prototype.unsubscribe.call(this, elementID);
2773 },
2774 pauseItem: function(item) {
2775  DomObserver.prototype.pauseItem.call(this, item);
2776  item.observer.disconnect();
2777 },
2778 resumeItem: function(item) {
2779  DomObserver.prototype.resumeItem.call(this, item);
2780  if(!item.paused) {
2781   var target = this.getItemElement(item);
2782   if(target)
2783    item.observer.observe(target, item.config);
2784  }
2785 }
2786});
2787var domObserver = null;
2788function _aspxGetDomObserver() {
2789 if(domObserver == null)
2790  domObserver = DomObserver.IsMutationObserverAvailable() ? new MutationObserver() : new TimerObserver();
2791 return domObserver;
2792}
2793var ControlUpdateWatcher = ASPx.CreateClass(null, {
2794 constructor: function() {
2795  this.helpers = { };
2796  this.clearLockerTimerID = -1;
2797  this.clearLockerTimerDelay = 15;
2798  this.postProcessing = false;
2799  this.init();
2800 },
2801 init: function() {
2802  var postHandler = aspxGetPostHandler();
2803  postHandler.Post.AddHandler(this.OnPost, this);
2804 },
2805 Add: function(helper) {
2806  this.helpers[helper.GetName()] = helper;
2807 },

2808 CanSendCallback: function(dxCallbackOwner, arg) {
2809  this.LockConfirmOnBeforeWindowUnload();
2810  var modifiedHelpers = this.FilterModifiedHelpersByDXCallbackOwner(this.GetModifiedHelpers(), dxCallbackOwner, arg);
2811  if(modifiedHelpers.length === 0) return true;
2812  var modifiedHelpersInfo = this.GetToConfirmAndToResetLists(modifiedHelpers, dxCallbackOwner.name);
2813  if(!modifiedHelpersInfo) return true;
2814  if(modifiedHelpersInfo.toConfirm.length === 0) {
2815   this.ResetClientChanges(modifiedHelpersInfo.toReset);
2816   return true;
2817  }
2818  var helper = modifiedHelpersInfo.toConfirm[0];
2819  if(!confirm(helper.GetConfirmUpdateText()))
2820   return false;
2821  this.ResetClientChanges(modifiedHelpersInfo.toReset);
2822  return true;
2823 },
2824 OnPost: function(s, e) {
2825  if(this.isDxCallback(e))
2826   return;
2827  this.postProcessing = true;
2828  this.LockConfirmOnBeforeWindowUnload();
2829  var modifiedHelpersInfo = this.GetModifedHelpersInfo(e);
2830  if(!modifiedHelpersInfo)
2831   return;
2832  if(modifiedHelpersInfo.toConfirm.length === 0) {
2833   this.ResetClientChanges(modifiedHelpersInfo.toReset);
2834   return;
2835  }
2836  var helper = modifiedHelpersInfo.toConfirm[0];
2837  if(!confirm(helper.GetConfirmUpdateText())) {
2838   e.cancel = true;
2839   this.finishPostProcessing();
2840  }
2841  if(!e.cancel)
2842   this.ResetClientChanges(modifiedHelpersInfo.toReset);
2843 },
2844 isDxCallback: function(e) {
2845  return e.isDXCallback || this.isInternalUploadControlCallback();
2846 },
2847 isInternalUploadControlCallback: function() {
2848  var isInCallback = false;
2849  for(var key in this.helpers) {
2850   if(this.helpers.hasOwnProperty(key)) {
2851    var helper = this.helpers[key];
2852    isInCallback = isInCallback || helper.isInUploadCallback();
2853   }
2854  }
2855  return isInCallback;
2856 },
2857 finishPostProcessing: function() {
2858  this.postProcessing = false;
2859 },
2860 GetModifedHelpersInfo: function(e) {
2861  var modifiedHelpers = this.FilterModifiedHelpers(this.GetModifiedHelpers(), e);
2862  if(modifiedHelpers.length === 0) return;
2863  return this.GetToConfirmAndToResetLists(modifiedHelpers, e && e.ownerID);
2864 },
2865 GetToConfirmAndToResetLists: function(modifiedHelpers, ownerID) {
2866  var resetList = [ ];
2867  var confirmList = [ ];
2868  for(var i = 0; i < modifiedHelpers.length; i++) {
2869   var helper = modifiedHelpers[i];
2870   if(!helper.GetConfirmUpdateText()) { 
2871    resetList.push(helper);
2872    continue;
2873   }
2874   if(helper.CanShowConfirm(ownerID)) { 
2875    resetList.push(helper);
2876    confirmList.push(helper);
2877   }
2878  }
2879  return { toConfirm: confirmList, toReset: resetList };
2880 },
2881 FilterModifiedHelpers: function(modifiedHelpers, e) {
2882  if(modifiedHelpers.length === 0)
2883   return [ ];
2884  if(this.RequireProcessUpdatePanelCallback(e))
2885   return this.FilterModifiedHelpersByUpdatePanels(modifiedHelpers);
2886  if(this.postProcessing)
2887   return this.FilterModifiedHelpersByPostback(modifiedHelpers);
2888  return modifiedHelpers;
2889 },
2890 FilterModifiedHelpersByDXCallbackOwner: function(modifiedHelpers, dxCallbackOwner, arg) {
2891  var result = [ ];
2892  for(var i = 0; i < modifiedHelpers.length; i++) {
2893   var helper = modifiedHelpers[i];
2894   if(helper.NeedConfirmOnCallback(dxCallbackOwner, arg))
2895    result.push(helper);
2896  }
2897  return result;
2898 },
2899 FilterModifiedHelpersByUpdatePanels: function(modifiedHelpers) {
2900  var result = [ ];
2901  var updatePanels = this.GetUpdatePanelsWaitedForUpdate();
2902  for(var i = 0; i < updatePanels.length; i++) {
2903   var panelID = updatePanels[i].replace(/\$/g, "_");
2904   var panel = ASPx.GetElementById(panelID);
2905   if(!panel) continue;
2906   for(var j = 0; j < modifiedHelpers.length; j++) {
2907    var helper = modifiedHelpers[j];
2908    if(ASPx.GetIsParent(panel, helper.GetControlMainElement()))
2909     result.push(helper);
2910   }
2911  }
2912  return result;
2913 },
2914 FilterModifiedHelpersByPostback: function(modifiedHelpers) {
2915  var result = [ ];
2916  for(var i = 0; i < modifiedHelpers.length; i++) {
2917   var helper = modifiedHelpers[i];
2918   if(helper.NeedConfirmOnPostback())
2919    result.push(helper);
2920  }
2921  return result;
2922 },
2923 RequireProcessUpdatePanelCallback: function(e) {
2924  var rManager = this.GetMSRequestManager();
2925  if(rManager && e && e.isMSAjaxCallback)
2926   return rManager._postBackSettings.async;
2927  return false;
2928 },
2929 GetUpdatePanelsWaitedForUpdate: function() {
2930  var rManager = this.GetMSRequestManager();
2931  if(!rManager) return [ ];

2932  var panelUniqueIDs = rManager._postBackSettings.panelsToUpdate || [ ];
2933  var panelClientIDs = [ ];
2934  for(var i = 0; i < panelUniqueIDs.length; i++) {
2935   var index = ASPx.Data.ArrayIndexOf(rManager._updatePanelIDs, panelUniqueIDs[i]);
2936   if(index >= 0)
2937    panelClientIDs.push(rManager._updatePanelClientIDs[index]);
2938  }
2939  return panelClientIDs;
2940 },
2941 GetMSRequestManager: function() {
2942  return ASPx.GetMSAjaxRequestManager();
2943 },
2944 GetModifiedHelpers: function() {
2945  var result = [ ];
2946  for(var key in this.helpers) { 
2947   if(this.helpers.hasOwnProperty(key)) {
2948    var helper = this.helpers[key];
2949    if(helper.HasChanges())
2950     result.push(helper);
2951   }
2952  }
2953  return result;
2954 },
2955 ResetClientChanges: function(modifiedHelpers) {
2956  for(var i = 0; i < modifiedHelpers.length; i++)
2957   modifiedHelpers[i].ResetClientChanges();
2958 },
2959 GetConfirmUpdateMessage: function() {
2960  if(this.confirmOnWindowUnloadLocked) return;
2961  var modifiedHelpersInfo = this.GetModifedHelpersInfo();
2962  if(!modifiedHelpersInfo || modifiedHelpersInfo.toConfirm.length === 0) 
2963   return;
2964  var helper = modifiedHelpersInfo.toConfirm[0];
2965  return helper.GetConfirmUpdateText();
2966 },
2967 LockConfirmOnBeforeWindowUnload: function() {
2968  this.confirmOnWindowUnloadLocked = true;
2969  this.clearLockerTimerID = ASPx.Timer.ClearTimer(this.clearLockerTimerID);
2970  this.clearLockerTimerID = window.setTimeout(function() {
2971   this.confirmOnWindowUnloadLocked = false;
2972  }.aspxBind(this), this.clearLockerTimerDelay);
2973 },
2974 OnWindowBeforeUnload: function(e) {
2975  var confirmMessage = this.GetConfirmUpdateMessage();
2976  if(confirmMessage)
2977   e.returnValue = confirmMessage;
2978  this.finishPostProcessing();
2979  return confirmMessage;
2980 },
2981 OnWindowUnload: function(e) {
2982  if(this.confirmOnWindowUnloadLocked) return;
2983  var modifiedHelpersInfo = this.GetModifedHelpersInfo();
2984  if(!modifiedHelpersInfo) return;
2985  this.ResetClientChanges(modifiedHelpersInfo.toReset);
2986 },
2987 OnMouseDown: function(e) {
2988 },
2989 OnFocusIn: function(e) {
2990 },
2991 PreventBeforeUnloadOnLinkClick: function(e) {
2992  if(ASPx.GetObjectKeys(this.helpers).length == 0)
2993   return;
2994  var link = ASPx.GetParentByTagName(ASPx.Evt.GetEventSource(e), "A");
2995  if(!link || link.dxgvLinkClickHanlderAssigned)
2996   return;
2997  var url = ASPx.Attr.GetAttribute(link, "href");
2998  if(!url || url.indexOf("javascript:") < 0)
2999   return;
3000  ASPx.Evt.AttachEventToElement(link, "click", function(ev) { return ASPx.Evt.PreventEvent(ev); });
3001  link.dxgvLinkClickHanlderAssigned = true;
3002 }
3003});
3004ControlUpdateWatcher.Instance = null;
3005ControlUpdateWatcher.getInstance = function () {
3006 if (!ControlUpdateWatcher.Instance) {
3007  ControlUpdateWatcher.Instance = new ControlUpdateWatcher();
3008  ASPx.Evt.AttachEventToElement(window, "beforeunload", function(e) {
3009   return ControlUpdateWatcher.Instance.OnWindowBeforeUnload(e);
3010  });
3011  ASPx.Evt.AttachEventToElement(window, "unload", function(e) {
3012   ControlUpdateWatcher.Instance.OnWindowUnload(e);
3013  });
3014  ASPx.Evt.AttachEventToDocument("mousedown", function(e) {
3015   ControlUpdateWatcher.Instance.OnMouseDown(e);
3016  });
3017  ASPx.Evt.AttachEventToDocument("focusin", function(e) {
3018   ControlUpdateWatcher.Instance.OnFocusIn(e);
3019  });
3020 }
3021 return ControlUpdateWatcher.Instance;
3022};
3023var UpdateWatcherHelper = ASPx.CreateClass(null, {
3024 constructor: function(owner) {
3025  this.owner = owner;
3026  this.ownerWatcher = ControlUpdateWatcher.getInstance();
3027  this.ownerWatcher.Add(this);
3028 },
3029 GetName: function() {
3030  return this.owner.name;
3031 },
3032 GetControlMainElement: function() {
3033  return this.owner.GetMainElement();
3034 },
3035 GetControlParentForm: function(){
3036  return ASPx.GetParentByTagName(this.GetControlMainElement(), "FORM");
3037 },
3038 CanShowConfirm: function(requestOwnerID) {
3039  return true;
3040 },
3041 HasChanges: function() {
3042  return false;
3043 },
3044 GetConfirmUpdateText: function() {
3045  return "";
3046 },
3047 NeedConfirmOnCallback: function(dxCallbackOwner) {
3048  return true;
3049 },
3050 NeedConfirmOnPostback: function() {
3051  if(ASPx.IsUploadSubmitRequest)
3052   return !ASPx.IsUploadSubmitRequest(this.GetControlParentForm(

3052));
3053  return true;
3054 },
3055 ResetClientChanges: function() {
3056 },
3057 ConfirmOnCustomControlEvent: function() {
3058  var confirmMessage = this.GetConfirmUpdateText();
3059  if(confirmMessage)
3060   return confirm(confirmMessage);
3061  return false;
3062 },
3063 isInUploadCallback: function() {
3064  return false;
3065 }
3066});
3067var ControlTabIndexManager = ASPx.CreateClass(null, {
3068 constructor: function() {
3069  this.elementsWithChangedTabIndex = {};
3070 },
3071 getChangedElementsForControlId: function(id) {
3072  if(!this.elementsWithChangedTabIndex[id])
3073   this.elementsWithChangedTabIndex[id] = [];
3074  return this.elementsWithChangedTabIndex[id];
3075 },
3076 isElementWithChangedIndex: function(element) {
3077  for(var key in this.elementsWithChangedTabIndex)
3078   if(this.elementsWithChangedTabIndex.hasOwnProperty(key))
3079    if(this.elementsWithChangedTabIndex[key].indexOf(element) !== -1)
3080     return true;
3081  return false;
3082 },
3083 changeTabIndexAttribute: function(element, id) {
3084  var elements = this.getChangedElementsForControlId(id);
3085  ASPx.Attr.ChangeTabIndexAttribute(element);
3086  if(elements.indexOf(element) === -1)
3087   elements.push(element);
3088 },
3089 restoreTabIndexAttribute: function(element, id) {
3090  var elements = this.getChangedElementsForControlId(id),
3091   index = elements.indexOf(element);
3092  if(index !== -1) {
3093   elements.splice(index, 1);
3094   if(!this.isElementWithChangedIndex(element))
3095    ASPx.Attr.RestoreTabIndexAttribute(element);
3096  }
3097 }
3098});
3099ControlTabIndexManager.Instance = null;
3100ControlTabIndexManager.getInstance = function() {
3101 if(!ControlTabIndexManager.Instance)
3102  ControlTabIndexManager.Instance = new ControlTabIndexManager();
3103 return ControlTabIndexManager.Instance;
3104};
3105var ControlCallbackHandlersQueue = ASPx.CreateClass(null, {
3106 constructor: function (owner) {
3107  this.owner = owner;
3108  this.handlerInfos = [];
3109 },
3110 addCallbackHandler: function(handlerInfo) {
3111  this.handlerInfos.push(handlerInfo);
3112 },
3113 executeCallbacksHandlers: function() {
3114  for(var i = 0, handlerInfo; handlerInfo = this.handlerInfos[i]; i++)
3115   handlerInfo.handler.call(this.owner, handlerInfo.result);
3116  this.handlerInfos = [];
3117 }
3118});
3119var ControlCallbackQueueHelper = ASPx.CreateClass(null, {
3120 constructor: function (owner) {
3121  this.owner = owner;
3122  this.pendingCallbacks = [];
3123  this.receivedCallbacks = [];
3124  this.attachEvents();
3125 },
3126 showLoadingElements: function () {
3127  this.owner.ShowLoadingDiv();
3128  if (this.owner.IsCallbackAnimationEnabled())

3129   this.owner.StartBeginCallbackAnimation();
3130  else
3131   this.owner.ShowLoadingElementsInternal();
3132 },
3133 attachEvents: function () {
3134  this.owner.EndCallback.AddHandler(this.onEndCallback.aspxBind(this));
3135  this.owner.CallbackError.AddHandler(this.onCallbackError.aspxBind(this));
3136 },
3137 detachEvents: function () {
3138  this.owner.EndCallback.RemoveHandler(this.onEndCallback);
3139  this.owner.CallbackError.RemoveHandler(this.onCallbackError);
3140 },
3141 onCallbackError: function (owner, result) {
3142  this.sendErrorToChildControl(result);
3143 },
3144 ignoreDuplicates: function () {
3145  return true;
3146 },
3147 hasDuplicate: function (arg) {
3148  for (var i in this.pendingCallbacks) {
3149   if (this.pendingCallbacks[i].arg == arg && this.pendingCallbacks[i].state != ASPx.callbackState.aborted)
3150    return true;
3151  }
3152  return false;
3153 },
3154 getToken: function (halperContext, callbackInfo) {
3155  return {
3156   cancel: function () {
3157    if (callbackInfo.state == ASPx.callbackState.sent) {
3158     callbackInfo.state = ASPx.callbackState.aborted;
3159     halperContext.sendNext();
3160    }
3161    if (callbackInfo.state == ASPx.callbackState.inTurn)
3162     ASPx.Data.ArrayRemove(halperContext.pendingCallbacks, callbackInfo);
3163   },
3164   callbackId: -1
3165  };
3166 },
3167 sendCallback: function (arg, handlerContext, handler, commandName, onBeforeSend) {
3168  if (this.ignoreDuplicates() && this.hasDuplicate(arg))
3169   return false;
3170  var handlerContext = handlerContext || this.owner;
3171  var callbackInfo = {
3172   arg: arg,
3173   handlerContext: handlerContext,
3174   handler: handler || handlerContext.OnCallback,
3175   state: ASPx.callbackState.inTurn,
3176   callbackId: -1,
3177   onBeforeSend: onBeforeSend
3178  };
3179  this.pendingCallbacks.push(callbackInfo);
3180  if (!this.hasActiveCallback()) {
3181   this.createCallbackByCallbackInfo(callbackInfo, commandName);
3182  }
3183  return this.getToken(this, callbackInfo);
3184 },
3185 hasActiveCallback: function () {
3186  return this.getCallbacksInfoByState(ASPx.callbackState.sent).length > 0;
3187 },
3188 sendNext: function () {
3189  var nextCallbackInfo = this.getCallbacksInfoByState(ASPx.callbackState.inTurn)[0];
3190  if (nextCallbackInfo) {
3191   this.createCallbackByCallbackInfo(nextCallbackInfo);
3192   return nextCallbackInfo.callbackId;
3193  }
3194 },
3195 createCallbackByCallbackInfo: function(callbackInfo, commandName) {
3196  if(callbackInfo.onBeforeSend)
3197   callbackInfo.onBeforeSend();
3198  callbackInfo.callbackId = this.owner.CreateCallback(callbackInfo.arg, commandName);
3199  callbackInfo.state = ASPx.callbackState.sent;
3200 },
3201 onEndCallback: function () {
3202  if (!this.owner.isErrorOnCallback && this.hasPendingCallbacks()) {
3203   var curCallbackId;
3204   var curCallbackInfo;
3205   var handlerContext;
3206   for (var i in this.receivedCallbacks) {
3207    if(this.receivedCallbacks.hasOwnProperty(i)) {
3208     curCallbackId = this.receivedCallbacks[i];
3209     curCallbackInfo = this.getCallbackInfoById(curCallbackId);
3210     if (curCallbackInfo.state != ASPx.callbackState.aborted) {
3211      handlerContext = curCallbackInfo.handlerContext;
3212      if (handlerContext.OnEndCallback)
3213       handlerContext.OnEndCallback();
3214      this.sendNext();
3215     }
3216     ASPx.Data.ArrayRemove(this.pendingCallbacks, curCallbackInfo);
3217    }
3218   }
3219   ASPx.Data.ArrayClear(this.receivedCallbacks);
3220  }
3221 },
3222 hasPendingCallbacks: function () {
3223  return this.pendingCallbacks && this.pendingCallbacks.length && this.pendingCallbacks.length > 0;
3224 },
3225 processCallback: function (result, callbackId) {
3226  this.receivedCallbacks.push(callbackId);
3227  if (this.hasPendingCallbacks()) {
3228   var callbackInfo = this.getCallbackInfoById(callbackId);
3229   if (callbackInfo.state != ASPx.callbackState.aborted)
3230    callbackInfo.handler.call(callbackInfo.handlerContext, result);
3231  }
3232 },
3233 getCallbackInfoById: function (id) {
3234  for (var i in this.pendingCallbacks) {
3235   if (this.pendingCallbacks[i].callbackId == id)
3236    return this.pendingCallbacks[i];
3237  }
3238 },
3239 getCallbacksInfoByState: function (state) {
3240  var result = [];
3241  for (var i in this.pendingCallbacks) {
3242   if (this.pendingCallbacks[i].state == state)
3243    result.push(this.pendingCallbacks[i]);
3244  }
3245  return result;
3246 },
3247 sendErrorToChildControl: function (callbackObj) {
3248  if (!this.hasPendingCallbacks())
3249   return;
3250  var callbackInfo = this.getCallbackInfoById(callbackObj.callbackId || 0);
3251  if (!callbackInfo)
3252   return;
3253  var hasChildControlHandler = (callbackInfo.handlerContext != this.owner) && callbackInfo.handlerContext.OnCallbackError;
3254  if (hasChildControlHandler)
3255   callbackInfo.handlerContext.OnCallbackError.call(callbackInfo.handlerContext, callbackObj.message, callbackObj.data);
3256 }
3257});
3258var AccessibilityHelperBase = ASPx.CreateClass(null, {
3259 constructor: function(control) {
3260  this.control = control;
3261  this.pronounceMessageTimeout = 500;
3262  this.pronounceIsStarted = false;
3263  this.timerID = -1;
3264 },
3265 PronounceMessage: function(text, activeItemArgs, inactiveItemArgs, mainElementArgs, ownerMainElement) {
3266  this.timerID = ASPx.Timer.ClearTimer(this.timerID);
3267  this.pronounceIsStarted = true;
3268  this.timerID = window.setTimeout(function() {
3269   this.PronounceMessageCore(text, activeItemArgs, inactiveItemArgs, mainElementArgs, ownerMainElement);
3270  }.aspxBind(this), this.getPronounceTimeout());
3271 },
3272 PronounceMessageCore: function(text) {
3273  this.processValidationState();
3274  if(this.control.IsFocused())
3275   this.control.SendMessageToAssistiveTechnology(text);
3276 },
3277 GetActiveElement: function(inputIsMainElement) {
3278  if(this.pronounceIsStarted) return null;

3279  var mainElement = inputIsMainElement ? this.control.GetInputElement() : this.getMainElement();
3280  var activeElementId = ASPx.Attr.GetAttribute(mainElement, 'aria-activedescendant');
3281  return activeElementId ? ASPx.GetElementById(activeElementId) : mainElement;
3282 },
3283 GetPronounceElement: function() { return null; },
3284 processValidationState: function() {
3285  var errorTextElement = null;
3286  if(this.control.GetErrorCell())
3287   errorTextElement = this.getAriaExplanatoryTextManager().GetErrorTextElement();
3288  var input = this.getInputElement();
3289  var invalidArg =  { "aria-invalid": !this.control.isValid ? "true" : "" };
3290  this.changeActivityAttributes(input, invalidArg);
3291  if(errorTextElement)
3292   this.getAriaExplanatoryTextManager().SetOrRemoveText([input], errorTextElement, !this.control.isValid, false, true);
3293 },
3294 getMainElement: function() {
3295  if(!ASPx.IsExistsElement(this.mainElement))
3296   this.mainElement = this.control.GetAccessibilityAssistantElement();
3297  return this.mainElement;
3298 },
3299 changeActivityAttributes: function(element, args) {
3300  if(!element)
3301   return;
3302  for(var key in args) {
3303   if(args.hasOwnProperty(key)) {
3304    var value = args[key];
3305    if(key == "innerHtml")
3306     ASPx.SetInnerHtml(element, value);
3307    else {
3308     var action = value !== "" ? ASPx.Attr.SetAttribute : ASPx.Attr.RemoveAttribute;
3309     action(element, key, value);
3310    }
3311   }
3312  }
3313 },
3314 getPronounceTimeout: function() { return this.pronounceMessageTimeout; },
3315 getInputElement: function() { return this.control.GetInputElement(); },
3316 getAriaExplanatoryTextManager: function() { return this.control.ariaExplanatoryTextManager; }
3317});
3318var AccessibilityHelper = ASPx.CreateClass(AccessibilityHelperBase, {
3319 constructor: function(control) {
3320  this.constructor.prototype.constructor.call(this, control);
3321  this.activeItem = this.getItems()[0];
3322 },
3323 PronounceMessageCore: function(text, activeItemArgs, inactiveItemArgs, mainElementArgs, ownerMainElement) {
3324  if(!this.getItems())
3325   return;
3326  this.toogleItem();
3327  var mainElement = this.getMainElement();
3328  var activeItem = this.getItem(true);
3329  var inactiveItem = this.getItem();
3330  if(ASPx.Attr.GetAttribute(mainElement, "role") != "application")
3331   mainElementArgs = this.addArguments(mainElementArgs, { "aria-activedescendant" : activeItem.id });
3332  var messageAttrObj = {};
3333  var activeItemRole = ASPx.Attr.GetAttribute(activeItem, "role");
3334  var attrName = activeItemRole == "combobox" ? "aria-label" : "innerHtml";
3335  messageAttrObj[attrName] = ASPx.Str.EncodeHtml(text);
3336  activeItemArgs = this.addArguments(activeItemArgs, messageAttrObj);
3337  messageAttrObj[attrName] = "";
3338  inactiveItemArgs = this.addArguments(inactiveItemArgs, messageAttrObj);
3339  var errorTextElement = null;
3340  if(this.control.GetErrorCell()) {
3341   errorTextElement = this.getAriaExplanatoryTextManager().GetErrorTextElement();
3342   activeItemArgs = this.addArguments(activeItemArgs,   {"aria-invalid"  : !this.control.isValid ? "true" : "" });
3343   mainElementArgs = this.addArguments(mainElementArgs, { "aria-invalid" : "" });
3344   inactiveItemArgs = this.addArguments(inactiveItemArgs,  { "aria-invalid" : "" });
3345  }
3346  this.changeActivityAttributes(activeItem, activeItemArgs);
3347  if(errorTextElement) {
3348   this.getAriaExplanatoryTextManager().SetOrRemoveText([activeItem], errorTextElement, !this.control.isValid, false, true);
3349   this.getAriaExplanatoryTextManager().SetOrRemoveText([mainElement, inactiveItem], errorTextElement, false, false, false);
3350  }
3351  this.changeActivityAttributes(mainElement, mainElementArgs);
3352  if(!!ownerMainElement && ASPx.Attr.GetAttribute(ownerMainElement, "role") != "application")
3353   this.changeActivityAttributes(ownerMainElement, { "aria-activedescendant": activeItem.id });
3354  this.changeActivityAttributes(inactiveItem, inactiveItemArgs);
3355  this.pronounceIsStarted = false;
3356 },
3357 GetPronounceElement: function() {
3358  return this.getItem(true);
3359 },
3360 getItems: function() {
3361  if(!ASPx.IsExistsElement(this.items))
3362   this.items = ASPx.GetChildElementNodes(this.getMainElement());
3363  return this.items;
3364 },
3365 getItem: function(isActive) {
3366  if(isActive)
3367   return this.activeItem;
3368  var items = this.getItems();

3369  return items[0] === this.activeItem ? items[1] : items[0];
3370 },
3371 toogleItem: function() {
3372  this.activeItem = this.getItem();
3373 },
3374 addArguments: function(targetArgs, newArgs) {
3375  if(!targetArgs) targetArgs = { };
3376  for(var key in newArgs) {
3377   if(newArgs.hasOwnProperty(key) && !targetArgs.hasOwnProperty(key))
3378    targetArgs[key] = newArgs[key];
3379  }
3380  return targetArgs;
3381 }
3382});
3383var AccessibilityPronouncer = ASPx.CreateClass(null, {
3384 constructor: function() {
3385  this.pronouncerId = "dxPronouncer";
3386  this.initialized = false;
3387  this.focusableMessageElement = null;
3388  this.messageElement = null;
3389  this.pronouncers = {
3390   live: new AccessibilityLivePronouncer(this),
3391   descendant: new AccessibilityDescendantPronouncer(this)
3392  };
3393 },
3394 Pronounce: function(args, type) {
3395  this.pronouncers[type].Pronounce(args);
3396 },
3397 EnsureInitialize: function() {
3398  if(!this.initialized)
3399   this.initialize();
3400 },
3401 RemoveState: function() {
3402  for(var pronouncer in this.pronouncers)
3403   if(this.pronouncers.hasOwnProperty(pronouncer))
3404    pronouncer.RemoveState();
3405 },
3406 RestoreControlState: function(type, mainElement) {
3407  this.pronouncers[type].RestoreControlState(mainElement);
3408 },
3409 RestoreElementsState: function(type, elements) {
3410  this.pronouncers[type].RestoreElementsState(elements);
3411 },
3412 RestoreElementState: function(type, element) {
3413  this.pronouncers[type].RestoreElementState(element);
3414 },
3415 initialize: function() {
3416  this.createFocusableMessageElement();
3417  this.createMessageElement();
3418  this.prepareFocusableMessageElement();
3419  this.setAttributesForKeyboardNavigation();
3420  this.initialized = true;
3421 },
3422 createFocusableMessageElement: function() {
3423  var focusableMessageElement = document.createElement("DIV");
3424  document.body.appendChild(focusableMessageElement);
3425  this.focusableMessageElement = focusableMessageElement;   
3426 },
3427 prepareFocusableMessageElement: function() {
3428  this.focusableMessageElement.className = "dxAIFME";
3429 },
3430 setAttributesForKeyboardNavigation: function() {
3431  ASPx.Attr.Aria.SetApplicationRole(this.focusableMessageElement);
3432  ASPx.Attr.Aria.SetSilence(this.focusableMessageElement);
3433 },
3434 createMessageElement: function() {
3435  var messageElement = document.createElement("DIV");
3436  messageElement.id = this.pronouncerId;
3437  ASPx.Attr.SetAttribute(messageElement, "role", "note");
3438  this.focusableMessageElement.appendChild(messageElement);
3439  this.messageElement = messageElement;
3440 },
3441 getMessage: function(messagePartsArg) {
3442  var messageParts = messagePartsArg.filter(function(x) { return ASPx.IsExists(x); });
3443  return messageParts.join(", ");
3444 }
3445});
3446var AccessibilityPronouncerBase = ASPx.CreateClass(null, {
3447 constructor: function() {
3448  this.state = { };
3449 },
3450 Pronounce: function(args) {
3451  var messageElement = this.getMessageElement();
3452  ASPx.Attr.Aria.SetOrRemoveLabel(messageElement);
3453  ASPx.SetInnerHtml(messageElement, "");
3454  this.PronounceCore(args);
3455 },
3456 PronounceCore: function(args) { },
3457 SaveElementState: function(element) { 
3458  if(this.state[element.id])
3459   return;
3460  this.state[element.id] = {
3461   element: element,
3462   descendant: ASPx.Attr.GetAttribute(element, ASPx.Attr.Aria.descendant)
3463  };
3464 },
3465 RemoveState: function() {
3466  this.state = { };
3467 },
3468 RestoreControlState: function(mainElement) { 
3469  for(var elementInfo in this.state) {
3470   if(this.state.hasOwnProperty(elementInfo)) {
3471    var element = this.state[elementInfo].element;
3472    if(!mainElement || ASPx.GetIsParent(mainElement, element))
3473     this.RestoreElementState(element);
3474   }
3475  }
3476 },
3477 RestoreElementsState: function(elements) { 
3478  for(var i = 0; i < elements.length; i++)
3479   this.RestoreElementState(elements[i]);
3480 },
3481 RestoreElementState: function(element) {
3482  var elementState = this.state[element.id];
3483  if(!elementState)
3484   return;
3485  ASPx.Attr.Aria.SetOrRemoveDescendant(element, elementState.descendant);
3486  delete this.state[element.id];
3487 },
3488 getMessage: function(args) {
3489  return ASPx.AccessibilityPronouncer.getMessage(args.messageParts);
3490 },
3491 getMessageElement: function() {
3492  return ASPx.AccessibilityPronouncer.messageElement;
3493 },
3494 getFocusableMessageElement: function() {
3495   return ASPx.AccessibilityPronouncer.focusableMessageElement;
3496 }
3497});
3498var AccessibilityLivePronouncer = ASPx.CreateClass(AccessibilityPronouncerBase, {
3499 constructor: function() {
3500  this.constructor.prototype.constructor.call(this);
3501 },
3502 PronounceCore: function(args) {

3503  var message = this.getMessage(args);
3504  var messageElement = this.getMessageElement();
3505  ASPx.Attr.SetAttribute(this.getFocusableMessageElement(), "aria-live", "assertive");
3506  ASPx.Attr.Aria.SetAtomic(this.getFocusableMessageElement(), "true");
3507  ASPx.SetInnerHtml(messageElement, ASPx.Str.EncodeHtml(message));
3508 }
3509});
3510var AccessibilityDescendantPronouncer = ASPx.CreateClass(AccessibilityPronouncerBase, {
3511 constructor: function() {
3512  this.constructor.prototype.constructor.call(this);
3513 },
3514 PronounceCore: function(args) {
3515  var message = this.getMessage(args);
3516  var activeElement = ASPx.GetActiveElement();
3517  var messageElement = this.getMessageElement();
3518  this.SaveElementState(activeElement);
3519  ASPx.Attr.RemoveAttribute(this.getFocusableMessageElement(), "aria-live");
3520  ASPx.Attr.RemoveAttribute(this.getFocusableMessageElement(), "aria-atomic");
3521  ASPx.Attr.Aria.SetOrRemoveLabel(messageElement, message);
3522  ASPx.Attr.Aria.SetOrRemoveDescendant(activeElement, messageElement.id);
3523 }
3524});
3525ASPx.AccessibilityPronouncerType = {
3526 live: "live",
3527 descendant: "descendant"
3528};
3529ASPx.AccessibilityPronouncer = new AccessibilityPronouncer();
3530var RestoreFocusHelper = ASPx.CreateClass(null, {
3531 constructor: function() {
3532  this.excludedIDs = [ "DXCBtn" ]; 
3533  this.pronouncerType = ASPx.AccessibilityPronouncerType.live;
3534  this.callbackQueue = [];
3535  this.Initialize();
3536 },
3537 Initialize: function() {
3538  var that = this;
3539  ASPx.attachToLoad(function() {
3540   ASPxClientControl.GetControlCollection().BeginCallback.AddHandler(that.OnBeginCallback, that);
3541   ASPxClientControl.GetControlCollection().EndCallback.AddHandler(that.OnEndCallback, that);
3542  });
3543 },
3544 OnBeginCallback: function(s, e) {
3545  var control = e.control;
3546  if(!control.allowRestoreFocusOnCallbacks())
3547   return;
3548  control.accessibilityFocusTreeLine = this.getFocusTreeLine(control);
3549  var controlHasCallbackTreeLine = this.callbackQueueContainsTreeLine(control);
3550  this.pushTreeLineInfoIntoCallbackQueue(control);
3551  if(control.accessibilityFocusTreeLine && !controlHasCallbackTreeLine)
3552   control.SendMessageToAssistiveTechnology(this.getDefaultCallbackMessage());
3553 },
3554 OnEndCallback: function(s, e) {
3555  var control = e.control;
3556  if(!control.allowRestoreFocusOnCallbacks())
3557   return;
3558  var treeLineInfo = this.shiftTreeLineInfoFromCallbackQueue(control);
3559  if(treeLineInfo.queueLength == 0) {
3560   if(!control.accessibilityFocusTreeLine && treeLineInfo.treeLine)
3561    control.accessibilityFocusTreeLine = treeLineInfo.treeLine;
3562   var focusElement = this.findFocusElement(control);
3563   var focusIsManagerByPopupwindow = this.isFocusManagedByActivePopupWindow(focusElement);
3564   var focusIsManagedByControl = control.shouldPreventFocusRestoringOnCallback && control.shouldPreventFocusRestoringOnCallback();
3565   if(!focusIsManagerByPopupwindow && !focusIsManagedByControl)
3566    ASPx.AccessibilityUtils.SetFocusAccessible(focusElement);
3567   delete control.accessibilityFocusTreeLine;
3568  }
3569 },
3570 pushTreeLineInfoIntoCallbackQueue: function(control) {
3571  var controlTreeLine = control.accessibilityFocusTreeLine ? control.accessibilityFocusTreeLine.slice(0) : null;
3572  if(!this.callbackQueue[control.name])
3573   this.callbackQueue[control.name] = [];
3574  this.callbackQueue[control.name].push(controlTreeLine);
3575 },
3576 shiftTreeLineInfoFromCallbackQueue: function(control) {
3577  var treeLineInfo = { queueLength: 0, treeLine: null };
3578  var treeLines = this.callbackQueue[control.name];
3579  if(treeLines && treeLines.length > 0) {
3580   treeLineInfo.treeLine = treeLines.shift();
3581   var linesCount = treeLines.length;
3582   treeLineInfo.queueLength = linesCount;
3583   if(linesCount > 0 && !treeLines[0] && treeLineInfo.treeLine)
3584    treeLines[0] = treeLineInfo.treeLine.slice(0);
3585  }
3586  return treeLineInfo;
3587 },
3588 callbackQueueContainsTreeLine: function(control) {
3589  var treeLines = this.callbackQueue[control.name];
3590  if(!treeLines || treeLines.length == 0) 
3591   return false;
3592  if(treeLines[treeLines.length - 1])
3593   return true;
3594  return false;
3595 },
3596 getDefaultCallbackMessage: function() {
3597  return ASPx.AccessibilitySR.DefaultCallbackMessage;
3598 },
3599 isFocusManagedByActivePopupWindow: function(focusElement) {
3600  var popupControl = this.getActivePopupControl();
3601  if(!popupControl || popupControl.accessibleFocusElement)
3602   return false;
3603  this.initializePopupAccessibleFocusElement(popupControl, focusElement);
3604  return popupControl.setFocusOnCallback;
3605 },
3606 getActivePopupControl: function() {
3607  var activePopupWindow = ASPx.GetPopupControlCollection && ASPx.GetPopupControlCollection().GetCurrentActiveWindowElement();
3608  if(!activePopupWindow)
3609   return null;
3610  var popupInfo = ASPx.GetPopupControlCollection().GetPopupWindowFromID(activePopupWindow.id);
3611  return popupInfo.popupControl;
3612 },
3613 initializePopupAccessibleFocusElement: function(popupControl, focusElement) {
3614  if(popupControl.setFocusOnCallback)
3615   popupControl.accessibleFocusElement = focusElement;
3616  else {
3617   var parentControl = popupControl.GetParentControl();
3618   if(parentControl && parentControl.GetMainElement())
3619    popupControl.accessibleFocusElement = ASPx.FindFirstChildActionElement(parentControl.GetMainElement());
3620  }
3621 },
3622 getFocusTreeLine: function(control) {
3623  var element = ASPx.GetActiveElement();
3624  if(!ASPx.IsExistsElement(element))
3625   return null;
3626  var mainElement = control.GetMainElement();
3627  if(!ASPx.GetIsParent(mainElement, element)) {
3628   var treeInfo = this.findFocusedControlElement(mainElement, element);
3629   element = treeInfo.focusElement;
3630   mainElement = treeInfo.rootElement;
3631  }
3632  return this.getTreeLineCore(mainElement, element);
3633 },
3634 getTreeLineCore: function(mainElement, element) {
3635  if(!element) return null;
3636  treeLine = [ ];
3637  while(element) {
3638   treeLine.push({ 

3639    id: element.id,
3640    tagName: element.tagName,
3641    index: ASPx.Data.ArrayIndexOf(element.parentNode.childNodes, element)
3642   });
3643   if(element === mainElement || element === document.body)
3644    break;
3645   element = element.parentNode;
3646  }
3647  return treeLine;
3648 },
3649 findFocusedControlElement: function(mainElement, activeElement) {
3650  var element = null;
3651  var parentElement = mainElement;
3652  var focusedEditor = ASPx.IsExists(ASPx.GetFocusedEditor) ? ASPx.GetFocusedEditor() : null;
3653  if(focusedEditor && ASPx.GetIsParent(mainElement, focusedEditor.GetMainElement()))
3654   element = focusedEditor.GetFocusableInputElement();
3655  else {
3656   if(mainElement && activeElement) {
3657    var mainControl = ASPx.GetClientControlByElementID(mainElement.id);
3658    var parentControls = ASPx.GetParentClientControls(activeElement.id);
3659    for(var i = parentControls.length - 1; i > -1; i--) {   
3660     if(mainControl.name == parentControls[i].name) {
3661      element = activeElement;
3662      var rootIndex = i > 0 ? i - 1 : i;
3663      parentElement = parentControls[rootIndex].GetMainElement();
3664      if(!parentElement && parentControls[rootIndex].GetCurrentWindowElement)
3665       parentElement = parentControls[rootIndex].GetCurrentWindowElement();
3666      break;
3667     }
3668    }
3669   }
3670  }
3671  return { focusElement: element, rootElement: parentElement }; 
3672 },
3673 findFocusElement: function(control) {
3674  if(!control.accessibilityFocusTreeLine)
3675   return;
3676  var treeLine = control.accessibilityFocusTreeLine.slice(0);
3677  var focusElementParent = this.findFocusElementParentById(treeLine);
3678  if(!focusElementParent) 
3679   return;
3680  return this.findFocusElementFromDOMTree(treeLine, focusElementParent);
3681 },
3682 findFocusElementParentById: function(treeLine) {
3683  for(var i = 0; i < treeLine.length; i++) {
3684   var id = treeLine[i].id;
3685   if(!this.isValidId(id))
3686    continue;
3687   var element = document.getElementById(id);
3688   if(element) {
3689    treeLine.splice(i, treeLine.length - i);
3690    treeLine.reverse();
3691    return element;
3692   }
3693  }
3694  return null;
3695 },
3696 findFocusElementFromDOMTree: function(treeLine, focusElementParent) {
3697  var element = focusElementParent;
3698  for(var i = 0; i < treeLine.length; i++) {
3699   var info = treeLine[i];
3700   if(info.index >= element.childNodes.length) {
3701    element = element.childNodes.length > 0 ? element.childNodes[element.childNodes.length - 1] : null;
3702    return this.findNeighbourFocusElement(element, focusElementParent);
3703   }
3704   var child = element.childNodes[info.index];
3705   if(child.tagName !== info.tagName)
3706    return this.findNeighbourFocusElement(child, focusElementParent);
3707   element = child;
3708  }
3709  return element;
3710 },
3711 findNeighbourFocusElement: function(element, focusElementParent) {
3712  ASPx.ActionElementsCache.BeginUsage();
3713  var result = this.findNeighbourFocusElementCore(element, focusElementParent);
3714  ASPx.ActionElementsCache.EndUsage();
3715  return result;
3716 },
3717 findNeighbourFocusElementCore: function(element, focusElementParent) {
3718  if(!element || !element.parentNode) return null;
3719  var neighbours = element.parentNode.childNodes;
3720  var indices = this.calcLeftRightIndices(ASPx.Data.ArrayIndexOf(neighbours, element), neighbours.length);
3721  for(var i = 0; i < indices.length; i++) {
3722   var index = indices[i];
3723   var actionElement = ASPx.FindFirstChildActionElement(neighbours[index]);
3724   if(actionElement)
3725    return actionElement;
3726  }
3727  if(element === focusElementParent)
3728   return null;
3729  return this.findNeighbourFocusElement(element.parentNode, focusElementParent);
3730 },
3731 calcLeftRightIndices: function(startIndex, count) {
3732  var indices = [ ];
3733  var incSides = [ 0, 0 ];
3734  var index = startIndex;
3735  for(var i = 0; i < count; i++) {
3736   indices.push(index);
3737   var even = i % 2 === 0;
3738   var nextIndex = this.calcNextIndex(startIndex, count, incSides, even);
3739   if(nextIndex < 0)
3740    nextIndex = this.calcNextIndex(startIndex, count, incSides, !even);
3741   index = nextIndex;
3742  }
3743  return indices;
3744 },
3745 calcNextIndex: function(startIndex, count, incSides, even) {
3746  var sideIndex = even ? 0 : 1;
3747  var inc = incSides[sideIndex];
3748  inc += even ? -1 : 1;
3749  var nextIndex = startIndex + inc;
3750  if(nextIndex >= 0 && nextIndex < count) {
3751   incSides[sideIndex] = inc;
3752   return nextIndex;
3753  }
3754  return -1;
3755 },
3756 isValidId: function(id) {
3757  return id && !this.isExcludedId(id);
3758 },
3759 isExcludedId: function(id) {
3760  var result = false;
3761  for(var i = 0; i < this.excludedIDs.length; i++) {
3762   if(id.indexOf(this.excludedIDs[i]) > -1) {
3763    result = true;
3764    break;
3765   }
3766  }
3767  return result;
3768 }
3769});
3770var EventStorage = ASPx.CreateClass(null, {
3771 constructor: function() {
3772  this.bag = { };
3773 },
3774 Save: function(e, data, overwrite) {
3775  var key = this.getEventKey(e);
3776  if(this.bag.hasOwnProperty(key) && !overwrite)
3777   return;
3778  this.bag[key] = data;
3779  window.setTimeout(function() { delete this.bag[key]; }.aspxBind(this), 100);
3780 },
3781 Load: function(e) {
3782  var key = this.getEventKey(e);
3783  return this.bag[key];
3784 },
3785 getEventKey: function(e) {
3786  if(ASPx.IsExists(e.timeStamp))
3787   return e.timeStamp.toString();
3788  var eventSource = ASPx.Evt.GetEventSource(e);
3789  var type = e.type.toString();
3790  return eventSource ? type + "_" + eventSource.uniqueID.toString() : type;
3791 }
3792});
3793ASPx.RestoreFocusHelper = new RestoreFocusHelper();
3794EventStorage.Instance = null;
3795EventStorage.getInstance = function() {
3796 if(!EventStorage.Instance)
3797  EventStorage.Instance = new EventStorage();
3798 return EventStorage.Instance;
3799};
3800var GetGlobalObject = function(objectName) {
3801 var fields = objectName.split('.');
3802 var obj = window[fields[0]];
3803 for(var i = 1;

3803 obj && i < fields.length; i++) {
3804  obj = obj[fields[i]];
3805 }
3806 return obj;
3807};
3808var GetExternalScriptProcessor = function() {
3809 return ASPx.ExternalScriptProcessor ? ASPx.ExternalScriptProcessor.getInstance() : null;
3810};
3811var SAVED_WIDTH_ATTR = "data-dx-ripple-saved-width";
3812var RIPPLE_FIXED_ROW_ATTR = "data-dx-ripple-locked";
3813var READ_ONLY_COMBOBOX_MARKER_CSS_CLASS = "dxICBReadonlyMarker";
3814var ThemesWithRipple = ['Material'];
3815var RippleHelper = {
3816 rippleTargetClassName: "dxRippleTarget",
3817 rippleTargetExternalClassName: "dxRippleTargetExternal",
3818 rippleContainerClassName: "dxRippleContainer",
3819 rippleClassName: "dxRipple",
3820 touchRadius: -1,
3821 isMobileExternalRipple: null,
3822 zoom: 1,
3823 Init: function() {
3824  if(this.getIsRippleFunctionalityEnabled()) {
3825   setTimeout(function() {
3826    this.calcTouchRadius();
3827   }.aspxBind(this), 0);
3828  }
3829 },
3830 calcTouchRadius: function() {
3831  var testBlock = document.createElement("DIV");
3832  ASPx.SetStyles(testBlock, {
3833   height: "1in",
3834   width: "1in",
3835   left: "-100%",
3836   top: "-100%",
3837   position: "absolute"
3838  });
3839  document.body.appendChild(testBlock);
3840  this.touchRadius = (1.8 / 2.54) * Math.max(testBlock.offsetWidth, testBlock.offsetHeight);
3841  document.body.removeChild(testBlock);
3842 },
3843 isRippleFunctionalityEnabled: null,
3844 checkRippleFunctionality: function() {
3845  if(ASPx.Browser.Safari && ASPx.Browser.Version <= 5.1)
3846   return false;
3847  for(var i = 0; i < ThemesWithRipple.length; i++) {
3848   var firstRippleThemeElement = document.querySelector("[class*='_" + ThemesWithRipple[i] + "']");
3849   if(firstRippleThemeElement)
3850    return true;
3851  }  
3852  return false;
3853 },
3854 ReInit: function() {
3855  this.isRippleFunctionalityEnabled = null;
3856  this.Init();
3857 },
3858 onDocumentMouseDown: function(evt) {
3859  if(RippleHelper.getIsRippleFunctionalityEnabled())
3860   RippleHelper.processMouseDown(evt);
3861 },
3862 getIsRippleFunctionalityEnabled: function() {
3863  if(!ASPx.IsExists(this.isRippleFunctionalityEnabled))
3864   this.isRippleFunctionalityEnabled = this.checkRippleFunctionality();
3865  return this.isRippleFunctionalityEnabled;
3866 },
3867   createTargetInfo: function(target) {
3868  return { 
3869   x: ASPx.GetAbsoluteX(target),
3870   y: ASPx.GetAbsoluteY(target),
3871   width: target.offsetWidth,
3872   height: target.offsetHeight,
3873   classNames: ASPx.GetClassNameList(target),
3874   getTarget: function() { return target; },
3875   getRect: function() { return {x: this.x, y: this.y, width: this.width, height: this.height }; }
3876  };
3877 },
3878 createEventInfo: function(evt) {
3879  return { x: this.getEventX(evt), y: this.getEventY(evt) };
3880 },
3881 processMouseDown: function(evt) {
3882  var evtSource = ASPx.Evt.GetEventSource(evt);
3883  var rippleTarget = this.getRippleTargetElement(evtSource);
3884  if(this.needToProcessRipple(rippleTarget, evtSource))
3885   this.processRipple(this.createTargetInfo(rippleTarget), this.createEventInfo(evt));
3886 },
3887 getRippleTargetElement: function(evtSource) {
3888  if(this.hasRippleMarker(evtSource))
3889   return evtSource;
3890  if(evtSource.tagName && evtSource.tagName.toLowerCase() == "input" && ASPx.ElementContainsCssClass(evtSource, "dxTI")) {
3891   var elements = ASPx.GetChildElementNodesByPredicate(evtSource.parentNode.parentNode, function(element) {
3892    return this.hasRippleMarker(element);
3893   }.aspxBind(this));
3894   return elements && elements[0];
3895  }
3896  return ASPx.GetParent(evtSource, function(element) {
3897   return this.hasRippleMarker(element);
3898  }.aspxBind(this));
3899 },
3900 hasRippleMarker: function(element) {
3901  if(!ASPx.IsExistsElement(element))
3902   return false;
3903  var computedStyles = window.getComputedStyle(element, ":before");
3904  if(ASPx.IsExists(computedStyles)) {
3905   var content = computedStyles.getPropertyValue("content");
3906   if(content.indexOf(this.rippleTargetExternalClassName) > -1) {
3907    ASPx.AddClassNameToElement(element, this.rippleTargetExternalClassName);
3908    return true;
3909   }
3910   return content.indexOf(this.rippleTargetClassName) > -1;
3911  }
3912  return false;
3913 },
3914 needToProcessRipple: function(rippleTarget, evtSource) {
3915  if(!rippleTarget || !ASPx.AnimationUtils)
3916   return false;
3917  var isClearButton = ASPx.ElementContainsCssClass(rippleTarget, "dxeButton") && rippleTarget.id && rippleTarget.id.indexOf("B-100") !== -1;
3918  var isEmptyCalendarDay = ASPx.ElementContainsCssClass(rippleTarget, "dxeCalendarDay") && ASPx.Str.Trim(rippleTarget.textContent) == "";
3919  var isReadonly = ASPx.ElementContainsCssClass(rippleTarget, READ_ONLY_COMBOBOX_MARKER_CSS_CLASS);
3920  var tempFixDisable = ASPx.ElementContainsCssClass(rippleTarget, "dxSwitcher") && ASPx.Browser.MacOSMobilePlatform;
3921  var rippleIsForbidden = isReadonly || isClearButton || isEmptyCalendarDay || ASPx.GetParentByPartialClassName(rippleTarget, "Disabled") ||
3922   ASPx.ElementContainsCssClass(rippleTarget, "dxgvBatchEditCell") || ASPx.ElementContainsCssClass(rippleTarget, "dxcvEditForm") ||
3923   ASPx.GetParentByPartialClassName(evtSource, "dxcvFocusedCell") || tempFixDisable;
3924  return !rippleIsForbidden;
3925 },
3926 hasBothOverflow: function(style) {
3927  return style.overflow == "scroll" || style.overflow == "auto" || style.overflow == "hidden";
3928 },
3929 hasOverflowX: function(style) {
3930  return style.overflowX == "scroll" || style.overflowX == "auto" || style.overflowX == "hidden";
3931 },
3932 hasOverflowY: function(style) {
3933  return style.overflowY == "scroll" || style.overflowY == "auto" || style.overflowY == "hidden";
3934 },
3935 getExternalRippleContainerSize: function(targetRect) {
3936  if(ASPx.Browser.MobileUI) {
3937   var origTouchRadius = this.getOriginTouchRadius();
3938   if(origTouchRadius < targetRect.width || origTouchRadius < targetRect.height)
3939    origTouchRadius = Math.max(targetRect.width, targetRect.height);
3940   return {x: targetRect.x + (targetRect.width - origTouchRadius) / 2, y: targetRect.y + (targetRect.height - origTouchRadius) / 2, width: origTouchRadius, height: origTouchRadius };
3941  }
3942  var result = { x: 0, y: 0, width: 0, height: 0 };
3943  var diff = targetRect.width - targetRect.height;
3944  if(diff > 0) {
3945   result.x = targetRect.x;
3946   result.y = targetRect.y - diff / 2;
3947   result.width = targetRect.width;
3948   result.height = targetRect.width;
3949  } else {
3950   result.x = targetRect.x + diff / 2;
3951   result.y = targetRect.y;
3952   result.width = targetRect.height;
3953   result.height = targetRect.height;
3954  }
3955  return result;
3956 },
3957 getInternalContainerSize: function(targetInfo) {
3958  var parentWithOverflow = RippleHelper.getParentWithOverflow(targetInfo.getTarget());
3959  if(!ASPx.IsExists(parentWithOverflow))
3960   return targetInfo;
3961  var parentWithOverflowStyle = ASPx.GetCurrentStyle(parentWithOverflow);
3962  var bothOverflow = this.hasBothOverflow(parentWithOverflowStyle);
3963  var overflowX = this.hasOverflowX(parentWithOverflowStyle);
3964  var overflowY = this.hasOverflowY(parentWithOverflowStyle);
3965  var parentRect = {
3966   x: ASPx.GetAbsoluteX(parentWithOverflow),
3967   y: ASPx.GetAbsoluteY(parentWithOverflow),
3968   width: parentWithOverflow.offsetWidth,
3969   height: parentWithOverflow.offsetHeight
3970  };
3971  return this.getInternalContainerSizeCore(targetInfo, parentRect, bothOverflow, overflowX, overflowY);
3972 },
3973 getInternalContainerSizeCore: function(targetRect, parentRect, bothOverflow, overflowX, overflowY) {
3974  var result = {};
3975  ASPx.Data.MergeHashTables(result, targetRect);
3976  if(bothOverflow || overflowX) {
3977   result.x = targetRect.x < parentRect.x ? parentRect.x : targetRect.x;
3978   if(targetRect.x + targetRect.width > parentRect.x + parentRect.width)
3979    result.width = parentRect.x + parentRect.width - targetRect.x;
3980   if(parentRect.x > targetRect.x)
3981    result.width -= (parentRect.x - targetRect.x);
3982  }
3983  if(bothOverflow || overflowY) {
3984   result.y = targetRect.y < parentRect.y ? parentRect.y : targetRect.y;
3985   if(targetRect.y + targetRect.height > parentRect.y + parentRect.height)
3986    result.height = parentRect.y + parentRect.height - targetRect.y;
3987   if(parentRect.y > targetRect.y)
3988    result.height -= (parentRect.y - targetRect.y);
3989  }
3990  return result;
3991 },
3992 calculateRippleContainerSize: function(targetInfo, isExternalRipple) {
3993  return isExternalRipple ? this.getExternalRippleContainerSize(targetInfo) : this.getInternalContainerSize(targetInfo);
3994 },
3995 getParentWithOverflow: function(rippleTarget) {
3996  var result = ASPx.GetParent(rippleTarget, function(element) {
3997   var elementStyle = ASPx.GetCurrentStyle(element);
3998   return this.hasBothOverflow(elementStyle) || this.hasOverflowX(elementStyle) || this.hasOverflowY(elementStyle);
3999  }.aspxBind(this));
4000  return result;
4001 },
4002 getDuration: function(targetInfo) {
4003  return this.IsExternalRipple(targetInfo) || ASPx.Browser.MobileUI ? 650 : 450;
4004 },
4005 createRippleTransition: function(container, rippleElement, radius, targetInfo) {
4006  var rippleSize = 2 * radius;
4007  var transitionProperties = {
4008   width: { from: 0, to: rippleSize, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "width", unit: "px" },
4009   height: { from: 0, to: rippleSize, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "height", unit: "px" },
4010   marginLeft: { from: 0, to: -rippleSize / 2, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "marginLeft", unit: "px" },
4011   marginTop: { from: 0, to: -rippleSize / 2, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "marginTop", unit: "px" },
4012   opacity: { from: 1, to: 0.05, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "o

4012pacity", unit: "%" }
4013  };
4014  var rippleTransition = ASPx.AnimationUtils.createMultipleAnimationTransition(rippleElement, {
4015   transition: ASPx.AnimationConstants.Transitions.RIPPLE,
4016   duration: this.getDuration(targetInfo),
4017   needForceTransitionEndByTimerFlag: true, 
4018   onComplete: function() {
4019    this.RemoveRippleContainer(container.parentElement);
4020   }.bind(this)
4021  });
4022  rippleTransition.Start(transitionProperties);
4023 },
4024 needForceTransitionEndByTimer: function() { return true; }, 
4025 calculateRadius: function(isExternalRipple, posX, posY, containerRect) {
4026  var radius = -1;
4027  if(isExternalRipple) {
4028   if(ASPx.Browser.MobileUI)
4029    radius = this.getOriginTouchRadius() / 2;
4030   else
4031    radius = Math.max(containerRect.height, containerRect.width);
4032  } else {
4033   var width1 = posX - containerRect.x;
4034   var width2 = containerRect.width - width1;
4035   var height1 = posY - containerRect.y;
4036   var height2 = containerRect.height - height1;
4037   var rippleWidth = Math.max(width1, width2);
4038   var rippleHeight = Math.max(height1, height2);
4039   radius = Math.sqrt(Math.pow(rippleHeight, 2) + Math.pow(rippleWidth, 2));
4040  }
4041  return radius;
4042 },
4043 createRippleElement: function(container, rippleCenter) {
4044  var rippleElement = document.createElement("DIV");
4045  rippleElement.className = this.rippleClassName;
4046  container.appendChild(rippleElement);
4047  ASPxClientUtils.SetAbsoluteX(rippleElement, rippleCenter.x);
4048  ASPxClientUtils.SetAbsoluteY(rippleElement, rippleCenter.y);
4049  return rippleElement;
4050 },
4051 processRipple: function(targetInfo, eventInfo) {
4052  this.initRippleProcess();
4053  var isExternalRipple = this.IsExternalRipple(targetInfo);
4054  var rippleCenter = this.getRippleCenter(targetInfo.getRect(), eventInfo, isExternalRipple);
4055  var container = this.createRippleContainer(targetInfo, isExternalRipple);
4056  var rippleElement = this.createRippleElement(container, rippleCenter);
4057  var radius = this.calculateRadius(isExternalRipple, rippleCenter.x, rippleCenter.y, this.getElementRect(container));
4058  this.createRippleTransition(container, rippleElement, radius, targetInfo);
4059 },
4060 initRippleProcess: function() {
4061  this.isMobileExternalRipple = null;
4062  this.zoom = screen.width / window.innerWidth;
4063 },
4064 getRippleCenter: function(targetInfo, eventInfo, isExternalRipple) {
4065  var posX = 0;
4066  var posY = 0;
4067  if(isExternalRipple) {
4068   posX = targetInfo.x + targetInfo.width / 2;
4069   posY = targetInfo.y + targetInfo.height / 2;
4070  } else {
4071   posX = eventInfo.x;
4072   posY = eventInfo.y;
4073  }
4074  return {x: posX, y: posY};
4075 },
4076 createRippleContainer: function(targetInfo, isExternalRipple) {
4077  var containerParent = targetInfo.getTarget();
4078  if(!containerParent)
4079   return;
4080  var containerTagName = containerParent.tagName == "TR" ? "TD" : "DIV";
4081  var container = document.createElement(containerTagName);
4082  container.className = this.rippleContainerClassName;
4083  if(containerParent.parentNode && containerParent.tagName == "IMG")
4084   containerParent = containerParent.parentNode;
4085  if(this.isARowInFixedLayoutTable(containerParent))
4086   this.lockFixedLayoutTableSizes(containerParent);
4087  containerParent.appendChild(container);
4088  if(isExternalRipple)
4089   container.style.borderRadius = "50%";
4090  var containerRect = this.calculateRippleContainerSize(targetInfo, isExternalRipple);
4091  this.assignContainerSettings(container, containerRect);
4092  return container;
4093 },
4094 isARowInFixedLayoutTable: function(containerParent) {
4095  if(containerParent.tagName !== "TR")
4096   return false;
4097  var parentTable = this.getParentTable(containerParent);
4098  return parentTable && ASPx.GetCurrentStyle(parentTable)["table-layout"] === "fixed";
4099 },
4100 processFirstRowOfFixedTable: function(containerRow, rowAction, cellAction) {
4101  var firstRow = this.getFirstRow(containerRow);
4102  rowAction(firstRow);
4103  var cells = ASPx.Data.CollectionToArray(firstRow.cells);
4104  cells.forEach(cellAction);
4105 },
4106 getParentTable: function(element) {
4107  var parentTable = element;
4108  while(parentTable && parentTable.tagName !== "TABLE")
4109   parentTable = parentTable.parentElement;
4110  return parentTable;
4111 },
4112 lockFixedLayoutTableSizes: function(containerRow) {
4113  var firstRow = this.getFirstRow(containerRow);
4114  if(this.incLockCount(firstRow) === 1) {
4115   var cells = ASPx.Data.CollectionToArray(firstRow.cells);
4116   var widths = cells.map(function(cell) { return cell.style.width; });
4117   var computedWidths = cells.map(function(cell) {
4118    return window.getComputedStyle(cell).width;
4119   });
4120   var fixWidth = function(cell, i) {
4121    if(ASPx.Attr.IsExistsAttribute(cell, SAVED_WIDTH_ATTR))
4122     return;
4123    if(widths[i])
4124     ASPx.Attr.SetAttribute(cell, SAVED_WIDTH_ATTR, widths[i]);
4125    cell.style.width = computedWidths[i];
4126   };

4127   cells.forEach(fixWidth);
4128  }
4129 }, 
4130 unlockFixedLayoutTableSizes: function(containerRow) {
4131  var firstRow = this.getFirstRow(containerRow);   
4132  if(this.decLockCount(firstRow) === 0) {
4133   var cells = ASPx.Data.CollectionToArray(firstRow.cells);
4134   var restoreState = function(cell) {
4135    if(ASPx.Attr.IsExistsAttribute(cell, SAVED_WIDTH_ATTR)) {
4136     cell.style.width = ASPx.Attr.GetAttribute(cell, SAVED_WIDTH_ATTR);
4137     ASPx.Attr.RemoveAttribute(cell, SAVED_WIDTH_ATTR);
4138    } else {
4139     cell.style.width = null;
4140    }
4141   };
4142   cells.forEach(restoreState);
4143  }
4144 },
4145 getFirstRow: function(containerRow) { return ASPx.GetChildByTagName(containerRow.parentElement, "TR", 0); },
4146 incLockCount: function(elem) { return this.changeLockCount(elem, 1); },
4147 decLockCount: function(elem) { return this.changeLockCount(elem, -1); },
4148 changeLockCount: function(elem, diff) {
4149  var lockCounter = this.getLockCount(elem);
4150  lockCounter += diff;
4151  lockCounter = Math.max(0, lockCounter);
4152  if(lockCounter === 0)
4153   ASPx.Attr.RemoveAttribute(elem, RIPPLE_FIXED_ROW_ATTR);
4154  else
4155   ASPx.Attr.SetAttribute(elem, RIPPLE_FIXED_ROW_ATTR, lockCounter);
4156  return lockCounter;
4157 },
4158 getLockCount: function(lockElement) {
4159  var attrValue = ASPx.Attr.GetAttribute(lockElement, RIPPLE_FIXED_ROW_ATTR);
4160  return parseInt(attrValue) || 0;
4161 },
4162 assignContainerSettings: function(container, containerRect) {
4163  var properties = {
4164   height: containerRect.height,
4165   width: containerRect.width,
4166   left: ASPx.PrepareClientPosForElement(containerRect.x, container, true),
4167   top: ASPx.PrepareClientPosForElement(containerRect.y, container, false)
4168  };
4169  if(ASPx.Browser.MobileUI)
4170   ASPx.Data.MergeHashTables(properties, {marginTop: 0, marginLeft: 0 });
4171  ASPx.SetStyles(container, properties, ASPx.Browser.MobileUI);
4172 },
4173 IsExternalRipple: function(targetInfo) {
4174  var hasExternalRippleClassName = ASPx.ElementContainsCssClass(targetInfo.getTarget(), this.rippleTargetExternalClassName);
4175  if(!ASPx.Browser.MobileUI)
4176   return hasExternalRippleClassName;
4177  return hasExternalRippleClassName || this.IsMobileExternalRipple(targetInfo);
4178 },
4179 IsMobileExternalRipple: function(targetInfo) {
4180  if(this.isMobileExternalRipple == null) {
4181   var originTouchRadius = this.getOriginTouchRadius();
4182   this.isMobileExternalRipple = ASPx.Browser.MobileUI && targetInfo.width < originTouchRadius && targetInfo.height < originTouchRadius;
4183  }
4184  return this.isMobileExternalRipple;
4185 },
4186 RemoveRippleContainer: function(element) {
4187  if(!element)
4188   return;
4189  var childs = ASPx.GetChildNodesByClassName(element, this.rippleContainerClassName);
4190  var rippleContainer = childs.length > 0 ? childs[0] : null;
4191  if(rippleContainer != null) {
4192   var containerParent = rippleContainer.parentNode;
4193   containerParent.removeChild(rippleContainer);
4194   if(this.isARowInFixedLayoutTable(containerParent))
4195    this.unlockFixedLayoutTableSizes(containerParent);
4196  }
4197 },
4198 getEventX: function(evt) {
4199  return ASPxClientUtils.GetEventX(evt);
4200 },
4201 getEventY: function(evt) {
4202  return ASPxClientUtils.GetEventY(evt);
4203 },
4204 getOriginTouchRadius: function() {
4205  return this.touchRadius / this.zoom;
4206 },
4207 getElementRect: function(element) {
4208  return { x: ASPx.GetAbsoluteX(element), y: ASPx.GetAbsoluteY(element), width: element.offsetWidth, height: element.offsetHeight };
4209 }
4210};
4211var AccessibilitySR = {
4212 AddStringResources: function(stringResourcesObj) {
4213  if(stringResourcesObj) {
4214   for(var key in stringResourcesObj)
4215    if(stringResourcesObj.hasOwnProperty(key))
4216     this[key] = stringResourcesObj[key];
4217  }
4218 }
4219};
4220ASPx.OrderedMap = OrderedMap;
4221ASPx.CollectionBase = CollectionBase;
4222ASPx.FunctionIsInCallstack = _aspxFunctionIsInCallstack;
4223ASPx.RaisePostHandlerOnPost = aspxRaisePostHandlerOnPost;
4224ASPx.GetPostHandler = aspxGetPostHandler;
4225ASPx.ProcessScriptsAndLinks = _aspxProcessScriptsAndLinks;
4226ASPx.InitializeLinks = _aspxInitializeLinks;
4227ASPx.InitializeScripts = _aspxInitializeScripts;
4228ASPx.RunStartupScripts = _aspxRunStartupScripts;
4229ASPx.IsStartupScriptsRunning = _aspxIsStartupScriptsRunning;
4230ASPx.AddScriptsRestartHandler = _aspxAddScriptsRestartHandler;
4231ASPx.GetFocusedElement = _aspxGetFocusedElement;
4232ASPx.GetDomObserver = _aspxGetDomObserver;

4233ASPx.CacheHelper = CacheHelper;
4234ASPx.ControlTree = ControlTree;
4235ASPx.ControlAdjuster = ControlAdjuster;
4236ASPx.GetControlAdjuster = GetControlAdjuster;
4237ASPx.ControlCallbackHandlersQueue = ControlCallbackHandlersQueue;
4238ASPx.ResourceManager = ResourceManager;
4239ASPx.UpdateWatcherHelper = UpdateWatcherHelper;
4240ASPx.EventStorage = EventStorage;
4241ASPx.GetGlobalObject = GetGlobalObject;
4242ASPx.GetExternalScriptProcessor = GetExternalScriptProcessor;
4243ASPx.CheckBoxCheckState = CheckBoxCheckState;
4244ASPx.CheckBoxInputKey = CheckBoxInputKey;
4245ASPx.CheckableElementStateController = CheckableElementStateController;
4246ASPx.CheckableElementHelper = CheckableElementHelper;
4247ASPx.CheckBoxInternal = CheckBoxInternal;
4248ASPx.CheckBoxInternalCollection = CheckBoxInternalCollection;
4249ASPx.ControlCallbackQueueHelper = ControlCallbackQueueHelper;
4250ASPx.FocusedStyleDecoration = FocusedStyleDecoration;
4251ASPx.EditorStyleDecoration = EditorStyleDecoration;
4252ASPx.TextEditorStyleDecoration = TextEditorStyleDecoration;
4253ASPx.AccessibilitySR = AccessibilitySR;
4254ASPx.KbdHelper = KbdHelper;
4255ASPx.AccessKeysHelper = AccessKeysHelper;
4256ASPx.AccessKey = AccessKey;
4257ASPx.IFrameHelper = IFrameHelper;
4258ASPx.Ident = Ident;
4259ASPx.TouchUIHelper = TouchUIHelper;
4260ASPx.ControlUpdateWatcher = ControlUpdateWatcher;
4261ASPx.ControlTabIndexManager = ControlTabIndexManager;
4262ASPx.AccessibilityHelperBase = AccessibilityHelperBase;
4263ASPx.AccessibilityHelper = AccessibilityHelper;
4264ASPx.RippleHelper = RippleHelper;
4265ASPx.ThemesWithRipple = ThemesWithRipple;
4266ASPx.NetworkError = NetworkError;
4267window.ASPxClientEvent = ASPxClientEvent;
4268window.ASPxClientEventArgs = ASPxClientEventArgs;
4269window.ASPxClientCancelEventArgs = ASPxClientCancelEventArgs;
4270window.ASPxClientProcessingModeEventArgs = ASPxClientProcessingModeEventArgs;
4271window.ASPxClientProcessingModeCancelEventArgs = ASPxClientProcessingModeCancelEventArgs;
4272ASPx.Evt.AttachEventToDocument(TouchUIHelper.touchMouseDownEventName, RippleHelper.onDocumentMouseDown);
4273ASPx.classesScriptParsed = true;
4274})(ASPx, { GCCheckInterval: 5000 });
4275
4276(function () {
4277 IntersectionObserversManager = ASPx.CreateClass(null, {
4278  constructor: function() {
4279   this.rootElementToObserverMap = this.createMap();
4280   this.elementToHandlerMap = this.createMap();
4281   this.clearInvalidElementsInterval = null;
4282   this.clearInvalidElementsPeriod = 5000;
4283  },
4284  AddTargetElement: function(element, rootElement, visibilityChangedHandler) {
4285   this.addTargetElementCore(element, rootElement, visibilityChangedHandler);
4286  },
4287  SubscribeElemensVisibilityChangeInBrowserWindow: function (element, visibilityChangedHandler) {
4288   this.addTargetElementCore(element, null, visibilityChangedHandler);
4289  },
4290  createMap: function() {
4291   return new Map();
4292  },
4293  getObserver: function() {
4294   return IntersectionObserver;
4295  },
4296  initializeObserver: function(rootElement) {
4297   if(!this.rootElementToObserverMap.get(rootElement)) {
4298    var options = {
4299     root: rootElement,
4300     rootMargin: '-1px',
4301     threshold: 0.0 
4302    };
4303    var observerClass = this.getObserver();
4304    var observer = new observerClass(this.visibilityChanged.bind(this), options);
4305    this.rootElementToObserverMap.set(rootElement, observer);
4306   }
4307  },
4308  addTargetElementCore: function(element, rootElement, visibilityChangedHandler) {
4309   this.initializeObserver(rootElement);
4310   if(!this.isAlreadyObserved(element)) {
4311    var observer = this.rootElementToObserverMap.get(rootElement);
4312    if(observer) {
4313     observer.observe(element);
4314     this.setObservedMarker(element);
4315     this.setElementVisibilityChangedHandler(element, visibilityChangedHandler, observer);
4316     if(this.clearInvalidElementsInterval === null) {
4317      this.clearInvalidElementsInterval = setInterval(this.removeDeletedElements.bind(this), this.clearInvalidElementsPeriod);
4318     }
4319    }
4320   }
4321  },
4322  visibilityChanged: function(entries, observer) {
4323   entries.forEach(function (entry) {
4324    if(ASPx.IsExistsElement(entry.target)){
4325     var element = this.elementToHandlerMap.get(observer);
4326     if(element) {
4327      var handler = element.get(entry.target);
4328      if(handler)
4329       handler(entry.isIntersecting);
4330     }
4331    }
4332   }.bind(this));
4333  },
4334  removeDeletedElements: function() {

4335   this.elementToHandlerMap.forEach(function(elements, observer) {
4336    elements.forEach(function(handler, element) {
4337     if(!ASPx.IsExistsElement(element)) {
4338      elements.delete(element);
4339     }
4340    }.bind(this));
4341    if(elements.size === 0) {
4342     this.elementToHandlerMap.delete(observer);
4343    }
4344   }.bind(this));
4345   if(this.elementToHandlerMap.size === 0) {
4346    clearInterval(this.clearInvalidElementsInterval);
4347    this.clearInvalidElementsInterval = null;
4348   }
4349  },
4350  setElementVisibilityChangedHandler: function(element, visibilityChangedHandler, observer) {
4351   if(!this.elementToHandlerMap.get(observer))
4352    this.elementToHandlerMap.set(observer, this.createMap());
4353   var el = this.elementToHandlerMap.get(observer);
4354   if(el)
4355    el.set(element, visibilityChangedHandler);
4356  },
4357  isAlreadyObserved: function(element) {
4358   return !!element.dxObserved;
4359  },
4360  setObservedMarker: function(element) {
4361   element.dxObserved = true;
4362  },
4363  reset: function() {
4364   this.rootElementToObserverMap.forEach(function(observer, rootElement) {
4365    observer.disconnect();
4366   }.bind(this));
4367   this.rootElementToObserverMap = this.createMap();
4368   this.elementToHandlerMap = this.createMap();
4369   this.clearInvalidElementsInterval = null;
4370   this.clearInvalidElementsPeriod = 5000;
4371  }
4372 });
4373 IntersectionObserversManagerForOldBrowsers = ASPx.CreateClass(null, {
4374  SubscribeElemensVisibilityChangeInBrowserWindow: function() { }
4375 });
4376 ASPx.IntersectionObserversManager = ASPx.IntersectionObserversManager || ((typeof(IntersectionObserver) !== "undefined") ? new IntersectionObserversManager() : new IntersectionObserversManagerForOldBrowsers());
4377}
4378)(ASPx);
4379
4380(function () {
4381ASPx.StateItemsExist = false;
4382ASPx.FocusedItemKind = "FocusedStateItem";
4383ASPx.HoverItemKind = "HoverStateItem";
4384ASPx.PressedItemKind = "PressedStateItem";
4385ASPx.SelectedItemKind = "SelectedStateItem";
4386ASPx.DisabledItemKind = "DisabledStateItem";
4387ASPx.ReadOnlyItemKind = "ReadOnlyStateItem";
4388ASPx.CachedStatePrefix = "cached";
4389ASPxStateItem = ASPx.CreateClass(null, {
4390 constructor: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, kind, disableApplyingStyleToLink){
4391  this.name = name;
4392  this.classNames = classNames;
4393  this.customClassNames = [];
4394  this.resultClassNames = [];
4395  this.cssTexts = cssTexts;
4396  this.postfixes = postfixes;
4397  this.imageObjs = imageObjs;
4398  this.imagePostfixes = imagePostfixes;
4399  this.kind = kind;
4400  this.classNamePostfix = kind.substr(0, 1).toLowerCase();
4401  this.enabled = true;
4402  this.needRefreshBetweenElements = false;
4403  this.elements = null;
4404  this.images = null;
4405  this.links = [];
4406  this.colorChanged = [];
4407  this.textDecorationChanged = [];
4408  this.disableApplyingStyleToLink = !!disableApplyingStyleToLink; 
4409 },
4410 GetCssText: function(index){
4411  if(ASPx.IsExists(this.cssTexts[index]))
4412   return this.cssTexts[index];
4413  return this.cssTexts[0];
4414 },
4415 CreateStyleRule: function(index){
4416  if(this.GetCssText(index) == "") return "";
4417  var styleSheet = ASPx.GetCurrentStyleSheet();
4418  if(styleSheet)
4419   return ASPx.CreateImportantStyleRule(styleSheet, this.GetCssText(index), this.classNamePostfix);  
4420  return ""; 
4421 },
4422 GetClassName: function(index){
4423  if(ASPx.IsExists(this.classNames[index]))
4424   return this.classNames[index];
4425  return this.classNames[0];
4426 },
4427 GetResultClassName: function(index){
4428  if(!ASPx.IsExists(this.resultClassNames[index])) {
4429   if(!ASPx.IsExists(this.customClassNames[index]))
4430    this.customClassNames[index] = this.CreateStyleRule(index);
4431   if(this.GetClassName(index) != "" && this.customClassNames[index] != "")
4432    this.resultClassNames[index] = this.GetClassName(index) + " " + this.customClassNames[index];
4433   else if(this.GetClassName(index) != "")
4434    this.resultClassNames[index] = this.GetClassName(index);
4435   else if(this.customClassNames[index] != "")
4436    this.resultClassNames[index] = this.customClassNames[index];
4437   else
4438    this.resultClassNames[index] = "";
4439  }
4440  return this.resultClassNames[index];
4441 },
4442 GetElements: function(element){
4443  if(!this.elements || !ASPx.IsValidElements(this.elements)){
4444   if(this.postfixes && this.postfixes.length > 0){
4445    this.elements = [ ];
4446    var parentNode = element.parentNode;
4447    if(parentNode){

4448     for(var i = 0; i < this.postfixes.length; i++){
4449      var id = this.name + this.postfixes[i];
4450      this.elements[i] = ASPx.GetChildById(parentNode, id);
4451      if(!this.elements[i])
4452       this.elements[i] = ASPx.GetElementById(id);
4453     }
4454    }
4455   }
4456   else
4457    this.elements = [element];
4458  }
4459  return this.elements;
4460 },
4461 GetImages: function(element){
4462  if(!this.images || !ASPx.IsValidElements(this.images)){
4463   this.images = [ ];
4464   if(this.imagePostfixes && this.imagePostfixes.length > 0){
4465    var elements = this.GetElements(element);
4466    for(var i = 0; i < this.imagePostfixes.length; i++){
4467     var id = this.name + this.imagePostfixes[i];
4468     for(var j = 0; j < elements.length; j++){
4469      if(!elements[j]) continue;
4470      if(elements[j].id == id)
4471       this.images[i] = elements[j];
4472      else
4473       this.images[i] = ASPx.GetChildById(elements[j], id);
4474      if(this.images[i])
4475       break;
4476     }
4477    }
4478   }
4479  }
4480  return this.images;
4481 },
4482 Apply: function(element){
4483  if(!this.enabled) return;
4484  try{
4485   this.ApplyStyle(element);
4486   if(this.imageObjs && this.imageObjs.length > 0)
4487    this.ApplyImage(element);
4488  }
4489  catch(e){
4490  }
4491 },
4492 ApplyStyle: function(element){
4493  var elements = this.GetElements(element);
4494  for(var i = 0; i < elements.length; i++){
4495   if(!elements[i]) continue;
4496   var elementColor, elementTextDecoration;
4497   if(this.colorChanged[i] === undefined) {
4498    elementColor = window.getComputedStyle(elements[i]).color;
4499   }
4500   if(this.textDecorationChanged[i] === undefined) {
4501    elementTextDecoration = window.getComputedStyle(elements[i]).textDecoration;
4502   }
4503   if(this.GetResultClassName(i) != "") {
4504    var className = elements[i].className.replace(this.GetResultClassName(i), "");
4505    elements[i].className = ASPx.Str.Trim(className) + " " + this.GetResultClassName(i);
4506   }
4507   if(this.colorChanged[i] === undefined) {
4508    this.colorChanged[i] = window.getComputedStyle(elements[i]).color !== elementColor;
4509   }
4510   if(this.textDecorationChanged[i] === undefined) {
4511    this.textDecorationChanged[i] = window.getComputedStyle(elements[i]).textDecoration !== elementTextDecoration;
4512   }
4513   if(!ASPx.Browser.Opera || ASPx.Browser.Version >= 9)
4514    this.ApplyStyleToLinks(elements, i);
4515  }
4516 },
4517 ApplyStyleToLinks: function(elements, index){
4518  if(this.disableApplyingStyleToLink)
4519   return;
4520  if(!ASPx.IsValidElements(this.links[index]))
4521   this.links[index] = ASPx.GetNodesByTagName(elements[index], "A");
4522  for(var i = 0; i < this.links[index].length; i++)
4523   this.ApplyStyleToLinkElement(this.links[index][i], index);
4524 },
4525 ApplyStyleToLinkElement: function(link, index) {
4526  if(this.colorChanged[index])
4527   ASPx.Attr.ChangeAttributeExtended(link.style, "color", link, "saved" + this.kind + "Color", "inherit");
4528  if(this.textDecorationChanged[index])
4529   ASPx.Attr.ChangeAttributeExtended(link.style, "text-decoration", link, "saved" + this.kind + "TextDecoration", "inherit");
4530 },
4531 ApplyImage: function(element){
4532  var images = this.GetImages(element);
4533  for(var i = 0; i < images.length; i++){
4534   if(!images[i] || !this.imageObjs[i]) continue;
4535   var useSpriteImage = typeof(this.imageObjs[i]) != "string";
4536   var newUrl = "", newCssClass = "", newBackground = "";
4537   if(useSpriteImage){
4538    newUrl = ASPx.EmptyImageUrl;           
4539    if(this.imageObjs[i].spriteCssClass) 
4540     newCssClass = this.imageObjs[i].spriteCssClass;

4541    if(this.imageObjs[i].spriteBackground)
4542     newBackground = this.imageObjs[i].spriteBackground;
4543   }
4544   else{
4545    newUrl = this.imageObjs[i];
4546    if(ASPx.Attr.IsExistsAttribute(images[i].style, "background"))   
4547     newBackground = " ";
4548   }
4549   if(newUrl != "")
4550    ASPx.Attr.ChangeAttributeExtended(images[i], "src", images[i], "saved" + this.kind + "Src", newUrl);
4551   if(newCssClass != "")
4552    this.ApplyImageClassName(images[i], newCssClass);
4553   if(newBackground != ""){
4554    if(ASPx.Browser.WebKitFamily) {
4555     var savedBackground = ASPx.Attr.GetAttribute(images[i].style, "background");
4556     if(!useSpriteImage)
4557      savedBackground += " " + images[i].style["backgroundPosition"];
4558     ASPx.Attr.SetAttribute(images[i], "saved" + this.kind + "Background", savedBackground);
4559     ASPx.Attr.SetAttribute(images[i].style, "background", newBackground);
4560    }
4561    else
4562     ASPx.Attr.ChangeAttributeExtended(images[i].style, "background", images[i], "saved" + this.kind + "Background", newBackground);
4563   }     
4564  }
4565 },
4566 ApplyImageClassName: function(element, newClassName){
4567  if(ASPx.Attr.GetAttribute(element, "saved" + this.kind + "ClassName"))
4568   this.CancelImageClassName(element);
4569  var className = element.className;
4570  ASPx.Attr.SetAttribute(element, "saved" + this.kind + "ClassName", className);
4571  element.className = className + " " + newClassName;
4572 },
4573 Cancel: function(element){
4574  if(!this.enabled) return;
4575  try{  
4576   if(this.imageObjs && this.imageObjs.length > 0)
4577    this.CancelImage(element);
4578   this.CancelStyle(element);
4579  }
4580  catch(e){
4581  }
4582 },
4583 CancelStyle: function(element){
4584  var elements = this.GetElements(element);
4585  for(var i = 0; i < elements.length; i++){
4586   if(!elements[i]) continue;
4587   if(this.GetResultClassName(i) != "") {
4588    var className = ASPx.Str.Trim(elements[i].className.replace(this.GetResultClassName(i), ""));
4589    elements[i].className = className;
4590   }
4591   if(!ASPx.Browser.Opera || ASPx.Browser.Version >= 9)
4592    this.CancelStyleFromLinks(elements, i);
4593  }
4594 },
4595 CancelStyleFromLinks: function(elements, index){
4596  if(this.disableApplyingStyleToLink)
4597   return;
4598  if(!ASPx.IsValidElements(this.links[index]))
4599   this.links[index] = ASPx.GetNodesByTagName(elements[index], "A");
4600  for(var i = 0; i < this.links[index].length; i++)
4601   this.CancelStyleFromLinkElement(this.links[index][i], index);
4602 },
4603 CancelStyleFromLinkElement: function(link, index){
4604  ASPx.Attr.RestoreAttributeExtended(link.style, "color", link, "saved" + this.kind + "Color");
4605  ASPx.Attr.RestoreAttributeExtended(link.style, "text-decoration", link, "saved" + this.kind + "TextDecoration");
4606 },
4607 CancelImage: function(element){
4608  var images = this.GetImages(element);
4609  for(var i = 0; i < images.length; i++){
4610   if(!images[i] || !this.imageObjs[i]) continue;
4611   ASPx.Attr.RestoreAttributeExtended(images[i], "src", images[i], "saved" + this.kind + "Src");
4612   this.CancelImageClassName(images[i]);
4613   ASPx.Attr.RestoreAttributeExtended(images[i].style, "background", images[i], "saved" + this.kind + "Background");
4614  }
4615 },
4616 CancelImageClassName: function(element){
4617  var savedClassName = ASPx.Attr.GetAttribute(element, "saved" + this.kind + "ClassName");
4618  if(ASPx.IsExists(savedClassName)) {
4619   element.className = savedClassName;
4620   ASPx.Attr.RemoveAttribute(element, "saved" + this.kind + "ClassName");
4621  }
4622 },
4623 Clone: function(){
4624  return new ASPxStateItem(this.name, this.classNames, this.cssTexts, this.postfixes, 
4625   this.imageObjs, this.imagePostfixes, this.kind, this.disableApplyingStyleToLink);
4626 },
4627 IsChildElement: function(element){
4628  if(element != null){
4629   var elements = this.GetElements(element);
4630   for(var i = 0; i < elements.length; i++){
4631    if(!elements[i]) continue;
4632    if(ASPx.GetIsParent(elements[i], element)) 
4633     return true;
4634   }
4635  }
4636  return false;
4637 },
4638 ForceRedrawAppearance: function(element) {
4639  if(!aspxGetStateController().IsForceRedrawAppearanceLocked()) {
4640   var value = element.style.opacity;
4641   element.style.opacity = "0.7777";
4642   var dummy = element.offsetWidth;
4643   element.style.opacity = value;
4644  }
4645 }
4646});
4647ASPxClientStateEventArgs = ASPx.CreateClass(null, {
4648 constructor: function(item, element){
4649  this.item = item;
4650  this.element = element;
4651  this.toElement = null;
4652  this.fromElement = null;
4653  this.htmlEvent = null;
4654 }
4655});
4656ASPxStateController = ASPx.CreateClass(null, {
4657 constructor: function(){
4658  this.focusedItems = { };
4659  this.hoverItems = { };
4660  this.pressedItems = { };
4661  this.selectedItems = { };
4662  this.disabledItems = {};
4663  this.readOnlyItems = {};
4664  this.disabledScheme = {};
4665  this.currentFocusedElement = null;
4666  this.currentFocusedItemName = null;
4667  this.currentHoverElement = null;
4668  this.currentHoverItemName = null;
4669  this.currentPressedElement = null;
4670  this.currentPressedItemName = null;
4671  this.savedCurrentPressedElement = null;
4672  this.savedCurrentMouseMoveSrcElement = null;
4673  this.forceRedrawAppearanceLockCount = 0;
4674  this.stateItemType = ASPxStateItem;
4675  this.AfterSetFocusedState = new ASPxClientEvent();
4676  this.AfterClearFocusedState = new ASPxClientEvent();
4677  this.AfterSetHoverState = new ASPxClientEvent();
4678  this.AfterClearHoverState = new ASPxClientEvent();
4679  this.AfterSetPressedState = new ASPxClientEvent();
4680  this.AfterClearPressedState = new ASPxClientEvent();
4681  this.AfterDisabled = new ASPxClientEvent();
4682  this.AfterEnabled = new ASPxClientEvent();
4683  this.BeforeSetFocusedState = new ASPxClientEvent();
4684  this.BeforeClearFocusedState = new ASPxClientEvent();
4685  this.BeforeSetHoverState = new ASPxClientEvent();
4686  this.BeforeClearHoverState = new ASPxClientEvent();
4687  this.BeforeSetPressedState = new ASPxClientEvent();
4688  this.BeforeClearPressedState = new ASPxClientEvent();
4689  this.BeforeDisabled = new ASPxClientEvent();
4690  this.BeforeEnabled = new ASPxClientEvent();
4691  this.FocusedItemKeyDown = new ASPxClientEvent();
4692 }, 
4693 AddHoverItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink){
4694  this.AddItem(this.hoverItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.HoverItemKind, disableApplyingStyleToLink);
4695  this.AddItem(this.focusedItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.FocusedItemKind, disableApplyingStyleToLink);
4696 },
4697 AddPressedItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink){
4698  this.AddItem(this.pressedItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.PressedItemKind, disableApplyingStyleToLink);
4699 },
4700 AddSelectedItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink){
4701  this.AddItem(this.selectedItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.SelectedItemKind, disableApplyingStyleToLink);
4702 },
4703 AddDisabledItem: function (name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink, rootId) {
4704  this.AddItem(this.disabledItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes,
4705   ASPx.DisabledItemKind, disableApplyingStyleToLink, this.addIdToDisabledItemScheme, rootId);
4706 },
4707 AddReadOnlyItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink) {
4708  this.AddItem(this.readOnlyItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.ReadOnlyItemKind, disableApplyingStyleToLink);
4709 },
4710 addIdToDisabledItemScheme: function(rootId, childId) {
4711  if (!rootId)
4712   return;
4713  if (!this.disabledScheme[rootId])
4714   this.disabledScheme[rootId] = [rootId];

4715  if (childId && (rootId != childId) && ASPx.Data.ArrayIndexOf(this.disabledScheme[rootId], childId) == -1)
4716   this.disabledScheme[rootId].push(childId);
4717 },
4718 removeIdFromDisabledItemScheme: function(rootId, childId) {
4719  if (!rootId || !this.disabledScheme[rootId])
4720   return;
4721  ASPx.Data.ArrayRemove(this.disabledScheme[rootId], childId);
4722  if (this.disabledScheme[rootId].length == 0)
4723   delete this.disabledScheme[rootId];
4724 },
4725 AddItem: function (items, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, kind, disableApplyingStyleToLink, onAdd, rootId) {
4726  var type = this.getStateItemType();
4727  var stateItem = new type(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, kind, disableApplyingStyleToLink);
4728  if (postfixes && postfixes.length > 0) {
4729   for (var i = 0; i < postfixes.length; i++) {
4730    items[name + postfixes[i]] = stateItem;
4731    if (onAdd)
4732     onAdd.call(this, rootId, name + postfixes[i]);
4733   }
4734  }
4735  else {
4736   if (onAdd)
4737    onAdd.call(this, rootId, name);
4738   items[name] = stateItem;
4739  }
4740  ASPx.StateItemsExist = true;
4741 },
4742 getStateItemType: function () { return this.stateItemType; },
4743 withCustomStateItemType: function (newType, callback) {
4744  this.stateItemType = newType;
4745  callback(this);
4746  this.stateItemType = ASPxStateItem;
4747 },
4748 RemoveHoverItem: function(name, postfixes){
4749  this.RemoveItem(this.hoverItems, name, postfixes);
4750  this.RemoveItem(this.focusedItems, name, postfixes);
4751 },
4752 RemovePressedItem: function(name, postfixes){
4753  this.RemoveItem(this.pressedItems, name, postfixes);
4754 },
4755 RemoveSelectedItem: function(name, postfixes){
4756  this.RemoveItem(this.selectedItems, name, postfixes);
4757 },
4758 RemoveDisabledItem: function (name, postfixes, rootId) {
4759  this.RemoveItem(this.disabledItems, name, postfixes, this.removeIdFromDisabledItemScheme, rootId);
4760 },
4761 RemoveReadOnlyItem: function(name, postfixes) {
4762  this.RemoveItem(this.readOnlyItems, name, postfixes);
4763 },
4764 RemoveItem: function (items, name, postfixes, onRemove, rootId) {
4765  if (postfixes && postfixes.length > 0) {
4766   for (var i = 0; i < postfixes.length; i++) {
4767    delete items[name + postfixes[i]];
4768    if (onRemove)
4769     onRemove.call(this, rootId, name + postfixes[i]);
4770   }
4771  }
4772  else {
4773   delete items[name];
4774   if (onRemove)
4775    onRemove.call(this, rootId, name);
4776  }
4777 },
4778 RemoveDisposedItems: function(){
4779  this.RemoveDisposedItemsByType(this.hoverItems);
4780  this.RemoveDisposedItemsByType(this.pressedItems);
4781  this.RemoveDisposedItemsByType(this.focusedItems);
4782  this.RemoveDisposedItemsByType(this.selectedItems);
4783  this.RemoveDisposedItemsByType(this.disabledItems);
4784  this.RemoveDisposedItemsByType(this.disabledScheme);
4785  this.RemoveDisposedItemsByType(this.readOnlyItems);
4786 },
4787 RemoveDisposedItemsByType: function(items){
4788  for(var key in items) {
4789   if(items.hasOwnProperty(key)) {
4790    var item = items[key];
4791    var element = document.getElementById(key);
4792    if(!element || !ASPx.IsValidElement(element))
4793     delete items[key];
4794    try {
4795     if(item && item.elements) {
4796      for(var i = 0; i < item.elements.length; i++) {
4797       if(!ASPx.IsValidElements(item.links[i]))
4798        item.links[i] = null;
4799      }
4800     }
4801    }
4802    catch(e) {
4803    }
4804   }
4805  }
4806 },
4807 GetFocusedElement: function(srcElement){
4808  return this.GetItemElement(srcElement, this.focusedItems, ASPx.FocusedItemKind);
4809 },
4810 GetHoverElement: function(srcElement){
4811  return this.GetItemElement(srcElement, this.hoverItems, ASPx.HoverItemKind);
4812 },
4813 GetPressedElement: function(srcElement){
4814  return this.GetItemElement(srcElement, this.pressedItems, ASPx.PressedItemKind);
4815 },
4816 GetSelectedElement: function(srcElement){
4817  return this.GetItemElement(srcElement, this.selectedItems, ASPx.SelectedItemKind);
4818 },
4819 GetDisabledElement: function(srcElement){
4820  return this.GetItemElement(srcElement, this.disabledItems, ASPx.DisabledItemKind);
4821 },
4822 GetReadOnlyElement: function(srcElement) {
4823  return this.GetItemElement(srcElement, this.readOnlyItems, ASPx.ReadOnlyItemKind);
4824 },
4825 GetItemElement: function(srcElement, items, kind){
4826  if(srcElement && srcElement[ASPx.CachedStatePrefix + kind]){
4827   var cachedElement = srcElement[ASPx.CachedStatePrefix + kind];
4828   if(cachedElement != ASPx.EmptyObject)
4829    return cachedElement;
4830   return null;
4831  }
4832  var element = srcElement;
4833  while(element != null) {

4834   var item = items[element.id];
4835   if(item){
4836    this.CacheItemElement(srcElement, kind, element);
4837    element[kind] = item;
4838    return element;
4839   }
4840   element = element.parentNode;
4841  }
4842  this.CacheItemElement(srcElement, kind, ASPx.EmptyObject);
4843  return null;
4844 },
4845 CacheItemElement: function(srcElement, kind, value){
4846  if(srcElement && !srcElement[ASPx.CachedStatePrefix + kind])
4847   srcElement[ASPx.CachedStatePrefix + kind] = value;
4848 },
4849 DoSetFocusedState: function(element, fromElement){
4850  var item = element[ASPx.FocusedItemKind];
4851  if(item){
4852   var args = new ASPxClientStateEventArgs(item, element);
4853   args.fromElement = fromElement;
4854   this.BeforeSetFocusedState.FireEvent(this, args);
4855   item.Apply(element);
4856   this.AfterSetFocusedState.FireEvent(this, args);
4857  }
4858 },
4859 DoClearFocusedState: function(element, toElement){
4860  var item = element[ASPx.FocusedItemKind];
4861  if(item){
4862   var args = new ASPxClientStateEventArgs(item, element);
4863   args.toElement = toElement;
4864   this.BeforeClearFocusedState.FireEvent(this, args);
4865   item.Cancel(element);
4866   this.AfterClearFocusedState.FireEvent(this, args);
4867  }
4868 },
4869 DoSetHoverState: function(element, fromElement){
4870  var item = element[ASPx.HoverItemKind];
4871  if(item){
4872   var args = new ASPxClientStateEventArgs(item, element);
4873   args.fromElement = fromElement;
4874   this.BeforeSetHoverState.FireEvent(this, args);
4875   item.Apply(element);
4876   this.AfterSetHoverState.FireEvent(this, args);
4877  }
4878 },
4879 DoClearHoverState: function(element, toElement){
4880  var item = element[ASPx.HoverItemKind];
4881  if(item){
4882   var args = new ASPxClientStateEventArgs(item, element);
4883   args.toElement = toElement;
4884   this.BeforeClearHoverState.FireEvent(this, args);
4885   item.Cancel(element);
4886   this.AfterClearHoverState.FireEvent(this, args);
4887  }
4888 },
4889 DoSetPressedState: function(element){
4890  var item = element[ASPx.PressedItemKind];
4891  if(item){
4892   var args = new ASPxClientStateEventArgs(item, element);
4893   this.BeforeSetPressedState.FireEvent(this, args);
4894   item.Apply(element);
4895   this.AfterSetPressedState.FireEvent(this, args);
4896  }
4897 },
4898 DoClearPressedState: function(element){
4899  var item = element[ASPx.PressedItemKind];
4900  if(item){
4901   var args = new ASPxClientStateEventArgs(item, element);
4902   this.BeforeClearPressedState.FireEvent(this, args);
4903   item.Cancel(element);
4904   this.AfterClearPressedState.FireEvent(this, args);
4905  }
4906 },
4907 SetCurrentFocusedElement: function(element){
4908  if(this.currentFocusedElement && !ASPx.IsValidElement(this.currentFocusedElement)){
4909   this.currentFocusedElement = null;
4910   this.currentFocusedItemName = "";
4911  }
4912  if(this.currentFocusedElement != element){
4913   var oldCurrentFocusedElement = this.currentFocusedElement;
4914   var item = (element != null) ? element[ASPx.FocusedItemKind] : null;
4915   var itemName = (item != null) ? item.name : "";
4916   if(this.currentFocusedItemName != itemName){
4917    if(this.currentHoverItemName != "")
4918     this.SetCurrentHoverElement(null);
4919    if(this.currentFocusedElement != null)
4920     this.DoClearFocusedState(this.currentFocusedElement, element);
4921    this.currentFocusedElement = element;
4922    item = (element != null) ? element[ASPx.FocusedItemKind] : null;
4923    this.currentFocusedItemName = (item != null) ? item.name : "";
4924    if(this.currentFocusedElement != null)
4925     this.DoSetFocusedState(this.currentFocusedElement, oldCurrentFocusedElement);
4926   }
4927  }
4928 },
4929 GetCurrentHoverElement: function() {
4930  return this.currentHoverElement;
4931 },
4932 SetCurrentHoverElement: function(element){
4933  if(this.currentHoverElement && !ASPx.IsValidElement(this.currentHoverElement)){
4934   this.currentHoverElement = null;
4935   this.currentHoverItemName = "";
4936  }
4937  var item = (element != null) ? element[ASPx.HoverItemKind] : null;
4938  if(item && !item.enabled) { 
4939   element = this.GetItemElement(element.parentNode, this.hoverItems, ASPx.HoverItemKind);
4940   item = (element != null) ? element[ASPx.HoverItemKind] : null;
4941  }
4942  if(this.currentHoverElement != element){
4943   var oldCurrentHoverElement = this.currentHoverElement,
4944    itemName = (item != null) ? item.name : "";
4945   if(this.currentHoverItemName != itemName || (item != null && item.needRefreshBetweenElements)){
4946    if(this.currentHoverElement != null)
4947     this.DoClearHoverState(this.currentHoverElement, element);
4948    item = (element != null) ? element[ASPx.HoverItemKind] : null;
4949    if(item == null || item.enabled){
4950     this.currentHoverElement = element;
4951     this.currentHoverItemName = (item != null) ? item.name : "";
4952     if(this.currentHoverElement != null)
4953      this.DoSetHoverState(this.currentHoverElement, oldCurrentHoverElement);
4954    }
4955   }
4956  }
4957 },
4958 SetCurrentPressedElement: function(element){
4959  if(this.currentPressedElement && !ASPx.IsValidElement(this.currentPressedElement)){
4960   this.currentPressedElement = null;
4961   this.currentPressedItemName = "";
4962  }
4963  if(this.currentPressedElement != element){
4964   if(this.currentPressedElement != null)
4965    this.DoClearPressedState(this.currentPressedElement);
4966   var item = (element != null) ? element[ASPx.PressedItemKind] : null;
4967   if(item == null || item.enabled){
4968    this.currentPressedElement = element;
4969    this.currentPressedItemName = (item != null) ? item.name : "";
4970    if(this.currentPressedElement != null)
4971     this.DoSetPressedState(this.currentPressedElement);
4972   }
4973  }
4974 },
4975 SetCurrentFocusedElementBySrcElement: function(srcElement){
4976  var element = this.GetFocusedElement(srcElement);
4977  this.SetCurrentFocusedElement(element);
4978 },
4979 SetCurrentHoverElementBySrcElement: function(srcElement){
4980  var element = this.GetHoverElement(srcElement);
4981  this.SetCurrentHoverElement(element);
4982 },
4983 SetCurrentPressedElementBySrcElement: function(srcElement){
4984  var element = this.GetPressedElement(srcElement);
4985  this.SetCurrentPressedElement(element);
4986 },
4987 SetPressedElement: function (element) {
4988  this.SetCurrentHoverElement(null);
4989  this.SetCurrentPressedElementBySrcElement(element);
4990  this.savedCurrentPressedElement = this.currentPressedElement;
4991 },
4992 SelectElement: function (element) {
4993  var item = element[ASPx.SelectedItemKind];
4994  if(item)
4995   item.Apply(element);
4996 }, 
4997 SelectElementBySrcElement: function(srcElement){
4998  var element = this.GetSelectedElement(srcElement);
4999  if(element != null) this.SelectElement(element);
5000 }, 
5001 DeselectElement: function(element){
5002  var item = element[ASPx.SelectedItemKind];
5003  if(item)
5004   item.Cancel(element);
5005 }, 
5006 DeselectElementBySrcElement: function(srcElement){
5007  var element = this.GetSelectedElement(srcElement);
5008  if(element != null) this.DeselectElement(element);
5009 },
5010 SetElementEnabled: function(element, enable){
5011  if(enable)
5012   this.EnableElement(element);
5013  else
5014   this.DisableElement(element);
5015 },
5016 SetElementReadOnly: function(element, readOnly) {
5017  var element = this.GetReadOnlyElement(element);
5018  if (element != null) {
5019   var item = element[ASPx.ReadOnlyItemKind];
5020   if(item) {
5021    if(readOnly) {
5022     if(item.name == this.currentPressedItemName)
5023      this.SetCurrentPressedElement(null);
5024     if(item.name == this.currentHoverItemName)
5025      this.SetCurrentHoverElement(null);
5026    }
5027    if(readOnly)
5028     item.Apply(element);
5029    else
5030     item.Cancel(element);
5031   }
5032  }
5033 },
5034 SetElementWithChildNodesEnabled: function (parentName, enabled) {
5035  var procFunct = (enabled ? this.EnableElement : this.DisableElement);
5036  var childItems = this.disabledScheme[parentName];
5037  if (childItems && childItems.length > 0)
5038   for (var i = 0; i < childItems.length; i++) {
5039    procFunct.call(this, document.getElementById(childItems[i]));
5040   }
5041 },
5042 DisableElement: function (element) {
5043  var element = this.GetDisabledElement(element);
5044  if(element != null) {
5045   var item = element[ASPx.DisabledItemKind];
5046   if(item){
5047    var args = new ASPxClientStateEventArgs(item, element);
5048    this.BeforeDisabled.FireEvent(this, args);
5049    if(item.name == this.currentPressedItemName)
5050     this.SetCurrentPressedElement(null);
5051    if(item.name == this.currentHoverItemName)
5052     this.SetCurrentHoverElement(null);
5053    item.Apply(element);
5054    this.SetMouseStateItemsEnabled(item.name, item.postfixes, false);
5055    this.AfterDisabled.FireEvent(this, args);
5056   }
5057  }
5058 }, 
5059 EnableElement: function(element){
5060  var element = this.GetDisabledElement(element);
5061  if(element != null) {
5062   var item = element[ASPx.DisabledItemKind];
5063   if(item){
5064    var args = new ASPxClientStateEventArgs(item, element);
5065    this.BeforeEnabled.FireEvent(this, args);
5066    item.Cancel(element);
5067    this.SetMouseStateItemsEnabled(item.name, item.postfixes, true);
5068    this.AfterEnabled.FireEvent(this, args);
5069   }
5070  }
5071 }, 
5072 SetMouseStateItemsEnabled: function(name, postfixes, enabled){   
5073  if(postfixes && postfixes.length > 0){
5074   for(var i = 0; i < postfixes.length; i ++){
5075    this.SetItemsEnabled(this.hoverItems, name + postfixes[i], enabled);
5076    this.SetItemsEnabled(this.pressedItems, name + postfixes[i], enabled);
5077    this.SetItemsEnabled(this.focusedItems, name + postfixes[i], enabled);
5078   }
5079  }
5080  else{
5081   this.SetItemsEnabled(this.hoverItems, name, enabled);
5082   this.SetItemsEnabled(this.pressedItems, name, enabled);
5083   this.SetItemsEnabled(this.focusedItems, name, enabled);
5084  }  
5085 },
5086 SetItemsEnabled: function(items, name, enabled){   
5087  if(items[name])
5088   items[name].enabled = enabled;
5089 },
5090 OnFocusMove: function(evt){
5091  var element = ASPx.Evt.GetEventSource(evt);
5092  aspxGetStateController().SetCurrentFocusedElementBySrcElement(element);
5093 },
5094 OnMouseMove: function(evt, checkElementChanged){
5095  var srcElement = ASPx.Evt.GetEventSource(evt);
5096  if(checkElementChanged && srcElement == this.savedCurrentMouseMoveSrcElement) return;
5097  this.savedCurrentMouseMoveSrcElement = srcElement;
5098  if(this.savedCurrentPressedElement == null)
5099   this.SetCurrentHoverElementBySrcElement(srcElement);
5100  else{
5101   var element = this.GetPressedElement(srcElement);
5102   if(element != this.currentPressedElement){
5103    if(element == this.savedCurrentPressedElement)
5104     this.SetCurrentPressedElement(this.savedCurrentPressedElement);
5105    else
5106     this.SetCurrentPressedElement(null);
5107   }
5108  }
5109 },
5110 OnMouseDown: function(evt){
5111  if(!ASPx.Evt.IsLeftButtonPressed(evt)) return;
5112  var srcElement = ASPx.Evt.GetEventSource(evt);
5113  this.OnMouseDownOnElement(srcElement);
5114 },
5115 OnMouseDownOnElement: function (element) {
5116  if(this.GetPressedElement(element) == null) return;
5117  this.SetPressedElement(element);
5118 },
5119 OnMouseUp: function(evt){
5120  var srcElement = ASPx.Evt.GetEventSource(evt);
5121  this.OnMouseUpOnElement(srcElement);
5122 },
5123 OnMouseUpOnElement: function(element){
5124  if(this.savedCurrentPressedElement == null) return;
5125  this.ClearSavedCurrentPressedElement();
5126  this.SetCurrentHoverElementBySrcElement(element);
5127 },
5128 OnMouseOver: function(evt){
5129  var element = ASPx.Evt.GetEventSource(evt);
5130  if(element && element.tagName == "IFRAME")
5131   this.OnMouseMove(evt, true);
5132 },
5133 OnKeyDown: function(evt){
5134  var element = this.GetFocusedElement(ASPx.Evt.GetEventSource(evt));
5135  if(element != null && element == this.currentFocusedElement) {
5136   var item = element[ASPx.FocusedItemKind];
5137   if(item){
5138    var args = new ASPxClientStateEventArgs(item, element);
5139    args.htmlEvent = evt;
5140    this.FocusedItemKeyDown.FireEvent(this, args);
5141   }
5142  }
5143 },
5144 OnKeyUpOnElement: function(evt) {
5145  if(this.savedCurrentPressedElement != null && ASPx.Evt.IsActionKeyPressed(evt))
5146   this.ClearSavedCurrentPressedElement();
5147 },
5148 OnSelectStart: function(evt){
5149  if(this.savedCurrentPressedElement) {
5150   ASPx.Selection.Clear();
5151   return false;
5152  }
5153 },
5154 ClearSavedCurrentPressedElement: function() {
5155  this.savedCurrentPressedElement = null;
5156  this.SetCurrentPressedElement(null);
5157 },
5158 ClearCache: function(srcElement, kind) {
5159  if(srcElement[ASPx.CachedStatePrefix + kind])
5160   srcElement[ASPx.CachedStatePrefix + kind] = null;
5161 },
5162 ClearElementCache: function(srcElement) {
5163  this.ClearCache(srcElement, ASPx.FocusedItemKind);
5164  this.ClearCache(srcElement, ASPx.HoverItemKind);
5165  this.ClearCache(srcElement, ASPx.PressedItemKind);
5166  this.ClearCache(srcElement, ASPx.SelectedItemKind);
5167  this.ClearCache(srcElement, ASPx.DisabledItemKind);
5168 },
5169 ClearElementCacheInContainer: function(container) {
5170  var elements = ASPx.GetNodes(container);
5171  elements.push(container);
5172  ASPx.Data.ForEach(elements, this.ClearElementCache.bind(this));
5173 },
5174 LockForceRedrawAppearance: function() {
5175  this.forceRedrawAppearanceLockCount++;
5176 },
5177 UnlockForceRedrawAppearance: function() {
5178  this.forceRedrawAppearanceLockCount--;
5179 },
5180 IsForceRedrawAppearanceLocked: function() {
5181  return this.forceRedrawAppearanceLockCount > 0;
5182 },
5183 GetHoverItem: function(srcElement) {
5184  var element = this.GetHoverElement(srcElement);
5185  return (element != null) ? element[ASPx.HoverItemKind] : null;
5186 }
5187});
5188var stateController = null;
5189function aspxGetStateController(){
5190 if(stateController == null)
5191  stateController = new ASPxStateController();
5192 return stateController;
5193}
5194function aspxAddStateItems(method, namePrefix, classes, disableApplyingStyleToLink){
5195 for(var i = 0; i < classes.length; i ++){
5196  for(var j = 0; j < classes[i][2].length; j ++) {
5197   var name = namePrefix;
5198   if(classes[i][2][j])
5199    name += "_" + classes[i][2][j];
5200   var postfixes = classes[i][3] || null;
5201   var imageObjs = (classes[i][4] && classes[i][4][j]) || null;
5202   var imagePostfixes = classes[i][5] || null;
5203   method.call(aspxGetStateController(), name, classes[i][0], classes[i][1], postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink, namePrefix);
5204  }
5205 }
5206}
5207ASPx.AddHoverItems = function(namePrefix, classes, disableApplyingStyleToLink){
5208 aspxAddStateItems(aspxGetStateController().AddHoverItem, namePrefix, classes, disableApplyingStyleToLink);
5209};
5210ASPx.AddPressedItems = function(namePrefix, classes, disableApplyingStyleToLink){
5211 aspxAddStateItems(aspxGetStateController().AddPressedItem, namePrefix, classes, disableApplyingStyleToLink);
5212};
5213ASPx.AddSelectedItems = function(namePrefix, classes, disableApplyingStyleToLink){
5214 aspxAddStateItems(aspxGetStateController().AddSelectedItem, namePrefix, classes, disableApplyingStyleToLink);
5215};
5216ASPx.AddDisabledItems = function(namePrefix, classes, disableApplyingStyleToLink){
5217 aspxAddStateItems(aspxGetStateController().AddDisabledItem, namePrefix, classes, disableApplyingStyleToLink);
5218};
5219ASPx.AddReadOnlyItems = function(namePrefix, classes, disableApplyingStyleToLink) {
5220 aspxAddStateItems(aspxGetStateController().AddReadOnlyItem, namePrefix, classes, disableApplyingStyleToLink);
5221};
5222function aspxRemoveStateItems(method, namePrefix, classes){
5223 for(var i = 0; i < classes.length; i ++){
5224  for(var j = 0; j < classes[i][0].length; j ++) {
5225   var name = namePrefix;
5226   if(classes[i][0][j])
5227    name += "_" + classes[i][0][j];
5228   method.call(aspxGetStateController(), name, classes[i][1], namePrefix);
5229  }
5230 }
5231}
5232ASPx.RemoveHoverItems = function(namePrefix, classes){
5233 aspxRemoveStateItems(aspxGetStateController().RemoveHoverItem, namePrefix, classes);
5234};
5235ASPx.RemovePressedItems = function(namePrefix, classes){
5236 aspxRemoveStateItems(aspxGetStateController().RemovePressedItem, namePrefix, classes);
5237};
5238ASPx.RemoveSelectedItems = function(namePrefix, classes){
5239 aspxRemoveStateItems(aspxGetStateController().RemoveSelectedItem, namePrefix, classes);
5240};
5241ASPx.RemoveDisabledItems = function(namePrefix, classes){
5242 aspxRemoveStateItems(aspxGetStateController().RemoveDisabledItem, namePrefix, classes);
5243};
5244ASPx.RemoveReadOnlyItems = function(namePrefix, classes) {
5245 aspxRemoveStateItems(aspxGetStateController().RemoveReadOnlyItem, namePrefix, classes);
5246};
5247ASPx.AddAfterClearFocusedState = function(handler){
5248 aspxGetStateController().AfterClearFocusedState.AddHandler(handler);
5249};

5250ASPx.AddAfterSetFocusedState = function(handler){
5251 aspxGetStateController().AfterSetFocusedState.AddHandler(handler);
5252};
5253ASPx.AddAfterClearHoverState = function(handler){
5254 aspxGetStateController().AfterClearHoverState.AddHandler(handler);
5255};
5256ASPx.AddAfterSetHoverState = function(handler){
5257 aspxGetStateController().AfterSetHoverState.AddHandler(handler);
5258};
5259ASPx.AddAfterClearPressedState = function(handler){
5260 aspxGetStateController().AfterClearPressedState.AddHandler(handler);
5261};
5262ASPx.AddAfterSetPressedState = function(handler){
5263 aspxGetStateController().AfterSetPressedState.AddHandler(handler);
5264};
5265ASPx.AddAfterDisabled = function(handler){
5266 aspxGetStateController().AfterDisabled.AddHandler(handler);
5267};
5268ASPx.AddAfterEnabled = function(handler){
5269 aspxGetStateController().AfterEnabled.AddHandler(handler);
5270};
5271ASPx.AddBeforeClearFocusedState = function(handler){
5272 aspxGetStateController().BeforeClearFocusedState.AddHandler(handler);
5273};
5274ASPx.AddBeforeSetFocusedState = function(handler){
5275 aspxGetStateController().BeforeSetFocusedState.AddHandler(handler);
5276};
5277ASPx.AddBeforeClearHoverState = function(handler){
5278 aspxGetStateController().BeforeClearHoverState.AddHandler(handler);
5279};
5280ASPx.AddBeforeSetHoverState = function(handler){
5281 aspxGetStateController().BeforeSetHoverState.AddHandler(handler);
5282};
5283ASPx.AddBeforeClearPressedState = function(handler){
5284 aspxGetStateController().BeforeClearPressedState.AddHandler(handler);
5285};
5286ASPx.AddBeforeSetPressedState = function(handler){
5287 aspxGetStateController().BeforeSetPressedState.AddHandler(handler);
5288};
5289ASPx.AddBeforeDisabled = function(handler){
5290 aspxGetStateController().BeforeDisabled.AddHandler(handler);
5291};
5292ASPx.AddBeforeEnabled = function(handler){
5293 aspxGetStateController().BeforeEnabled.AddHandler(handler);
5294};
5295ASPx.AddFocusedItemKeyDown = function(handler){
5296 aspxGetStateController().FocusedItemKeyDown.AddHandler(handler);
5297};
5298ASPx.SetHoverState = function(element){
5299 aspxGetStateController().SetCurrentHoverElementBySrcElement(element);
5300};
5301ASPx.ClearHoverState = function(evt){
5302 aspxGetStateController().SetCurrentHoverElementBySrcElement(null);
5303};
5304ASPx.UpdateHoverState = function(evt){
5305 aspxGetStateController().OnMouseMove(evt, false);
5306};
5307ASPx.SetFocusedState = function(element){
5308 aspxGetStateController().SetCurrentFocusedElementBySrcElement(element);
5309};
5310ASPx.ClearFocusedState = function(evt){
5311 aspxGetStateController().SetCurrentFocusedElementBySrcElement(null);
5312};
5313ASPx.UpdateFocusedState = function(evt){
5314 aspxGetStateController().OnFocusMove(evt);
5315};
5316ASPx.AccessibilityMarkerClass = "dxalink";
5317ASPx.AssignAccessibilityEventsToChildrenLinks = function(container, clearFocusedStateOnMouseOut){
5318 var links = ASPx.GetNodesByPartialClassName(container, ASPx.AccessibilityMarkerClass);
5319 for(var i = 0; i < links.length; i++)
5320  ASPx.AssignAccessibilityEventsToLink(links[i], clearFocusedStateOnMouseOut);
5321};
5322ASPx.AssignAccessibilityEventsToLink = function(link, clearFocusedStateOnMouseOut) {
5323 if(!ASPx.ElementContainsCssClass(link, ASPx.AccessibilityMarkerClass))
5324  return;
5325 ASPx.AssignAccessibilityEventsToLinkCore(link, clearFocusedStateOnMouseOut);
5326};
5327ASPx.AssignAccessibilityEventsToLinkCore = function (link, clearFocusedStateOnMouseOut) {
5328 ASPx.Evt.AttachEventToElement(link, "focus", function (e) { ASPx.UpdateFocusedState(e); });
5329 var clearFocusedStateHandler = function (e) { ASPx.ClearFocusedState(e); };
5330 ASPx.Evt.AttachEventToElement(link, "blur", clearFocusedStateHandler);
5331 if(clearFocusedStateOnMouseOut)
5332  ASPx.Evt.AttachEventToElement(link, "mouseout", clearFocusedStateHandler);
5333};
5334ASPx.Evt.AttachEventToDocument("mousemove", function(evt) {
5335 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
5336  aspxGetStateController().OnMouseMove(evt, true);
5337});
5338ASPx.Evt.AttachEventToDocument(ASPx.TouchUIHelper.touchMouseDownEventName, function(evt) {
5339 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
5340  aspxGetStateController().OnMouseDown(evt);
5341});
5342ASPx.Evt.AttachEventToDocument(ASPx.TouchUIHelper.touchMouseUpEventName, function(evt) {
5343 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
5344  aspxGetStateController().OnMouseUp(evt);
5345});
5346ASPx.Evt.AttachEventToDocument("mouseover", function(evt) {
5347 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
5348  aspxGetStateController().OnMouseOver(evt);
5349});
5350ASPx.Evt.AttachEventToDocument("keydown", function(evt) {
5351 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
5352  aspxGetStateController().OnKeyDown(evt);
5353});
5354ASPx.Evt.AttachEventToDocument("selectstart", function(evt) {
5355 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
5356  return aspxGetStateController().OnSelectStart(evt);
5357});
5358ASPx.GetStateController = aspxGetStateController;

5359ASPx.StateItem = ASPxStateItem;
5360})();
5361
5362},0);