https://nieee.org.ng/DXR.axd?r=1_183-lWBlp

1(function() {
2var ASPxClientEditBase = ASPx.CreateClass(ASPxClientControl, {
3 constructor: function(name) {
4  this.constructor.prototype.constructor.call(this, name);
5  this.EnabledChanged = new ASPxClientEvent();
6  this.captionPosition = ASPx.Position.Left;
7  this.showCaptionColon = true;
8  this.scPrefix = "dxe";
9 },
10 InlineInitialize: function(){
11  ASPxClientControl.prototype.InlineInitialize.call(this);
12  this.InitializeEnabled(); 
13  this.InitializeEvents();
14 },
15 InitializeEnabled: function() {
16  this.SetEnabledInternal(this.clientEnabled, true);
17 },
18 InitializeEvents: function() { },
19 AddDefaultReadOnlyStateControllerItem: function(cssClass, mainElementId) {
20  ASPx.AddReadOnlyItems(mainElementId, [[[cssClass], [''], ['']]]);
21 },
22 AddDefaultDisabledStateControllerItem: function(cssClass, mainElementId) {
23  ASPx.AddDisabledItems(mainElementId, [[[cssClass], [''], ['']]]);
24 },
25 GetValue: function() {
26  var element = this.GetMainElement();
27  if(ASPx.IsExistsElement(element))
28   return element.innerHTML;
29  return "";
30 },
31 GetValueString: function(){
32  var value = this.GetValue();
33  return (value == null) ? null : value.toString();
34 },
35 EnsureValueStringIsActual: function() {
36  if(this.maskInfo != null)
37   this.ParseValue();
38 },
39 SetValue: function(value) {
40  if(value == null)
41   value = "";
42  var element = this.GetMainElement();
43  if(ASPx.IsExistsElement(element))
44   element.innerHTML = value;
45 },
46 GetEnabled: function(){
47  return this.enabled && this.clientEnabled;
48 },
49 SetEnabled: function(enabled){
50  if(this.clientEnabled != enabled) {
51   var errorFrameRequiresUpdate = this.GetIsValid && !this.GetIsValid();
52   if(errorFrameRequiresUpdate && !enabled)
53    this.UpdateErrorFrameAndFocus(false , null , true );
54   this.clientEnabled = enabled;
55   this.SetEnabledInternal(enabled, false);
56   if(errorFrameRequiresUpdate && enabled)
57    this.UpdateErrorFrameAndFocus(false );
58   this.RaiseEnabledChangedEvent();
59  }
60 },
61 SetEnabledInternal: function(enabled, initialization){
62  if(!this.enabled) return;
63  if(!initialization || !enabled)
64   this.ChangeEnabledStateItems(enabled);
65  this.ChangeEnabledAttributes(enabled);
66  if(ASPx.Browser.Chrome) {   
67   var mainElement = this.GetMainElement();
68   if(mainElement)
69    mainElement.className = mainElement.className;
70  } 
71 },
72 ChangeEnabledAttributes: function(enabled){
73 },
74 ChangeEnabledStateItems: function(enabled){
75 },
76 RaiseEnabledChangedEvent: function(){
77  if(!this.EnabledChanged.IsEmpty()){
78   var args = new ASPxClientEventArgs();
79   this.EnabledChanged.FireEvent(this, args);
80  }
81 },
82 GetDecodeValue: function (value) { 
83  if(typeof (value) == "string" && value.length > 1)
84   value = this.SimpleDecodeHtml(value);
85  return value;
86 },
87 SimpleDecodeHtml: function (html) {
88  return ASPx.Str.ApplyReplacement(html, [
89   [/&lt;/g, '<'],
90   [/&amp;/g, '&'],
91   [/&quot;/g, '"'],
92   [/&#39;/g, '\''],
93   [/&#32;/g, ' ']
94  ]);
95 },
96 GetCachedElementById: function(idSuffix) {
97  return ASPx.CacheHelper.GetCachedElementById(this, this.name + idSuffix);
98 },
99 GetCaptionCell: function() {
100  return this.GetCachedElementById(EditElementSuffix.CaptionCell);
101 },
102 GetExternalTable: function() {
103  return this.GetCachedElementById(EditElementSuffix.ExternalTable);
104 },
105 getCaptionRelatedCellCount: function() {
106  if(!this.captionRelatedCellCount)
107   this.captionRelatedCellCount = ASPx.GetNodesByClassName(this.GetExternalTable(), CaptionRelatedCellClassName).length;
108  return this.captionRelatedCellCount;
109 },
110 addCssClassToCaptionRelatedCells: function() {
111  if(this.captionPosition == ASPx.Position.Left || this.captionPosition == ASPx.Position.Right) {
112   var captionRelatedCellsIndex = this.captionPosition == ASPx.Position.Left ? 0 : this.GetCaptionCell().cellIndex;
113   for(var i = 0; i < this.GetExternalTable().rows.length; i++)
114    ASPx.AddClassNameToElement(this.GetExternalTable().rows[i].cells[captionRelatedCellsIndex], CaptionRelatedCellClassName);
115  }
116  if(this.captionPosition == ASPx.Position.Top || this.captionPosition == ASPx.Position.Bottom)
117   for(var i = 0; i < this.GetCaptionCell().parentNode.cells.length; i++)
118    ASPx.AddClassNameToElement(this.GetCaptionCell().parentNode.cells[i], CaptionRelatedCellClassName);
119 },
120 GetCaption: function() {
121  if(ASPx.IsExists(this.GetCaptionCell()))
122   return this.getCaptionInternal();
123  return "";
124 },
125 SetCaption: function(caption) {
126  if(!ASPx.IsExists(this.GetCaptionCell()))
127   return;
128  if(this.getCaptionRelatedCellCount() == 0)
129   this.addCssClassToCaptionRelatedCells();

130  if(caption !== "")
131   ASPx.RemoveClassNameFromElement(this.GetExternalTable(), ASPxEditExternalTableClassNames.TableWithEmptyCaptionClassName);
132  else
133   ASPx.AddClassNameToElement(this.GetExternalTable(), ASPxEditExternalTableClassNames.TableWithEmptyCaptionClassName);
134  this.setCaptionInternal(caption);
135 },
136 getCaptionTextNode: function() {
137  var captionElement = ASPx.GetNodesByPartialClassName(this.GetCaptionCell(), CaptionElementPartialClassName)[0];
138  return ASPx.GetNormalizedTextNode(captionElement);
139 },
140 getCaptionInternal: function() {
141  var captionText = this.getCaptionTextNode().nodeValue;
142  if(captionText !== "" && captionText[captionText.length - 1] == ":")
143   captionText = captionText.substring(0, captionText.length - 1);
144  return captionText;
145 },
146 setCaptionInternal: function(caption) {
147  caption = ASPx.Str.Trim(caption);
148  var captionTextNode = this.getCaptionTextNode();
149  if(this.showCaptionColon && caption[caption.length - 1] != ":" && caption !== "")
150   caption += ":";
151  captionTextNode.nodeValue = caption;
152 },
153 onVirtualKeyboardUITouchStart: function(evt) { }
154});
155var ValidationPattern = ASPx.CreateClass(null, {
156 constructor: function(errorText) {
157  this.errorText = errorText;
158 }
159});
160var RequiredFieldValidationPattern = ASPx.CreateClass(ValidationPattern, {
161 constructor: function(errorText) {
162  this.constructor.prototype.constructor.call(this, errorText);
163 },
164 EvaluateIsValid: function(value) {
165  return value != null && (value.constructor == Array || ASPx.Str.Trim(value.toString()) != "");
166 }
167});
168var RegularExpressionValidationPattern = ASPx.CreateClass(ValidationPattern, {
169 constructor: function(errorText, pattern) {
170  this.constructor.prototype.constructor.call(this, errorText);
171  this.pattern = pattern;
172 },
173 EvaluateIsValid: function(value) {
174  if(value == null) 
175   return true;
176  var strValue = value.toString();
177  if(ASPx.Str.Trim(strValue).length == 0)
178   return true;
179  var regEx = new RegExp(this.pattern);
180  var matches = regEx.exec(strValue);
181  return matches != null && strValue == matches[0];
182 }
183});
184function _aspxIsEditorFocusable(inputElement) {
185 return ASPx.IsFocusableCore(inputElement, function(container) {
186  return container.getAttribute("errorFrame") == "errorFrame";
187 });
188}
189var invalidEditorToBeFocused = null;
190var ValidationType = {
191 PersonalOnValueChanged: "ValueChanged",
192 PersonalViaScript: "CalledViaScript",
193 MassValidation: "MassValidation"
194};
195var ErrorFrameDisplay = {
196 None: "None",
197 Static: "Static",
198 Dynamic: "Dynamic"
199};
200var EditElementSuffix = {
201 ExternalTable: "_ET",
202 ControlCell: "_CC",
203 ErrorCell: "_EC",
204 ErrorTextCell: "_ETC",
205 ErrorImage: "_EI",
206 CaptionCell: "_CapC",
207 AccessibilityAdditionalTextRow: "_AHTR"
208};
209var ASPxEditExternalTableClassNames = {
210 ValidStaticTableClassName: "dxeValidStEditorTable",
211 ValidDynamicTableClassName: "dxeValidDynEditorTable",
212 TableWithEmptyCaptionClassName: "tableWithEmptyCaption"
213};
214var CaptionRelatedCellClassName = "dxeCaptionRelatedCell";
215var CaptionElementPartialClassName = "dxeCaption";
216var AccessibilityAssistantID = "AcAs";
217var ASPxClientEdit = ASPx.CreateClass(ASPxClientEditBase, {
218 constructor: function(name) {
219  this.constructor.prototype.constructor.call(this, name);
220  this.isASPxClientEdit = true;
221  this.inputElement = null;
222  this.convertEmptyStringToNull = true;
223  this.readOnly = false;
224  this.clientReadOnly = false;
225  this.focused = false;
226  this.focusEventsLocked = false;
227  this.focusEventsLockCount = 0;
228  this.receiveGlobalMouseWheel = true;
229  this.styleDecoration = null;
230  this.heightCorrectionRequired = false;
231  this.customValidationEnabled = false;
232  this.display = ErrorFrameDisplay.Static;
233  this.initialErrorText = "";
234  this.causesValidation = false;
235  this.validateOnLeave = true;
236  this.validationGroup = "";
237  this.sendPostBackWithValidation = null;
238  this.validationPatterns = [];
239  this.setFocusOnError = false;
240  this.errorDisplayMode = "it";
241  this.errorText = "";
242  this.isValid = true;
243  this.errorImageIsAssigned = false;
244  this.notifyValidationSummariesToAcceptNewError = false;
245  this.isErrorFrameRequired = false;
246  this.enterProcessed = false;
247  this.keyDownHandlers = {};
248  this.keyPressHandlers = {};
249  this.keyUpHandlers = {};

250  this.onKeyDownHandler = null;
251  this.onKeyPressHandler = null;
252  this.onKeyUpHandler = null;
253  this.onGotFocusHandler = null;
254  this.onLostFocusHandler = null;
255  this.GotFocus = new ASPxClientEvent();
256  this.LostFocus = new ASPxClientEvent();
257  this.Validation = new ASPxClientEvent();
258  this.ValueChanged = new ASPxClientEvent();
259  this.KeyDown = new ASPxClientEvent();
260  this.KeyPress = new ASPxClientEvent();
261  this.KeyUp = new ASPxClientEvent();
262  this.eventHandlersInitialized = false;
263  this.errorCellVisibilityChanged = new ASPxClientEvent();
264  this.ariaExplanatoryTextManager = null;
265  this.InitializeEventHandlers();
266 },
267 SetData: function(data){
268  if(data.decorationStyles){
269   for(var i = 0; i < data.decorationStyles.length; i++)
270    this.AddDecorationStyle(data.decorationStyles[i].key, 
271     data.decorationStyles[i].className, 
272     data.decorationStyles[i].cssText);
273  }
274 },
275 Initialize: function() {
276  this.initialErrorText = this.errorText;
277  ASPxClientEditBase.prototype.Initialize.call(this);
278  this.InitializeKeyHandlers();
279  this.UpdateClientValidationState();
280  this.UpdateValidationSummaries(null , true );
281 },
282 InlineInitialize: function() {
283  if(this.UseDelayedSpecialFocus())
284   this.InitializeDelayedSpecialFocus();
285  ASPxClientEditBase.prototype.InlineInitialize.call(this);
286  this.UpdateStyleDecorations();
287  var externalTable = this.GetExternalTable();
288  if(externalTable && ASPx.IsPercentageSize(externalTable.style.width)) {
289   this.width = "100%";
290   this.GetMainElement().style.width = "100%";
291   if(this.isErrorFrameRequired)
292    externalTable.setAttribute("errorFrame", "errorFrame");
293  }
294  this.ariaExplanatoryTextManager = this.CreateAriaExplanatoryTextManager();
295  if(this.clientReadOnly)
296   this.SetReadOnlyInternal(true);
297  this.UpdateErrorCellParentRowVisibility();
298 }, 
299 AfterInitialize: function() {
300  this.ariaExplanatoryTextManager.SetCaptionAssociating();
301  this.ariaExplanatoryTextManager.UpdateText();
302  this.ariaExplanatoryTextManager.UpdateValidationState();
303  ASPxClientEditBase.prototype.AfterInitialize.call(this);
304 },
305 UpdateStyleDecorations: function() {
306  if(this.styleDecoration)
307   this.styleDecoration.Update();
308 },
309 UseSpecialKeyboardHandling: function() {
310  return false;
311 },
312 InitializeKeyHandlers: function() {
313 },
314 AddKeyDownHandler: function(key, handler) {
315  this.keyDownHandlers[key] = handler;
316 },
317 AddKeyPressHandler: function(key, handler) {
318  this.keyPressHandlers[key] = handler;
319 },
320 InitializeEventHandlers: function() {
321  this.onGotFocusHandler = function(evt) { ASPx.EGotFocus(this.name); }.bind(this);
322  this.onLostFocusHandler = function(evt) { ASPx.ELostFocus(this.name); }.bind(this);
323  if(this.UseSpecialKeyboardHandling()) {
324   this.onKeyDownHandler = function(evt) { ASPx.KBSIKeyDown(this.name, evt); }.bind(this);
325   this.onKeyPressHandler = function(evt) { ASPx.KBSIKeyPress(this.name, evt); }.bind(this);
326   this.onKeyUpHandler = function(evt) { ASPx.KBSIKeyUp(this.name, evt); }.bind(this);
327  }
328 },
329 ChangeSpecialInputEnabledAttributes: function(element, method, doNotChangeAutoComplete) {
330  if(!doNotChangeAutoComplete) 
331   element.autocomplete = "off";
332  if(this.onKeyDownHandler != null)
333   method(element, "keydown", this.onKeyDownHandler);
334  if(this.onKeyPressHandler != null)
335   method(element, "keypress", this.onKeyPressHandler);
336  if(this.onKeyUpHandler != null)
337   method(element, "keyup", this.onKeyUpHandler);
338  if(this.onGotFocusHandler != null)
339   method(element, "focus", this.onGotFocusHandler);
340  if(this.onLostFocusHandler != null)
341   method(element, "blur", this.onLostFocusHandler);
342 },
343 CreateAriaExplanatoryTextManager: function() {
344  if(this.accessibilityCompliant)
345   return new EditAccessibilityExplanatoryTextManager(this);
346  else 
347   return new DisableAccessibilityExplanatoryTextManager(this);
348 },
349 UpdateClientValidationState: function() {
350  if(!this.customValidationEnabled)
351   return;
352  var mainElement = this.GetMainElement();
353  if(mainElement) {
354   var validationState = !this.GetIsValid() ? ("-" + this.GetErrorText()) : "";
355   this.UpdateStateObjectWithObject({ validationState: validationState });
356  }
357 },

358 UpdateValidationSummaries: function(validationType, initializing) {
359  if(ASPx.Ident.scripts.ASPxClientValidationSummary) {
360   var summaryCollection = ASPx.GetClientValidationSummaryCollection();
361   summaryCollection.OnEditorIsValidStateChanged(this, validationType, initializing && this.notifyValidationSummariesToAcceptNewError);
362  }
363 },
364 FindInputElement: function(){
365  return null;
366 },
367 GetInputElement: function(){
368  if(!ASPx.IsExistsElement(this.inputElement))
369   this.inputElement = this.FindInputElement();
370  return this.inputElement;
371 },
372 GetFocusableInputElement: function() {
373  return this.GetInputElement();
374 },
375 GetAccessibilityActiveElements: function() {
376  return [this.GetInputElement()];
377 },
378 GetAccessibilityFirstActiveElement: function() {
379  return this.accessibilityHelper ? 
380    this.accessibilityHelper.getMainElement() : 
381    this.GetAccessibilityActiveElements()[0];
382 },
383 GetAccessibilityAssistantElement: function() {
384  return this.GetChildElement(AccessibilityAssistantID);
385 },
386 GetErrorImage: function() {
387  return this.GetCachedElementById(EditElementSuffix.ErrorImage);
388 },
389 GetControlCell: function() {
390  return this.GetCachedElementById(EditElementSuffix.ControlCell);
391 },
392 GetErrorCell: function() {
393  return this.GetCachedElementById(EditElementSuffix.ErrorCell);
394 },
395 GetErrorTextCell: function() {
396  return this.GetCachedElementById(this.errorImageIsAssigned ? EditElementSuffix.ErrorTextCell : EditElementSuffix.ErrorCell);
397 },
398 GetReadOnly: function() {
399  return this.readOnly || this.clientReadOnly;
400 },
401 SetReadOnly: function(readOnly) {
402  readOnly = !!readOnly;
403  if(this.clientReadOnly === readOnly || this.readOnly)
404   return;
405  this.SetReadOnlyInternal(readOnly);
406 },
407 SetReadOnlyInternal: function(readOnly) {
408  this.clientReadOnly = readOnly;
409  this.ChangeReadOnlyStateItems(readOnly);
410 },
411 ChangeReadOnlyStateItems: function(readOnly) {
412  ASPx.GetStateController().SetElementReadOnly(this.GetMainElement(), readOnly);
413 },
414 SetVisible: function (isVisible) {
415  if(this.clientVisible == isVisible)
416   return;
417  var externalTable = this.GetExternalTable();
418  if(externalTable) {
419   ASPx.SetElementDisplay(externalTable, isVisible);
420   if(this.customValidationEnabled) {
421    var isValid = !isVisible ? true : void (0);
422    this.UpdateErrorFrameAndFocus(false , true , isValid );
423   }
424  }
425  ASPxClientControl.prototype.SetVisible.call(this, isVisible);
426 },
427 GetStateHiddenFieldName: function() {
428  return this.uniqueID + "$State";
429 },
430 GetValueInputToValidate: function() {
431  return this.GetInputElement();
432 },
433 IsVisible: function() {
434  if(!this.clientVisible)
435   return false;
436  var element = this.GetMainElement();
437  if(!element) 
438   return false;
439  while(element && element.tagName != "BODY") {
440   if(element.getAttribute("errorFrame") != "errorFrame" && (!ASPx.GetElementVisibility(element) || !ASPx.GetElementDisplay(element)))
441    return false;
442   element = element.parentNode;
443  }
444  return true;
445 },
446 AdjustControlCore: function() {
447  this.CollapseEditor();
448  this.UnstretchInputElement();
449  if(this.heightCorrectionRequired)
450   this.CorrectEditorHeight();
451 },
452 CorrectEditorHeight: function() {
453 },
454 UnstretchInputElement: function() {
455 },
456 UseDelayedSpecialFocus: function() {
457  return false;
458 },
459 GetInnerEditors: function() {
460  return [];
461 },
462 GetDelayedSpecialFocusTriggers: function() {
463  return [ this.GetMainElement() ];
464 },
465 InitializeDelayedSpecialFocus: function() {
466  this.specialFocusTimer = -1;    
467  var handler = function(evt) { this.OnDelayedSpecialFocusMouseDown(evt); }.aspxBind(this);
468  var triggers = this.GetDelayedSpecialFocusTriggers();
469  for(var i = 0; i < triggers.length; i++)
470   ASPx.Evt.AttachEventToElement(triggers[i], "mousedown", handler);
471 },
472 OnDelayedSpecialFocusMouseDown: function(evt) {
473  window.setTimeout(function() { this.SetFocus(); }.aspxBind(this), 0);
474 },
475 IsFocusEventsLocked: function() {
476  return this.focusEventsLocked || this.focusEventsLockCount !== 0;
477 },
478 BeginFocusUpdate: function() {
479  this.focusEventsLockCount++;
480 },
481 EndFocusUpdate: function() {
482  this.focusEventsLockCount--;
483  if(this.focusEventsLockCount === 0)
484   if(this.focused && !this.IsEditorElement(document.activeElement)) 
485    this.OnLostFocus();
486 },
487 LockFocusEvents: function() {
488  if(!this.focused) return;
489  this.focusEventsLocked = true;
490 },
491 UnlockFocusEvents: function() {
492  this.focusEventsLocked = false;
493 },
494 ForceRefocusEditor: function(evt, isNativeFocus) {
495  if(ASPx.Browser.VirtualKeyboardSupported && !this.ownerListBox) {
496   var focusedEditor = ASPx.VirtualKeyboardUI.getFocusedEditor();
497   if(ASPx.VirtualKeyboardUI.getInputNativeFocusLocked() && (!focusedEditor || focusedEditor === this))
498     return;
499   ASPx.VirtualKeyboardUI.setInputNativeFocusLocked(!isNativeFocus);
500  }

501  this.LockFocusEvents();
502  this.BlurInputElement();
503  window.setTimeout(function() { 
504   if(ASPx.Browser.VirtualKeyboardSupported && !this.ownerListBox) {
505    ASPx.VirtualKeyboardUI.setFocusToEditor(this);
506   } else {
507    this.SetFocus();
508   }
509  }.aspxBind(this), 0);
510 },
511 BlurInputElement: function() {
512  var inputElement = this.GetFocusableInputElement();
513  if(inputElement && inputElement.blur)
514   inputElement.blur();
515 },
516 IsEditorElement: function(element) {
517  return this.GetMainElement() == element || ASPx.GetIsParent(this.GetMainElement(), element);
518 },
519 IsClearButtonElement: function(element) {
520  return false;
521 },
522 IsElementBelongToInputElement: function(element) {
523  return this.GetInputElement() == element;
524 },
525 OnFocusCore: function() {
526  if(this.UseDelayedSpecialFocus())
527   this.specialFocusTimer = ASPx.Timer.ClearTimer(this.specialFocusTimer);
528  if(!this.IsFocusEventsLocked()){
529   this.focused = true;
530   ASPx.SetFocusedEditor(this);
531   if(this.styleDecoration)
532    this.styleDecoration.Update();
533   if(this.isInitialized)
534    this.RaiseFocus();
535  }
536  else
537   this.UnlockFocusEvents();
538 },
539 OnLostFocusCore: function() {
540  if(!this.IsFocusEventsLocked()){
541   this.focused = false;
542   if(ASPx.GetFocusedEditor() === this)
543    ASPx.SetFocusedEditor(null);
544   if(this.styleDecoration)
545    this.styleDecoration.Update();
546   this.RaiseLostFocus();
547  }
548 },
549 OnFocus: function() {
550  var focusedEditor = ASPx.GetFocusedEditor();
551  if(focusedEditor && focusedEditor.UseDelayedSpecialFocus() && focusedEditor !== this && focusedEditor.GetInnerEditors().indexOf(this) === -1 && ASPx.IsElementVisible(focusedEditor.GetMainElement())) {
552   var lostFocusHandler = function() {
553    focusedEditor.LostFocus.RemoveHandler(lostFocusHandler);
554    this.OnFocusCore();
555   }.bind(this);
556   focusedEditor.LostFocus.AddHandler(lostFocusHandler);
557  }
558  else {
559   this.OnFocusCore();
560  }  
561 },
562 OnLostFocus: function() {
563  if(this.isInitialized)
564   this.OnLostFocusCore();
565 },
566 OnMouseWheel: function(evt){
567 },
568 OnValidation: function(validationType) {
569  if(this.customValidationEnabled && this.isInitialized && ASPx.IsExistsElement(this.GetMainElement()) &&
570   (!this.IsErrorFrameDisplayed() || this.GetElementRequiredForErrorFrame())) {
571   this.BeginErrorFrameUpdate();
572   try {
573    if(this.validateOnLeave || validationType != ValidationType.PersonalOnValueChanged) {
574     this.SetIsValid(true, true );
575     this.SetErrorText(this.initialErrorText, true );
576     this.ValidateWithPatterns();
577     this.RaiseValidation();
578    }
579    this.UpdateErrorFrameAndFocus(this.editorFocusingRequired(validationType));
580   } finally {
581    this.EndErrorFrameUpdate();
582   }
583   this.UpdateValidationSummaries(validationType);
584   this.ariaExplanatoryTextManager.UpdateValidationState(validationType);
585  }
586 },
587 GetElementRequiredForErrorFrame: function() {
588  return this.GetExternalTable();
589 },
590 editorFocusingRequired: function(validationType) {
591  return !this.GetIsValid() &&
592   validationType == ValidationType.PersonalViaScript && this.setFocusOnError;
593 },
594 OnValueChanged: function() {
595  if(this.getProcessOnServerOnValueChanged())
596   this.SendPostBackInternal("");
597 },
598 getProcessOnServerOnValueChanged: function() {
599  var processOnServer = this.RaiseValidationInternal();
600  return this.RaiseValueChangedEvent() && processOnServer;
601 },
602 ParseValue: function() {
603 },
604 RaisePersonalStandardValidation: function() {
605  if(ASPx.IsFunction(window.ValidatorOnChange)) {
606   var inputElement = this.GetValueInputToValidate();
607   if(inputElement && inputElement.Validators)
608    window.ValidatorOnChange({ srcElement: inputElement });
609  }
610 },
611 RaiseValidationInternal: function() {
612  if(this.isPostBackAllowed() && this.causesValidation && this.validateOnLeave)
613   return ASPxClientEdit.ValidateGroup(this.validationGroup);
614  else {
615   this.OnValidation(ValidationType.PersonalOnValueChanged);
616   return this.GetIsValid();
617  }
618 },
619 RaiseValueChangedEvent: function(){
620  return this.RaiseValueChanged();
621 },
622 SendPostBackInternal: function(postBackArg) {
623  if(ASPx.IsFunction(this.sendPostBackWithValidation))
624   this.sendPostBackWithValidation(postBackArg);
625  else
626   this.SendPostBack(postBackArg);
627 },
628 SetElementToBeFocused: function() {
629  if(this.IsVisible())
630   invalidEditorToBeFocused = this;
631 },
632 GetFocusSelectAction: function() {
633  return null;
634 },
635 SetFocus: function() {
636  var inputElement = this.GetFocusableInputElement();
637  if(!inputElement) return; 
638  if((ASPx.GetActiveElement() != inputElement) && _aspxIsEditorFocusable(inputElement))
639   ASPx.SetFocus(inputElement, this.GetFocusSelectAction());
640 },
641 SetFocusOnError: function() {
642  if(invalidEditorToBeFocused == this) {
643   this.SetFocus();
644   invalidEditorToBeFocused = null;
645  }
646 },
647 BeginErrorFrameUpdate: function() {
648  if(!this.errorFrameUpdateLocked)
649   this.errorFrameUpdateLocked = true;
650 },
651 EndErrorFrameUpdate: function() {
652  this.errorFrameUpdateLocked = false;
653  var args = this.updateErrorFrameAndFocusLastCallArgs;
654  if(args) {
655   this.UpdateErrorFrameAndFocus(args[0], args[1]);
656   delete this.updateErrorFrameAndFocusLastCallArgs;
657  }
658 },
659 UpdateErrorFrameAndFocus: function(setFocusOnError, ignoreVisibilityCheck, isValid) {
660  if(!ignoreVisibilityCheck && !this.GetVisible())
661   return;
662  if(this.errorFrameUpdateLocked) {
663   this.updateErrorFrameAndFocusLastCallArgs = [ setFocusOnError, ignoreVisibilityCheck ];
664   return;
665  }
666  if(this.styleDecoration)
667   this.styleDecoration.Update();
668  if(typeof(isValid) == "undefined")
669   isValid = this.GetIsValid();
670  if(isValid && this.IsErrorFrameDisplayed())
671   this.ChangeErrorFrameVisibility(false);
672  else {
673   var editorLocatedWithinVisibleContainer = this.IsVisible();
674   if(this.IsErrorFrameDisplayed()) {
675    this.UpdateErrorCellContent();
676    this.ChangeErrorFrameVisibility(true);
677   }
678   if(editorLocatedWithinVisibleContainer) {
679    if(setFocusOnError && this.setFocusOnError && invalidEditorToBeFocused == null) {
680     this.SetElementToBeFocused();
681     this.SetFocusOnError();
682    }
683   }
684  }
685 },
686 ChangeErrorFrameVisibility: function(visible) {
687  var externalTable = this.GetExternalTable();
688  var isStaticDisplay = this.display == ErrorFrameDisplay.Static;
689  if(!isStaticDisplay && visible) {
690   this.EnsureControlCellStylesLoaded();
691   this.RestoreControlCellStyles();
692  }
693  this.ChangeErrorCellVisibility(visible, isStaticDisplay);
694  if(!isStaticDisplay && !visible) {
695   this.EnsureControlCellStylesLoaded();
696   this.ClearControlCellStyles();
697  }

698  var validExternalTableClassName = isStaticDisplay ? ASPxEditExternalTableClassNames.ValidStaticTableClassName
699   : ASPxEditExternalTableClassNames.ValidDynamicTableClassName;
700  ASPx.ToggleClassNameToElement(externalTable, validExternalTableClassName, !visible);
701  this.UpdateErrorCellParentRowVisibility();
702 },
703 ChangeErrorCellVisibility: function(visible, useVisibilityAttribute) {
704  var errorCell = this.GetErrorCell();
705  if(errorCell) {
706   if(useVisibilityAttribute)
707    ASPx.SetElementVisibility(errorCell, visible);
708   else {
709    ASPx.SetElementDisplay(errorCell, visible);
710    this.raiseErrorCellVisibilityChanged();
711   }
712  }
713 },
714 raiseErrorCellVisibilityChanged: function() {
715  if(!this.errorCellVisibilityChanged.IsEmpty())
716   this.errorCellVisibilityChanged.FireEvent(this);
717 },
718 UpdateErrorCellParentRowVisibility: function() {
719  var errorCell = this.GetErrorCell();
720  if(!errorCell || this.display == ErrorFrameDisplay.Static)
721   return;
722  var displayedCellCount = 0;
723  var errorCellParentRow = errorCell.parentNode;
724  for(var i = 0; i < errorCellParentRow.cells.length; i++) {
725   var cell = errorCellParentRow.cells[i];
726   if(ASPx.GetElementDisplay(cell))
727    displayedCellCount++;
728  }
729  ASPx.SetElementDisplay(errorCellParentRow, displayedCellCount > 0);
730 },
731 EnsureControlCellStylesLoaded: function() {
732  if(typeof(this.controlCellStyles) == "undefined") {
733   var controlCell = this.GetControlCell();
734   this.controlCellStyles = {
735    cssClass: controlCell.className,

736    style: this.ExtractElementStyleStringIgnoringVisibilityProps(controlCell)
737   };
738  }
739 },
740 ClearControlCellStyles: function() {
741  this.ClearElementStyle(this.GetControlCell());
742 },
743 RestoreControlCellStyles: function() {
744  var controlCell = this.GetControlCell();
745  controlCell.className = this.controlCellStyles.cssClass;
746  controlCell.style.cssText = this.controlCellStyles.style;
747 },
748 ExtractElementStyleStringIgnoringVisibilityProps: function(element) {
749  var savedVisibility = element.style.visibility;
750  var savedDisplay = element.style.display;
751  element.style.visibility = "";
752  element.style.display = "";
753  var styleStr = element.style.cssText;
754  element.style.visibility = savedVisibility;
755  element.style.display = savedDisplay;
756  return styleStr;
757 },
758 ClearElementStyle: function(element) {
759  if(!element)
760   return;
761  element.className = "";
762  var excludedAttrNames = [
763   "width", "display", "visibility",
764   "position", "left", "top", "z-index",
765   "margin", "margin-top", "margin-right", "margin-bottom", "margin-left",
766   "float", "clear"
767  ];
768  var savedAttrValues = { };
769  for(var i = 0; i < excludedAttrNames.length; i++) {
770   var attrName = excludedAttrNames[i];
771   var attrValue = element.style[attrName];
772   if(attrValue)
773    savedAttrValues[attrName] = attrValue;
774  }
775  element.style.cssText = "";
776  for(var styleAttrName in savedAttrValues)
777   if(savedAttrValues.hasOwnProperty(styleAttrName))
778    element.style[styleAttrName] = savedAttrValues[styleAttrName];
779 },
780 Clear: function() {
781  this.SetValue(null);
782  this.SetIsValid(true);
783  return true;
784 },
785 ResetEditorState: function() { },
786 UpdateErrorCellContent: function() {
787  if(this.errorDisplayMode.indexOf("t") > -1)
788   this.UpdateErrorText();
789  if(this.errorDisplayMode == "i")
790   this.UpdateErrorImage();
791 },
792 UpdateErrorImage: function() {
793  var image = this.GetErrorImage();
794  if(ASPx.IsExistsElement(image)) {
795   if(this.accessibilityCompliant) {
796    ASPx.Attr.SetAttribute(image, "aria-label", this.errorText);
797    var innerImg = ASPx.GetNodeByTagName(image, "IMG", 0);
798    if(ASPx.IsExists(innerImg))
799     innerImg.alt = this.errorText;
800   }
801   image.alt = this.errorText;
802   image.title = this.errorText;
803  } else {
804   this.UpdateErrorText();
805  }
806 },
807 UpdateErrorText: function() {
808  var errorTextCell = this.GetErrorTextCell();
809  if(ASPx.IsExistsElement(errorTextCell))
810   errorTextCell.innerHTML = this.HtmlEncode(this.errorText);
811 },
812 ValidateWithPatterns: function() {
813  if(this.validationPatterns.length > 0) {
814   var value = this.GetValue();
815   for(var i = 0; i < this.validationPatterns.length; i++) {
816    var validator = this.validationPatterns[i];
817    if(!validator.EvaluateIsValid(value)) {
818     this.SetIsValid(false, true );
819     this.SetErrorText(validator.errorText, true );
820     return;
821    }
822   }
823  }
824 },
825 OnSpecialKeyDown: function(evt){
826  this.RaiseKeyDown(evt);
827  var handler = this.keyDownHandlers[evt.keyCode];
828  if(handler) 
829   return this[handler](evt);
830  return false;
831 },
832 OnSpecialKeyPress: function(evt){
833  this.RaiseKeyPress(evt);
834  var handler = this.keyPressHandlers[evt.keyCode];
835  if(handler) 
836   return this[handler](evt);
837  if(ASPx.Browser.NetscapeFamily || ASPx.Browser.Opera){
838   if(evt.keyCode == ASPx.Key.Enter)
839    return this.enterProcessed;
840  }
841  return false;
842 },
843 OnSpecialKeyUp: function(evt){
844  this.RaiseKeyUp(evt);
845  var handler = this.keyUpHandlers[evt.keyCode];
846  if(handler) 
847   return this[handler](evt);
848  return false;
849 },
850 OnKeyDown: function(evt) {
851  if(!this.UseSpecialKeyboardHandling())
852   this.RaiseKeyDown(evt);
853 },
854 OnKeyPress: function(evt) {
855  if(!this.UseSpecialKeyboardHandling())
856   this.RaiseKeyPress(evt);
857 },
858 OnKeyUp: function(evt) {
859  if(!this.UseSpecialKeyboardHandling())
860   this.RaiseKeyUp(evt);
861 },
862 RaiseKeyDown: function(evt){
863  if(!this.KeyDown.IsEmpty()){
864   var args = new ASPxClientEditKeyEventArgs(evt);
865   this.KeyDown.FireEvent(this, args);
866  }
867 },
868 RaiseKeyPress: function(evt){
869  if(!this.KeyPress.IsEmpty()){
870   var args = new ASPxClientEditKeyEventArgs(evt);
871   this.KeyPress.FireEvent(this, args);
872  }
873 },
874 RaiseKeyUp: function(evt){
875  if(!this.KeyUp.IsEmpty()){
876   var args = new ASPxClientEditKeyEventArgs(evt);
877   this.KeyUp.FireEvent(this, args);
878  }
879 },
880 RaiseFocus: function(){
881  if(!this.GotFocus.IsEmpty()){
882   var args = new ASPxClientEventArgs();
883   this.GotFocus.FireEvent(this, args);
884  }
885 },
886 RaiseLostFocus: function(){
887  if(!this.LostFocus.IsEmpty()){
888   var args = new ASPxClientEventArgs();
889   this.LostFocus.FireEvent(this, args);
890  }
891 },
892 RaiseValidation: function() {
893  if(this.customValidationEnabled && !this.Validation.IsEmpty()) {
894   var currentValue = this.GetValue();
895   var args = new ASPxClientEditValidationEventArgs(currentValue, this.errorText, this.GetIsValid());
896   this.Validation.FireEvent(this, args);
897   this.SetErrorText(args.errorText, true );
898   this.SetIsValid(args.isValid, true );
899   if(args.value != currentValue)
900    this.SetValue(args.value);
901  }
902 },
903 RaiseValueChanged: function(){
904  var processOnServer = this.isPostBackAllowed();
905  if(!this.ValueChanged.IsEmpty()){
906   var args = new ASPxClientProcessingModeEventArgs(processOnServer);
907   this.ValueChanged.FireEvent(this, args);
908   processOnServer = args.processOnServer;
909  }
910  return processOnServer;  
911 },
912 isPostBackAllowed: function() {
913  return this.autoPostBack;
914 },
915 AddDecorationStyle: function(key, className, cssText) {
916  if(!this.styleDecoration) 
917   this.RequireStyleDecoration();
918  this.styleDecoration.AddStyle(key, className, cssText);
919 }, 
920 RequireStyleDecoration: function() {
921  this.styleDecoration = this.CreateStyleDecoration();
922  this.PopulateStyleDecorationPostfixes();
923 },
924 CreateStyleDecoration: function() {
925  return new ASPx.EditorStyleDecoration(this);
926 },
927 PopulateStyleDecorationPostfixes: function() {
928  this.styleDecoration.AddPostfix("");
929 },
930 LockStyleDecorationUpdate: function() {
931  if(this.styleDecoration)
932   this.styleDecoration.LockUpdate();
933 },
934 UnlockStyleDecorationUpdate: function() {
935  if(this.styleDecoration)
936   this.styleDecoration.UnlockUpdate();
937 },
938 Focus: function(){
939  this.SetFocus();
940 },
941 GetIsValid: function() {
942  var hasRequiredInputElement = !this.RequireInputElementToValidate() || ASPx.IsExistsElement(this.GetInputElement());
943  if(!hasRequiredInputElement || this.IsErrorFrameDisplayed() && !ASPx.IsExistsElement(this.GetElementRequiredForErrorFrame()))
944   return true;
945  return this.isValid;
946 },
947 RequireInputElementToValidate: function() {
948  return true;
949 },
950 IsErrorFrameDisplayed: function() {
951  return this.display !== ErrorFrameDisplay.None;
952 },
953 GetErrorText: function(){
954  return this.errorText;
955 },
956 SetIsValid: function(isValid, validating){
957  if(this.customValidationEnabled && this.isValid != isValid) {
958   this.isValid = isValid;
959   this.UpdateErrorFrameAndFocus(false );

960   this.UpdateClientValidationState();
961   if(!validating)
962    this.UpdateValidationSummaries(ValidationType.PersonalViaScript);
963  }
964 },
965 SetErrorText: function(errorText, validating){
966  if(this.customValidationEnabled && this.errorText != errorText) {
967   this.errorText = errorText;
968   this.UpdateErrorFrameAndFocus(false );
969   this.UpdateClientValidationState();
970   if(!validating)
971    this.UpdateValidationSummaries(ValidationType.PersonalViaScript);
972  }
973 },
974 Validate: function(){
975  this.ParseValue();
976  this.OnValidation(ValidationType.PersonalViaScript);
977 },
978 GetModifyEvent: function() {
979  return this.ValueChanged;
980 },
981 EnsureRequiredNativeAttributesExists: function() { }
982});
983ASPx.Ident.scripts.ASPxClientEdit = true;
984ASPx.focusedEditorName = "";
985ASPx.GetFocusedEditor = function() {
986 var focusedEditor = ASPx.GetControlCollection().Get(ASPx.focusedEditorName);
987 if(focusedEditor && !focusedEditor.focused){
988  ASPx.SetFocusedEditor(null);
989  focusedEditor = null;
990 }
991 return focusedEditor;
992};
993ASPx.SetFocusedEditor = function(editor) {
994 ASPx.focusedEditorName = editor ? editor.name : "";
995};
996ASPx.FindAssociatedLabelElements = function(editor) {
997 var assocciatedLabels = [];
998 var inputElement = editor.GetInputElement();
999 if(!ASPx.IsExists(inputElement) || !inputElement.id) 
1000  return assocciatedLabels;
1001 var labels = ASPx.GetNodesByTagName(document, "LABEL");
1002 for(var i = 0; i < labels.length; i++) {
1003  if(!!labels[i].htmlFor && labels[i].htmlFor === inputElement.id)
1004   assocciatedLabels.push(labels[i]);
1005 }
1006 return assocciatedLabels;
1007};
1008var DisableAccessibilityExplanatoryTextManager = ASPx.CreateClass(null, {
1009 constructor: function(editor) {
1010  this.editor = editor;
1011 },
1012 GetAdditionalTextRowId: function() {
1013  return this.editor.name + EditElementSuffix.AccessibilityAdditionalTextRow;
1014 },
1015 GetErrorTextElement: function () {
1016  return !!this.editor.GetErrorTextCell() ? this.editor.GetErrorTextCell() : this.editor.GetErrorImage();
1017 },
1018 GetTextElement: function() { return null; },
1019 SetCaptionAssociating: function() { },
1020 UpdateText: function() { },
1021 UpdateValidationState: function(validationType) { },
1022 ToggleErrorAlert: function() { },
1023 SetOrRemoveText: function(accessibilityElements, textElement, setText, isLabel, isFirst) { }
1024});
1025var EditAccessibilityExplanatoryTextManager = ASPx.CreateClass(DisableAccessibilityExplanatoryTextManager, {
1026 constructor: function(editor) {
1027  this.constructor.prototype.constructor.call(this, editor);
1028  this.invisibleRowCssClassName = "dxAIR";
1029 },
1030 GetTextElement: function() {
1031  var mainElement = this.editor.GetMainElement();
1032  if(!mainElement) return null;
1033  var explanatoryText = "";
1034  var explanatoryTextElement = null;
1035  if(!!this.editor.nullText)
1036   explanatoryText = this.editor.nullText;
1037  else if(!!this.editor.helpTextObj)
1038   explanatoryTextElement = this.editor.helpTextObj.helpTextElement;
1039  else if(!!mainElement.title)
1040   explanatoryText = mainElement.title;
1041  if(explanatoryText && mainElement.tagName == "TABLE") {
1042   var assistantElement = this.editor.GetAccessibilityFirstActiveElement();
1043   if(assistantElement)
1044    ASPx.Attr.Aria.AppendLabel(assistantElement, explanatoryText, true);
1045  }
1046  return explanatoryTextElement;
1047 },
1048 SetCaptionAssociating: function() {
1049  var captionCell = this.editor.GetCaptionCell();
1050  if(!captionCell || captionCell.childNodes[0].tagName == "LABEL") return;
1051  var labelElement = captionCell.childNodes[0];
1052  ASPx.EditAccessibilityExplanatoryTextManager.SetLabelAssociating(this.editor, this.editor.GetAccessibilityFirstActiveElement(), labelElement);
1053 },
1054 UpdateText: function() {
1055  var additionalTextElement = this.GetTextElement();
1056  if(ASPx.IsExists(additionalTextElement)) {
1057   var pronounceElement = this.editor.GetAccessibilityFirstActiveElement();
1058   var hasAnyLabel = !!ASPx.Attr.GetAttribute(pronounceElement, "aria-label") || 
1059    !!ASPx.Attr.GetAttribute(pronounceElement, "aria-labelledby") ||
1060    ASPx.FindAssociatedLabelElements(this.editor).length > 0;
1061   this.SetOrRemoveText([pronounceElement], additionalTextElement, true, !hasAnyLabel, false);
1062  }
1063 },

1064 UpdateValidationState: function(validationType) {
1065  if(validationType == ValidationType.PersonalOnValueChanged && this.editor.accessibilityHelper) return;
1066  var accessibilityElements = this.editor.GetAccessibilityActiveElements();
1067  var errorTextElement = this.GetErrorTextElement();
1068  this.SetOrRemoveText(accessibilityElements, errorTextElement, !this.editor.isValid, false, true);
1069  if(accessibilityElements.length > 0 && !!errorTextElement) {
1070   for(var i = 0; i < accessibilityElements.length; i++) {
1071    if(!ASPx.IsExists(accessibilityElements[i])) continue;
1072    ASPx.Attr.SetOrRemoveAttribute(accessibilityElements[i], "aria-invalid", !this.editor.isValid);
1073   }
1074  }
1075 },
1076 ToggleErrorAlert: function() {
1077  var errorTextElement = this.GetErrorTextElement();
1078  ASPx.SetElementDisplay(errorTextElement, false);
1079  ASPx.Attr.SetAttribute(errorTextElement, 'role', 'alert');
1080  ASPx.SetElementDisplay(errorTextElement, true);
1081  setTimeout(function() { ASPx.Attr.RemoveAttribute(errorTextElement, 'role'); }, 500);
1082 },
1083 SetOrRemoveText: function(accessibilityElements, textElement, setText, isLabel, isFirst) {
1084  var idsRefAttribute = isLabel ? ASPx.Attr.Aria.labelled : ASPx.Attr.Aria.described;
1085  if(!textElement) return;
1086  var textId = !!textElement.id ? textElement.id : textElement.parentNode.id;
1087  for(var i = 0; i < accessibilityElements.length; i++) {
1088   if(!accessibilityElements[i]) continue;
1089   var descRefString = ASPx.Attr.GetAttribute(accessibilityElements[i], idsRefAttribute);
1090   var descRefIds = !!descRefString ? descRefString.split(" ") : [ ];
1091   var descIndex = descRefIds.indexOf(textId);
1092   if(setText && descIndex == -1) {
1093    if(isFirst)
1094     descRefIds.unshift(textId);
1095    else
1096     descRefIds.push(textId);
1097   }
1098   else if(!setText && descIndex > -1)
1099    descRefIds.splice(descIndex, 1);
1100   ASPx.Attr.SetOrRemoveAttribute(accessibilityElements[i], idsRefAttribute, descRefIds.join(" "));
1101  }
1102 }
1103});
1104ASPx.DisableAccessibilityExplanatoryTextManager = DisableAccessibilityExplanatoryTextManager;
1105ASPx.EditAccessibilityExplanatoryTextManager = EditAccessibilityExplanatoryTextManager;
1106ASPx.EditAccessibilityExplanatoryTextManager.SetLabelAssociating = function(editor, activeElement, labelElement) {
1107 var clickHandler = function(evt) {
1108  if(editor && editor.OnAssociatedLabelClick)
1109   editor.OnAssociatedLabelClick(evt);
1110  else
1111   activeElement.click();
1112 };
1113 ASPx.Evt.AttachEventToElement(labelElement, "click", clickHandler);
1114 if(!!editor) {
1115  var hasAriaLabel = !!ASPx.Attr.GetAttribute(activeElement, "aria-label");
1116  editor.ariaExplanatoryTextManager.SetOrRemoveText([activeElement], labelElement, true, !hasAriaLabel, true);
1117 }
1118};
1119ASPxClientEdit.ClearEditorsInContainer = function(container, validationGroup, clearInvisibleEditors) {
1120 invalidEditorToBeFocused = null;
1121 ASPx.ProcessEditorsInContainer(container, ASPx.ClearProcessingProc, ASPx.ClearChoiceCondition, validationGroup, clearInvisibleEditors, true );
1122 ASPxClientEdit.ClearExternalControlsInContainer(container, validationGroup, clearInvisibleEditors, true );
1123};
1124ASPxClientEdit.ClearEditorsInContainerById = function(containerId, validationGroup, clearInvisibleEditors) {
1125 var container = document.getElementById(containerId);
1126 this.ClearEditorsInContainer(container, validationGroup, clearInvisibleEditors);
1127};
1128ASPxClientEdit.ClearGroup = function(validationGroup, clearInvisibleEditors) {
1129 return this.ClearEditorsInContainer(null, validationGroup, clearInvisibleEditors);
1130};
1131ASPxClientEdit.ValidateEditorsInContainer = function(container, validationGroup, validateInvisibleEditors) {
1132 var summaryCollection;
1133 if(ASPx.Ident.scripts.ASPxClientValidationSummary) {
1134  summaryCollection = ASPx.GetClientValidationSummaryCollection();
1135  summaryCollection.AllowNewErrorsAccepting(validationGroup);
1136 }
1137 var validationResult = ASPx.ProcessEditorsInContainer(container, ASPx.ValidateProcessingProc, _aspxValidateChoiceCondition, validationGroup, validateInvisibleEditors,
1138  false );
1139 validationResult.isValid = ASPxClientEdit.ValidateExternalControlsInContainer(container, validationGroup, validateInvisibleEditors,
1140  false ) && validationResult.isValid;
1141 if(typeof(validateInvisibleEditors) == "undefined")
1142  validateInvisibleEditors = false;
1143 if(typeof(validationGroup) == "undefined")
1144  validationGroup = null;    
1145 validationResult.isValid = ASPx.GetControlCollection().RaiseValidationCompleted(container, validationGroup,
1146 validateInvisibleEditors, validationResult.isValid, validationResult.firstInvalid, validationResult.firstVisibleInvalid);
1147 if(summaryCollection)
1148  summaryCollection.ForbidNewErrorsAccepting(validationGroup);
1149 if(!validationResult.isValid && !!validationResult.firstVisibleInvalid && validationResult.firstVisibleInvalid.accessibilityCompliant && !validationResult.firstVisibleInvalid.setFocusOnError) {
1150  var accessInvalidControl = validationResult.firstVisibleInvalid;
1151  if(!summaryCollection && !accessInvalidControl.focused) {
1152   var beforeDelayActiveElement = ASPx.GetActiveElement();
1153   setTimeout(function() {
1154    var currentActiveElement = ASPx.GetActiveElement();
1155    if(accessInvalidControl.focused || (currentActiveElement != beforeDelayActiveElement && ASPx.Attr.IsExistsAttribute(currentActiveElement, 'role')))
1156     return;
1157    accessInvalidControl.ariaExplanatoryTextManager.ToggleErrorAlert();
1158   }, 500);    
1159  }
1160 }
1161 return validationResult.isValid;
1162};
1163ASPxClientEdit.ValidateEditorsInContainerById = function(containerId, validationGroup, validateInvisibleEditors) {
1164 var container = document.getElementById(containerId);
1165 return this.ValidateEditorsInContainer(container, validationGroup, validateInvisibleEditors);
1166};

1167ASPxClientEdit.ValidateGroup = function(validationGroup, validateInvisibleEditors) {
1168 return this.ValidateEditorsInContainer(null, validationGroup, validateInvisibleEditors);
1169};
1170ASPxClientEdit.AreEditorsValid = function(containerOrContainerId, validationGroup, checkInvisibleEditors) {
1171 var container = typeof(containerOrContainerId) == "string" ? document.getElementById(containerOrContainerId) : containerOrContainerId;
1172 var checkResult = ASPx.ProcessEditorsInContainer(container, ASPx.EditorsValidProcessingProc, _aspxEditorsValidChoiceCondition, validationGroup,
1173  checkInvisibleEditors, false );
1174 checkResult.isValid = ASPxClientEdit.AreExternalControlsValidInContainer(containerOrContainerId, validationGroup,
1175  checkInvisibleEditors, false ) && checkResult.isValid;
1176 return checkResult.isValid;
1177};
1178ASPxClientEdit.AreExternalControlsValidInContainer = function(containerId, validationGroup, validateInvisibleEditors, processDisabledEditors) {
1179 if(ASPx.Ident.scripts.ASPxClientHtmlEditor)
1180  return ASPxClientHtmlEditor.AreEditorsValidInContainer(containerId, validationGroup, validateInvisibleEditors, processDisabledEditors);
1181 return true;
1182};
1183ASPxClientEdit.ClearExternalControlsInContainer = function(containerId, validationGroup, validateInvisibleEditors, processDisabledEditors) {
1184 if(ASPx.Ident.scripts.ASPxClientHtmlEditor)
1185  return ASPxClientHtmlEditor.ClearEditorsInContainer(containerId, validationGroup, validateInvisibleEditors, processDisabledEditors);
1186 return true;
1187};
1188ASPxClientEdit.ValidateExternalControlsInContainer = function(containerId, validationGroup, validateInvisibleEditors, processDisabledEditors) {
1189 if(ASPx.Ident.scripts.ASPxClientHtmlEditor)
1190  return ASPxClientHtmlEditor.ValidateEditorsInContainer(containerId, validationGroup, validateInvisibleEditors, processDisabledEditors);
1191 return true;
1192};
1193ASPxClientEdit.AttachEditorModificationListener = function(handler, predicate) {
1194 var processAction = function(event) { event.AddHandler(handler); };
1195 ASPxClientEdit.ProcessEditorModificationListener(handler, processAction, predicate);
1196};
1197ASPxClientEdit.DetachEditorModificationListener = function(handler, predicate) {
1198 var processAction = function(event) { event.RemoveHandler(handler); };
1199 ASPxClientEdit.ProcessEditorModificationListener(handler, processAction, predicate);
1200};
1201ASPxClientEdit.ProcessEditorModificationListener = function(handler, action, predicate) {
1202 ASPx.GetControlCollection().ForEachControl(function(control) {
1203  if(control.GetModifyEvent && predicate(control)) {
1204   if(control.isNative)
1205    control.EnsureRequiredNativeAttributesExists();
1206   action(control.GetModifyEvent());
1207  }
1208 });
1209};
1210var ASPxClientEditKeyEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
1211 constructor: function(htmlEvent) {
1212  this.constructor.prototype.constructor.call(this);
1213  this.htmlEvent = htmlEvent;
1214 }
1215});
1216var ASPxClientEditValidationEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
1217 constructor: function(value, errorText, isValid) {
1218  this.constructor.prototype.constructor.call(this);
1219  this.errorText = errorText;
1220  this.isValid = isValid;
1221  this.value = value;
1222 }
1223});
1224ASPx.ProcessEditorsInContainer = function(container, processingProc, choiceCondition, validationGroup, processInvisibleEditors, processDisabledEditors) {
1225 var allProcessedSuccessfull = true;
1226 var firstInvalid = null;
1227 var firstVisibleInvalid = null;
1228 var invalidEditorToBeFocused = null;
1229 ASPx.GetControlCollection().ForEachControl(function(control) {
1230  var canValidate = ASPx.CanValidateControl(control, container, processingProc, choiceCondition, validationGroup, processInvisibleEditors, processDisabledEditors);
1231  if(!canValidate) return;
1232  var isSuccess = processingProc(control);
1233  if(!isSuccess) {
1234   allProcessedSuccessfull = false;
1235   if(firstInvalid == null)
1236    firstInvalid = control;
1237   var isVisible = control.IsVisible();
1238   if(isVisible && firstVisibleInvalid == null)
1239    firstVisibleInvalid = control;
1240   if(control.setFocusOnError && invalidEditorToBeFocused == null && isVisible)
1241    invalidEditorToBeFocused = control;
1242  }
1243 }, this);
1244 if(invalidEditorToBeFocused != null)
1245  invalidEditorToBeFocused.SetFocus();
1246 return new ASPxValidationResult(allProcessedSuccessfull, firstInvalid, firstVisibleInvalid);
1247};
1248ASPx.CanValidateControl = function(control, container, processingProc, choiceCondition, validationGroup, processInvisibleEditors, processDisabledEditors) {
1249 var needToProcessRatingControl = window.ASPxClientRatingControl && (control instanceof ASPxClientRatingControl) && processingProc === ASPx.ClearProcessingProc;
1250 var mainElement = control.GetMainElement(); 
1251 if(!ASPx.Ident.IsASPxClientEdit(control) && !needToProcessRatingControl)
1252  return false;
1253 if(ASPx.Ident.isDialogInvisibleControl(control) || ASPx.Ident.isBatchEditUnusedEditor(control))
1254  return false; 
1255 if(!processDisabledEditors && !control.GetEnabled())
1256  return false;
1257 if(!mainElement || (container && !ASPx.GetIsParent(container, mainElement)))
1258  return false;
1259 if(!processInvisibleEditors && !control.IsVisible())
1260  return false;
1261 if(choiceCondition && !choiceCondition(control, validationGroup))
1262  return false;
1263 return true;
1264};
1265var ASPxValidationResult = ASPx.CreateClass(null, {
1266 constructor: function(isValid, firstInvalid, firstVisibleInvalid) {
1267  this.isValid = isValid;
1268  this.firstInvalid = firstInvalid;

1269  this.firstVisibleInvalid = firstVisibleInvalid;
1270 }
1271});
1272ASPx.ClearChoiceCondition = function(edit, validationGroup) {
1273 return !ASPx.IsExists(validationGroup) || (edit.validationGroup == validationGroup);
1274};
1275function _aspxValidateChoiceCondition(edit, validationGroup) {
1276 return ASPx.ClearChoiceCondition(edit, validationGroup) && edit.customValidationEnabled;
1277}
1278function _aspxEditorsValidChoiceCondition(edit, validationGroup) {
1279 return _aspxValidateChoiceCondition(edit, validationGroup);
1280}
1281function wrapLostFocusHandler(handler) {
1282 if(ASPx.Browser.Edge) {
1283  return function(name) {
1284   var edit = ASPx.GetControlCollection().Get(name);
1285   if(edit && !ASPx.IsElementVisible(edit.GetMainElement()))
1286    setTimeout(handler, 0, name);
1287   else
1288    handler(name);
1289  };
1290 }
1291 return handler;
1292}
1293ASPx.EGotFocus = function(name) {
1294 var edit = ASPx.GetControlCollection().Get(name);
1295 if(edit) {
1296  if(edit.isInitialized) {
1297   if(ASPx.Browser.VirtualKeyboardSupported && !edit.ownerListBox)
1298    ASPx.VirtualKeyboardUI.processEditorGotFocus(edit);
1299   else
1300    edit.OnFocus();
1301  }
1302  else {
1303   var inputElement = edit.GetFocusableInputElement();
1304   if(inputElement && inputElement === document.activeElement) {
1305    if(ASPx.Browser.Firefox)
1306     window.setTimeout(function() { document.activeElement.blur(); }, 0);
1307    else
1308     document.activeElement.blur();
1309   }
1310  }
1311 }
1312};
1313ASPx.ELostFocusCore = function(name) {
1314 var edit = ASPx.GetControlCollection().Get(name);
1315 if(ASPx.Browser.VirtualKeyboardSupported && (!edit || !edit.ownerListBox)) {
1316  var supressLostFocus = ASPx.VirtualKeyboardUI.isInputNativeBluring();
1317  if(!supressLostFocus)
1318   ASPx.VirtualKeyboardUI.resetFocusedEditorCore();
1319  else 
1320   return;
1321 }
1322 if(edit && edit.focused) {
1323  if(edit.UseDelayedSpecialFocus()) {
1324   if(edit.specialFocusTimer === -1)
1325    edit.specialFocusTimer = ASPx.Timer.SetControlBoundTimeout(function() { edit.OnLostFocus(); }, edit, 30);
1326  }
1327  else {
1328   edit.OnLostFocus();
1329  }
1330 }
1331};
1332ASPx.ELostFocus = wrapLostFocusHandler(ASPx.ELostFocusCore);
1333ASPx.EValueChanged = function(name) {
1334 var edit = ASPx.GetControlCollection().Get(name);
1335 if(edit != null)
1336  edit.OnValueChanged();
1337};
1338ASPx.VirtualKeyboardUI = (function() {
1339 var result = {
1340  focusedEditor: null,
1341  inputNativeFocusLocked: false,
1342  elementBelongsToEditor: function(element) {
1343   if(!element) return false;
1344   var isBelongsToEditor = false;
1345   ASPx.GetControlCollection().ForEachControl(function(control) {
1346    if(ASPx.Ident.IsASPxClientEdit(control) && control.IsEditorElement(element)) {
1347     isBelongsToEditor = true;
1348     return true;
1349    }
1350   }, this);
1351   return isBelongsToEditor;
1352  },
1353  elementBelongsToFocusedEditor: function (element) {
1354   return this.focusedEditor && this.focusedEditor.IsEditorElement(element);
1355  },
1356  onTouchStart: function (evt) {
1357   if (!ASPx.Browser.VirtualKeyboardSupported || this.isGooglePlaceAutocompleteElementTap(evt)) return;
1358   this.setInputNativeFocusLocked(false);
1359   if(this.focusedEditor)
1360    this.focusedEditor.onVirtualKeyboardUITouchStart(evt);
1361  },
1362  onTouchEnd: function(evt) {
1363   if(ASPx.TouchUIHelper.pointerEnabled) {  
1364    if(!window.testingTouchMode) { 
1365     if(evt.pointerType !== ASPx.TouchUIHelper.pointerType.Touch)
1366      return;
1367    }
1368    this.processFocusEditorControl(evt);
1369   } else
1370    ASPx.TouchUIHelper.handleFastTapIfRequired(evt,
1371     function() {
1372      this.processFocusEditorControl(evt);
1373     }.aspxBind(this), false);
1374  },
1375  processFocusEditorControl: function(evt) {
1376   var evtSource = ASPx.Evt.GetEventSource(evt);
1377   var focusedEditorIsTimeEdit = this.focusedEditor && (ASPx.Ident.IsASPxClientTimeEdit && ASPx.Ident.IsASPxClientTimeEdit(this.focusedEditor));
1378   var focusedTimeEditBelongsToDateEdit = focusedEditorIsTimeEdit && this.focusedEditor.OwnerDateEdit && this.focusedEditor.OwnerDateEdit.GetShowTimeSection();
1379   if(focusedTimeEditBelongsToDateEdit) {
1380    this.focusedEditor.OwnerDateEdit.ForceRefocusTimeSectionTimeEdit(evtSource);
1381    return;
1382   }
1383   var elementWithNativeFocus = ASPx.GetActiveElement();
1384   var someEditorInputIsFocused = this.elementBelongsToEditor(elementWithNativeFocus);
1385   var touchKeyboardIsVisible = someEditorInputIsFocused;

1386   var tapOutsideEditorAndInputs = !this.elementBelongsToEditor(evtSource) && !ASPx.Ident.IsFocusableElementRegardlessTabIndex(evtSource)
1387    && !this.isGooglePlaceAutocompleteElementTap(evt);
1388   var blurToHideTouchKeyboard = touchKeyboardIsVisible && tapOutsideEditorAndInputs;
1389   if(blurToHideTouchKeyboard) {
1390    elementWithNativeFocus.blur();
1391    return;
1392   }
1393   var tapOutsideFocusedEditor = this.focusedEditor && !this.elementBelongsToFocusedEditor(evtSource);
1394   if(tapOutsideFocusedEditor) {
1395    if(!this.elementBelongsToFocusedEditor(elementWithNativeFocus))
1396     this.resetFocusedEditor();
1397   }
1398  },
1399  focusEditor: function(edit) {
1400   if(!edit.focused) {
1401    this.setInputNativeFocusLocked(true);
1402    this.setFocusToEditor(edit);
1403   } else {
1404    edit.ForceRefocusEditor();
1405   }
1406  },
1407  setFocusToEditor: function(edit) {
1408   if(ASPx.Browser.MacOSMobilePlatform) {
1409    var timeoutDuration = ASPx.Browser.Chrome ? 250 : 30;
1410    window.setTimeout(function() {
1411     edit.SetFocus();
1412    }, timeoutDuration);
1413   } else {
1414    edit.SetFocus();
1415   }
1416  },
1417  processEditorGotFocus: function(edit) {
1418   if(this.focusedEditor === edit) {
1419    this.focusedEditor.UnlockFocusEvents();
1420    if(this.focusedEditor.EnsureClearButtonVisibility)
1421     this.focusedEditor.EnsureClearButtonVisibility();
1422   }
1423   else {
1424    this.setFocusedEditor(edit);
1425    if(this.getInputNativeFocusLocked())
1426     edit.BlurInputElement();
1427   }
1428  },
1429  setFocusedEditor: function(edit) {
1430   this.resetFocusedEditor();
1431   this.focusedEditor = edit;
1432   this.focusedEditor.Disposed.AddHandler(this.onFocusedEditorDisposed);
1433   this.focusedEditor.OnFocus();
1434   ASPx.SetFocusedEditor(this.focusedEditor);
1435  },
1436  isInputNativeBluring: function() {
1437   return this.focusedEditor && this.getInputNativeFocusLocked();
1438  },
1439  setInputNativeFocusLocked: function(locked) {
1440   this.inputNativeFocusLocked = locked;
1441  },
1442  getInputNativeFocusLocked: function() {
1443   return this.inputNativeFocusLocked;
1444  },
1445  resetFocusedEditor: function() {
1446   if(this.focusedEditor) {
1447    var curEditorName = this.focusedEditor.name;
1448    var focusedEditorInputElementExists = this.focusedEditor.GetInputElement();
1449    this.resetFocusedEditorCore();
1450    if(focusedEditorInputElementExists)
1451     ASPx.ELostFocusCore(curEditorName);
1452   }
1453  },
1454  resetFocusedEditorCore: function() { 
1455   if(this.focusedEditor)
1456    this.focusedEditor.Disposed.RemoveHandler(this.onFocusedEditorDisposed);
1457   this.focusedEditor = null;
1458  },
1459  getFocusedEditor: function() {
1460   return this.focusedEditor;
1461  },
1462  focusableInputElementIsActive: function(edit) {
1463   var inputElement = edit.GetFocusableInputElement();
1464   return !!inputElement ? ASPx.GetActiveElement() === inputElement : false;
1465  },
1466  isGooglePlaceAutocompleteElementTap: function(evt) {
1467   var googlePlaceAutocompleteContainer = ASPx.GetNodeByClassName(document.body, "pac-container", 0);
1468   if(!googlePlaceAutocompleteContainer)
1469    return false;
1470   return ASPx.GetParentByClassName(ASPx.Evt.GetEventSource(evt), "pac-container") != null;
1471  }
1472 };
1473 result.onFocusedEditorDisposed = function() {
1474  this.resetFocusedEditor();
1475 }.bind(result);
1476 return result;
1477})();
1478if(ASPx.Browser.VirtualKeyboardSupported) {
1479 var touchStartEventName = ASPx.TouchUIHelper.pointerEnabled ? ASPx.TouchUIHelper.pointerDownEventName : 'touchstart';
1480 var touchEndEventName = ASPx.TouchUIHelper.pointerEnabled ? ASPx.TouchUIHelper.pointerUpEventName : 'touchend';
1481 ASPx.Evt.AttachEventToDocument(touchStartEventName, function(evt) { ASPx.VirtualKeyboardUI.onTouchStart(evt); });
1482 ASPx.Evt.AttachEventToDocument(touchEndEventName, function(evt) { ASPx.VirtualKeyboardUI.onTouchEnd(evt); });
1483}
1484ASPx.Evt.AttachEventToDocument("mousedown", function(evt) {
1485 var editor = ASPx.GetFocusedEditor();
1486 if(!editor) 
1487  return;
1488 var evtSource = ASPx.Evt.GetEventSource(evt);
1489 if(editor.IsClearButtonElement(evtSource))
1490  return;
1491 if(editor.OwnerDateEdit && editor.OwnerDateEdit.GetShowTimeSection()) {
1492  editor.OwnerDateEdit.ForceRefocusTimeSectionTimeEdit(evtSource);
1493  return;
1494 }
1495 if(editor.ownerListBox && editor.ownerListBox.IsEditorElement(evtSource) && !editor.IsEditorElement(evtSource)) {
1496  editor.ownerListBox.ForceRefocusEditor(evt);
1497  ASPx.SetFocusedEditor(editor.ownerListBox);
1498  return;
1499 }
1500 if(editor.IsEditorElement(evtSource) && !editor.IsElementBelongToInputElement(evtSource))
1501  editor.ForceRefocusEditor(evt);
1502});
1503ASPx.Evt.AttachEventToDocument(ASPx.Evt.GetMouseWheelEventName(), function(evt) {
1504 var editor = ASPx.GetFocusedEditor();
1505 if(editor != null && ASPx.IsExistsElement(editor.GetMainElement()) && editor.focused && editor.receiveGlobalMouseWheel)
1506  editor.OnMouseWheel(evt);
1507});
1508ASPx.KBSIKeyDown = function(name, evt){
1509 var control = ASPx.GetControlCollection().Get(name);
1510 if(control != null){
1511  var isProcessed = control.OnSpecialKeyDown(evt);
1512  if(isProcessed)
1513   return ASPx.Evt.PreventEventAndBubble(evt);
1514 }
1515};
1516ASPx.KBSIKeyPress = function(name, evt){
1517 var control = ASPx.GetControlCollection().Get(name);
1518 if(control != null){
1519  var isProcessed = control.OnSpecialKeyPress(evt);
1520  if(isProcessed)
1521   return ASPx.Evt.PreventEventAndBubble(evt);
1522 }
1523};
1524ASPx.KBSIKeyUp = function(name, evt){
1525 var control = ASPx.GetControlCollection().Get(name);
1526 if(control != null){
1527  var isProcessed = control.OnSpecialKeyUp(evt);
1528  if(isProcessed)
1529   return ASPx.Evt.PreventEventAndBubble(evt);
1530 }
1531};
1532ASPx.ClearProcessingProc = function(edit) {
1533 return edit.Clear();
1534};
1535ASPx.ValidateProcessingProc = function(edit) {
1536 edit.OnValidation(ValidationType.MassValidation);
1537 return edit.GetIsValid();
1538};
1539ASPx.EditorsValidProcessingProc = function(edit) {
1540 return edit.GetIsValid();
1541};
1542var CheckEditElementHelper = ASPx.CreateClass(ASPx.CheckableElementHelper, {
1543 AttachToMainElement: function(internalCheckBox) {
1544  ASPx.CheckableElementHelper.prototype.AttachToMainElement.call(this, internalCheckBox);
1545  this.AttachToLabelElement(this.GetLabelElement(internalCheckBox.container), internalCheckBox);
1546 },
1547 AttachToLabelElement: function(labelElement, internalCheckBox) {
1548  var _this = this;
1549  if(labelElement) {
1550   ASPx.Evt.AttachEventToElement(labelElement, "click", 
1551    function (evt) { 
1552     _this.InvokeClick(internalCheckBox, evt);
1553    }
1554   );
1555   ASPx.Evt.AttachEventToElement(labelElement, "mousedown",
1556    function (evt) {
1557     internalCheckBox.Refocus();
1558    }
1559   );
1560  }
1561 },
1562 GetLabelElement: function(container) {
1563  var labelElement = ASPx.GetNodeByTagName(container, "LABEL", 0);
1564  if(!labelElement) {
1565   var labelCell = ASPx.GetNodeByClassName(container, "dxichTextCellSys", 0);
1566   labelElement = ASPx.GetNodeByTagName(labelCell, "SPAN", 0);
1567  }
1568  return labelElement;
1569 }
1570});
1571CheckEditElementHelper.Instance = new CheckEditElementHelper();
1572var CalendarSharedParameters = ASPx.CreateClass(null, {
1573 updateCalendarCallbackCommand: "UPDATE",
1574 constructor: function() {
1575  this.minDate = null;
1576  this.maxDate = null;
1577  this.disabledDates = [];
1578  this.calendarCustomDraw = false;
1579  this.hasCustomDisabledDatesViaCallback = false;
1580  this.dateRangeMode = false;
1581  this.currentDateEdit = null;
1582  this.DaysSelectingOnMouseOver = new ASPxClientEvent();
1583  this.VisibleDaysMouseOut = new ASPxClientEvent();
1584  this.CalendarSelectionChangedInternal = new ASPxClientEvent();
1585 },
1586 Assign: function(source) {
1587  this.minDate = source.minDate ? source.minDate : null;
1588  this.maxDate = source.maxDate ? source.maxDate : null;
1589  this.calendarCustomDraw = source.calendarCustomDraw ? source.calendarCustomDraw : false;

1590  this.hasCustomDisabledDatesViaCallback = source.hasCustomDisabledDatesViaCallback ? source.hasCustomDisabledDatesViaCallback : false;
1591  this.disabledDates = source.disabledDates ? source.disabledDates : [];
1592  this.currentDateEdit = source.currentDateEdit ? source.currentDateEdit : null;
1593 },
1594 GetUpdateCallbackParameters: function() {
1595  var callbackArgs = this.GetCallbackArgs();
1596  callbackArgs = this.FormatCallbackArg(this.updateCalendarCallbackCommand, callbackArgs);
1597  return callbackArgs;
1598 },
1599 GetCallbackArgs: function() {
1600  var args = {};
1601  if(this.minDate)
1602   args.clientMinDate = ASPx.DateUtils.GetInvariantDateString(this.minDate);
1603  if(this.maxDate)
1604   args.clientMaxDate = ASPx.DateUtils.GetInvariantDateString(this.maxDate);
1605  if(args.clientMinDate || args.clientMaxDate) {
1606   var jsonArgs = JSON.stringify(args);
1607   return ASPx.Str.EncodeHtml(jsonArgs);
1608  }
1609  return null;
1610 },
1611 FormatCallbackArg: function(prefix, arg) {
1612  if(!arg) return prefix;
1613  return [prefix, '|', arg.length, ';', arg, ';'].join('');
1614 }
1615});
1616ASPx.CalendarSharedParameters = CalendarSharedParameters;
1617ASPx.ValidationType = ValidationType;
1618ASPx.ErrorFrameDisplay = ErrorFrameDisplay;
1619ASPx.EditElementSuffix = EditElementSuffix;
1620ASPx.ValidationPattern = ValidationPattern;
1621ASPx.RequiredFieldValidationPattern = RequiredFieldValidationPattern;
1622ASPx.RegularExpressionValidationPattern = RegularExpressionValidationPattern;
1623ASPx.CheckEditElementHelper = CheckEditElementHelper;
1624ASPx.IsEditorFocusable = _aspxIsEditorFocusable;
1625window.ASPxClientEditBase = ASPxClientEditBase;
1626window.ASPxClientEdit = ASPxClientEdit;
1627window.ASPxClientEditKeyEventArgs = ASPxClientEditKeyEventArgs;
1628window.ASPxClientEditValidationEventArgs = ASPxClientEditValidationEventArgs;
1629})();
1630