https://www.berkutsystems.com/DXR.axd?r=1_183-PCMyo

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.specialKeyboardHandlingUsed = false;

251  this.onKeyDownHandler = null;
252  this.onKeyPressHandler = null;
253  this.onKeyUpHandler = null;
254  this.onGotFocusHandler = null;
255  this.onLostFocusHandler = null;
256  this.GotFocus = new ASPxClientEvent();
257  this.LostFocus = new ASPxClientEvent();
258  this.Validation = new ASPxClientEvent();
259  this.ValueChanged = new ASPxClientEvent();
260  this.KeyDown = new ASPxClientEvent();
261  this.KeyPress = new ASPxClientEvent();
262  this.KeyUp = new ASPxClientEvent();
263  this.eventHandlersInitialized = false;
264  this.errorCellVisibilityChanged = new ASPxClientEvent();
265  this.ariaExplanatoryTextManager = null;
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  ASPxClientEditBase.prototype.InlineInitialize.call(this);
284  this.UpdateStyleDecorations();
285  var externalTable = this.GetExternalTable();
286  if(externalTable && ASPx.IsPercentageSize(externalTable.style.width)) {
287   this.width = "100%";
288   this.GetMainElement().style.width = "100%";
289   if(this.isErrorFrameRequired)
290    externalTable.setAttribute("errorFrame", "errorFrame");
291  }
292  this.ariaExplanatoryTextManager = this.CreateAriaExplanatoryTextManager();
293  if(this.clientReadOnly)
294   this.SetReadOnlyInternal(true);
295  this.UpdateErrorCellParentRowVisibility();
296 }, 
297 AfterInitialize: function() {
298  this.ariaExplanatoryTextManager.SetCaptionAssociating();
299  this.ariaExplanatoryTextManager.UpdateText();
300  this.ariaExplanatoryTextManager.UpdateValidationState();
301  ASPxClientEditBase.prototype.AfterInitialize.call(this);
302 },
303 UpdateStyleDecorations: function() {
304  if(this.styleDecoration)
305   this.styleDecoration.Update();
306 },
307 InitSpecialKeyboardHandling: function(){
308  var name = this.name;
309  this.onKeyDownHandler = function(evt) { ASPx.KBSIKeyDown(name,evt); };
310  this.onKeyPressHandler = function(evt) { ASPx.KBSIKeyPress(name, evt); };
311  this.onKeyUpHandler = function(evt) { ASPx.KBSIKeyUp(name, evt); };
312  this.onGotFocusHandler = function(evt) { ASPx.ESGotFocus(name); };
313  this.onLostFocusHandler = function(evt) { ASPx.ESLostFocus(name); };
314  this.specialKeyboardHandlingUsed = true;
315  this.InitializeDelayedSpecialFocus();
316 },
317 InitializeKeyHandlers: function() {
318 },
319 AddKeyDownHandler: function(key, handler) {
320  this.keyDownHandlers[key] = handler;
321 },
322 AddKeyPressHandler: function(key, handler) {
323  this.keyPressHandlers[key] = handler;
324 },
325 ChangeSpecialInputEnabledAttributes: function(element, method, doNotChangeAutoComplete){
326  if(!doNotChangeAutoComplete) 
327   element.autocomplete = "off";
328  if(this.onKeyDownHandler != null)
329   method(element, "keydown", this.onKeyDownHandler);
330  if(this.onKeyPressHandler != null)
331   method(element, "keypress", this.onKeyPressHandler);
332  if(this.onKeyUpHandler != null)
333   method(element, "keyup", this.onKeyUpHandler);
334  if(this.onGotFocusHandler != null)
335   method(element, "focus", this.onGotFocusHandler);
336  if(this.onLostFocusHandler != null)
337   method(element, "blur", this.onLostFocusHandler);
338 },
339 CreateAriaExplanatoryTextManager: function() {
340  if(this.accessibilityCompliant)
341   return new EditAccessibilityExplanatoryTextManager(this);
342  else 
343   return new DisableAccessibilityExplanatoryTextManager(this);
344 },
345 UpdateClientValidationState: function() {
346  if(!this.customValidationEnabled)
347   return;
348  var mainElement = this.GetMainElement();
349  if(mainElement) {
350   var validationState = !this.GetIsValid() ? ("-" + this.GetErrorText()) : "";
351   this.UpdateStateObjectWithObject({ validationState: validationState });
352  }
353 },
354 UpdateValidationSummaries: function(validationType, initializing) {
355  if(ASPx.Ident.scripts.ASPxClientValidationSummary) {
356   var summaryCollection = ASPx.GetClientValidationSummaryCollection();
357   summaryCollection.OnEditorIsValidStateChanged(this, validationType, initializing && this.notifyValidationSummariesToAcceptNewError);
358  }
359 },
360 FindInputElement: function(){
361  return null;
362 },
363 GetInputElement: function(){
364  if(!ASPx.IsExistsElement(this.inputElement))
365   this.inputElement = this.FindInputElement();
366  return this.inputElement;
367 },
368 GetFocusableInputElement: function() {
369  return this.GetInputElement();
370 },
371 GetAccessibilityActiveElements: function() {
372  return [this.GetInputElement()];
373 },
374 GetAccessibilityFirstActiveElement: function() {
375  return this.accessibilityHelper ? 
376    this.accessibilityHelper.getMainElement() : 
377    this.GetAccessibilityActiveElements()[0];
378 },
379 GetAccessibilityAssistantElement: function() {
380  return this.GetChildElement(AccessibilityAssistantID);
381 },
382 GetErrorImage: function() {
383  return this.GetCachedElementById(EditElementSuffix.ErrorImage);
384 },
385 GetControlCell: function() {
386  return this.GetCachedElementById(EditElementSuffix.ControlCell);
387 },
388 GetErrorCell: function() {
389  return this.GetCachedElementById(EditElementSuffix.ErrorCell);
390 },
391 GetErrorTextCell: function() {
392  return this.GetCachedElementById(this.errorImageIsAssigned ? EditElementSuffix.ErrorTextCell : EditElementSuffix.ErrorCell);
393 },
394 GetReadOnly: function() {
395  return this.readOnly || this.clientReadOnly;
396 },
397 SetReadOnly: function(readOnly) {
398  readOnly = !!readOnly;
399  if(this.clientReadOnly === readOnly || this.readOnly)
400   return;
401  this.SetReadOnlyInternal(readOnly);
402 },
403 SetReadOnlyInternal: function(readOnly) {
404  this.clientReadOnly = readOnly;
405  this.ChangeReadOnlyStateItems(readOnly);
406 },
407 ChangeReadOnlyStateItems: function(readOnly) {
408  ASPx.GetStateController().SetElementReadOnly(this.GetMainElement(), readOnly);
409 },
410 SetVisible: function (isVisible) {
411  if(this.clientVisible == isVisible)
412   return;
413  var externalTable = this.GetExternalTable();
414  if(externalTable) {
415   ASPx.SetElementDisplay(externalTable, isVisible);
416   if(this.customValidationEnabled) {
417    var isValid = !isVisible ? true : void (0);
418    this.UpdateErrorFrameAndFocus(false , true , isValid );
419   }
420  }
421  ASPxClientControl.prototype.SetVisible.call(this, isVisible);
422 },
423 GetStateHiddenFieldName: function() {
424  return this.uniqueID + "$State";
425 },
426 GetValueInputToValidate: function() {
427  return this.GetInputElement();
428 },
429 IsVisible: function() {
430  if(!this.clientVisible)
431   return false;
432  var element = this.GetMainElement();
433  if(!element) 
434   return false;
435  while(element && element.tagName != "BODY") {
436   if(element.getAttribute("errorFrame") != "errorFrame" && (!ASPx.GetElementVisibility(element) || !ASPx.GetElementDisplay(element)))
437    return false;
438   element = element.parentNode;
439  }
440  return true;
441 },
442 AdjustControlCore: function() {
443  this.CollapseEditor();
444  this.UnstretchInputElement();
445  if(this.heightCorrectionRequired)
446   this.CorrectEditorHeight();
447 },
448 CorrectEditorHeight: function() {
449 },
450 UnstretchInputElement: function() {
451 },
452 UseDelayedSpecialFocus: function() {
453  return false;
454 },
455 GetDelayedSpecialFocusTriggers: function() {
456  return [ this.GetMainElement() ];
457 },
458 InitializeDelayedSpecialFocus: function() {
459  if(!this.UseDelayedSpecialFocus())
460   return;
461  this.specialFocusTimer = -1;    
462  var handler = function(evt) { this.OnDelayedSpecialFocusMouseDown(evt); }.aspxBind(this);
463  var triggers = this.GetDelayedSpecialFocusTriggers();
464  for(var i = 0; i < triggers.length; i++)
465   ASPx.Evt.AttachEventToElement(triggers[i], "mousedown", handler);
466 },
467 OnDelayedSpecialFocusMouseDown: function(evt) {
468  window.setTimeout(function() { this.SetFocus(); }.aspxBind(this), 0);
469 },
470 IsFocusEventsLocked: function() {
471  return this.focusEventsLocked || this.focusEventsLockCount !== 0;
472 },
473 BeginUpdate: function() {
474  this.focusEventsLockCount++;
475 },
476 EndUpdate: function() {
477  this.focusEventsLockCount--;
478  if(this.focusEventsLockCount === 0)
479   if(this.focused && !this.IsEditorElement(document.activeElement)) 
480    this.OnLostFocus();
481 },
482 LockFocusEvents: function() {
483  if(!this.focused) return;
484  this.focusEventsLocked = true;
485 },
486 UnlockFocusEvents: function() {
487  this.focusEventsLocked = false;
488 },
489 ForceRefocusEditor: function(evt, isNativeFocus) {
490  if(ASPx.Browser.VirtualKeyboardSupported && !this.ownerListBox) {
491   var focusedEditor = ASPx.VirtualKeyboardUI.getFocusedEditor();
492   if(ASPx.VirtualKeyboardUI.getInputNativeFocusLocked() && (!focusedEditor || focusedEditor === this))
493     return;
494   ASPx.VirtualKeyboardUI.setInputNativeFocusLocked(!isNativeFocus);
495  }

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

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

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

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

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

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

1264  this.firstVisibleInvalid = firstVisibleInvalid;
1265 }
1266});
1267ASPx.ClearChoiceCondition = function(edit, validationGroup) {
1268 return !ASPx.IsExists(validationGroup) || (edit.validationGroup == validationGroup);
1269};
1270function _aspxValidateChoiceCondition(edit, validationGroup) {
1271 return ASPx.ClearChoiceCondition(edit, validationGroup) && edit.customValidationEnabled;
1272}
1273function _aspxEditorsValidChoiceCondition(edit, validationGroup) {
1274 return _aspxValidateChoiceCondition(edit, validationGroup);
1275}
1276function wrapLostFocusHandler(handler) {
1277 if(ASPx.Browser.Edge) {
1278  return function(name) {
1279   var edit = ASPx.GetControlCollection().Get(name);
1280   if(edit && !ASPx.IsElementVisible(edit.GetMainElement()))
1281    setTimeout(handler, 0, name);
1282   else
1283    handler(name);
1284  };
1285 }
1286 return handler;
1287}
1288ASPx.EGotFocus = function(name) {
1289 var edit = ASPx.GetControlCollection().Get(name); 
1290 if(!edit) return;
1291 if(!edit.isInitialized){
1292  var inputElement = edit.GetFocusableInputElement();
1293  if(inputElement && inputElement === document.activeElement) {
1294   if(ASPx.Browser.Firefox)
1295    window.setTimeout(function() { document.activeElement.blur(); }, 0);
1296   else
1297    document.activeElement.blur();
1298  }
1299  return;
1300 }
1301 if(ASPx.Browser.VirtualKeyboardSupported && !edit.ownerListBox)
1302  ASPx.VirtualKeyboardUI.onCallingVirtualKeyboard(edit, false);
1303 else
1304  edit.OnFocus();
1305};
1306ASPx.ELostFocusCore = function(name) {
1307 var edit = ASPx.GetControlCollection().Get(name);
1308 if(ASPx.Browser.VirtualKeyboardSupported && (!edit || !edit.ownerListBox)) {
1309  var supressLostFocus = ASPx.VirtualKeyboardUI.isInputNativeBluring();
1310  if(supressLostFocus)
1311   return;
1312  ASPx.VirtualKeyboardUI.resetFocusedEditor();
1313 }
1314 if(edit != null)
1315  edit.OnLostFocus();
1316};
1317ASPx.ELostFocus = wrapLostFocusHandler(ASPx.ELostFocusCore);
1318ASPx.ESGotFocus = function(name) {
1319 var edit = ASPx.GetControlCollection().Get(name); 
1320 if(!edit) return;
1321   if(ASPx.Browser.VirtualKeyboardSupported && !edit.ownerListBox) {
1322  ASPx.VirtualKeyboardUI.onCallingVirtualKeyboard(edit, true);
1323 } else {
1324  edit.OnSpecialFocus();
1325 }
1326};
1327ASPx.ESLostFocusCore = function(name) {
1328 var edit = ASPx.GetControlCollection().Get(name);
1329 if(ASPx.Browser.VirtualKeyboardSupported && (!edit || !edit.ownerListBox)) {
1330  var supressLostFocus = ASPx.VirtualKeyboardUI.isInputNativeBluring();
1331  if(supressLostFocus)
1332   return;
1333  ASPx.VirtualKeyboardUI.resetFocusedEditor();
1334 }
1335 if(!edit) return;
1336 if(edit.UseDelayedSpecialFocus())
1337  edit.specialFocusTimer = window.setTimeout(function() { edit.OnSpecialLostFocus(); }, 30);
1338 else

1339  edit.OnSpecialLostFocus();
1340};
1341ASPx.ESLostFocus = wrapLostFocusHandler(ASPx.ESLostFocusCore);
1342ASPx.EValueChanged = function(name) {
1343 var edit = ASPx.GetControlCollection().Get(name);
1344 if(edit != null)
1345  edit.OnValueChanged();
1346};
1347ASPx.VirtualKeyboardUI = (function() {
1348 var focusedEditor = null;
1349 var inputNativeFocusLocked = false;
1350 function elementBelongsToEditor(element) {
1351  if(!element) return false;
1352  var isBelongsToEditor = false;
1353  ASPx.GetControlCollection().ForEachControl(function(control) {
1354   if(ASPx.Ident.IsASPxClientEdit(control) && control.IsEditorElement(element)) {
1355    isBelongsToEditor = true;
1356    return true;
1357   }
1358  }, this);
1359  return isBelongsToEditor;
1360 }
1361 function elementBelongsToFocusedEditor(element) {
1362  return focusedEditor && focusedEditor.IsEditorElement(element);
1363 }
1364 return {
1365  onTouchStart: function (evt) {
1366   if (!ASPx.Browser.VirtualKeyboardSupported || this.isGooglePlaceAutocompleteElementTap(evt)) return;
1367   inputNativeFocusLocked = false;
1368   if(focusedEditor)
1369    focusedEditor.onVirtualKeyboardUITouchStart(evt);
1370   if(ASPx.TouchUIHelper.pointerEnabled) {  
1371    if(!window.testingTouchMode) { 
1372     if(evt.pointerType !== ASPx.TouchUIHelper.pointerType.Touch
1373      || ASPx.Browser.AndroidMobilePlatform) 
1374      return;
1375    }
1376    this.processFocusEditorControl(evt);
1377   } else
1378    ASPx.TouchUIHelper.handleFastTapIfRequired(evt,  function(){ this.processFocusEditorControl(evt); }.aspxBind(this), false);
1379  },
1380  processFocusEditorControl: function(evt) {
1381   var evtSource = ASPx.Evt.GetEventSource(evt);
1382   var timeEditHasAppliedFocus = focusedEditor && (ASPx.Ident.IsASPxClientTimeEdit && ASPx.Ident.IsASPxClientTimeEdit(focusedEditor));
1383   var focusedTimeEditBelongsToDateEdit = timeEditHasAppliedFocus && focusedEditor.OwnerDateEdit && focusedEditor.OwnerDateEdit.GetShowTimeSection();
1384   if(focusedTimeEditBelongsToDateEdit) {
1385    focusedEditor.OwnerDateEdit.ForceRefocusTimeSectionTimeEdit(evtSource);
1386    return;
1387   }
1388   var elementWithNativeFocus = ASPx.GetActiveElement();
1389   var someEditorInputIsFocused = elementBelongsToEditor(elementWithNativeFocus);
1390   var touchKeyboardIsVisible = someEditorInputIsFocused;
1391   var tapOutsideEditorAndInputs = !elementBelongsToEditor(evtSource) && !ASPx.Ident.IsFocusableElementRegardlessTabIndex(evtSource);
1392   var blurToHideTouchKeyboard = touchKeyboardIsVisible && tapOutsideEditorAndInputs;
1393   if(blurToHideTouchKeyboard) {
1394    elementWithNativeFocus.blur();
1395    return;
1396   }
1397   var tapOutsideFocusedEditor = focusedEditor && !elementBelongsToFocusedEditor(evtSource);
1398   if(tapOutsideFocusedEditor) {
1399    var focusedEditorWithBluredInput = !elementBelongsToFocusedEditor(elementWithNativeFocus);
1400    if(focusedEditorWithBluredInput) 
1401     this.lostAppliedFocusOfEditor();
1402   }
1403  },
1404  smartFocusEditor: function(edit) {
1405   if(!edit.focused) {
1406    this.setInputNativeFocusLocked(true);
1407    this.setFocusEditorCore(edit);
1408   } else {
1409    edit.ForceRefocusEditor();
1410   }
1411  },
1412  setFocusEditorCore: function(edit) {
1413   if(ASPx.Browser.MacOSMobilePlatform) {
1414    var timeoutDuration = ASPx.Browser.Chrome ? 250 : 30;
1415    window.setTimeout(function(){ edit.SetFocus(); }, timeoutDuration);
1416   } else {
1417    edit.SetFocus();
1418   }
1419  },
1420  onCallingVirtualKeyboard: function(edit, isSpecial) {
1421   this.setAppliedFocusOfEditor(edit, isSpecial);
1422   if(edit.specialKeyboardHandlingUsed == isSpecial && inputNativeFocusLocked)
1423    edit.BlurInputElement();
1424  },
1425  isInputNativeBluring: function() {
1426   return focusedEditor && inputNativeFocusLocked;
1427  },
1428  setInputNativeFocusLocked: function(locked) {
1429   inputNativeFocusLocked = locked;
1430  },
1431  getInputNativeFocusLocked: function() {
1432   return inputNativeFocusLocked;
1433  },
1434  setAppliedFocusOfEditor: function(edit, isSpecial) {
1435   if(focusedEditor === edit) {
1436    if(edit.specialKeyboardHandlingUsed == isSpecial) {
1437     focusedEditor.UnlockFocusEvents();
1438     if(focusedEditor.EnsureClearButtonVisibility)
1439      focusedEditor.EnsureClearButtonVisibility();
1440    }
1441    return;
1442   }
1443   if(edit.specialKeyboardHandlingUsed == isSpecial) {
1444    this.lostAppliedFocusOfEditor();
1445    focusedEditor = edit;
1446    ASPx.SetFocusedEditor(edit);
1447   }
1448   if(isSpecial)
1449    edit.OnSpecialFocus();
1450   else
1451    edit.OnFocus();
1452  },
1453  lostAppliedFocusOfEditor: function() {
1454   if(!focusedEditor) return;
1455   var curEditorName = focusedEditor.name; 
1456   var skbdHandlingUsed = focusedEditor.specialKeyboardHandlingUsed;

1457   var focusedEditorInputElementExists = focusedEditor.GetInputElement();
1458   focusedEditor = null;
1459   if(!focusedEditorInputElementExists)
1460    return;
1461   ASPx.ELostFocusCore(curEditorName);
1462   if(skbdHandlingUsed)
1463    ASPx.ESLostFocusCore(curEditorName);
1464  },
1465  getFocusedEditor: function() {
1466   return focusedEditor;
1467  },
1468  resetFocusedEditor: function() {
1469   focusedEditor = null;
1470  },
1471  focusableInputElementIsActive: function(edit) {
1472   var inputElement = edit.GetFocusableInputElement();
1473   return !!inputElement ? ASPx.GetActiveElement() === inputElement : false;
1474  },
1475  isGooglePlaceAutocompleteElementTap: function(evt) {
1476   var googlePlaceAutocompleteContainer = ASPx.GetNodeByClassName(document.body, "pac-container", 0);
1477   if(!googlePlaceAutocompleteContainer)
1478    return false;
1479   return ASPx.GetParentByClassName(ASPx.Evt.GetEventSource(evt), "pac-container") != null;
1480  }
1481 };
1482})();
1483if(ASPx.Browser.VirtualKeyboardSupported) {
1484 var touchEventName = ASPx.TouchUIHelper.pointerEnabled ? ASPx.TouchUIHelper.pointerDownEventName : 'touchstart';
1485 ASPx.Evt.AttachEventToDocument(touchEventName, function(evt){ ASPx.VirtualKeyboardUI.onTouchStart(evt); });
1486}
1487ASPx.Evt.AttachEventToDocument("mousedown", function(evt) {
1488 var editor = ASPx.GetFocusedEditor();
1489 if(!editor) 
1490  return;
1491 var evtSource = ASPx.Evt.GetEventSource(evt);
1492 if(editor.IsClearButtonElement(evtSource))
1493  return;
1494 if(editor.OwnerDateEdit && editor.OwnerDateEdit.GetShowTimeSection()) {
1495  editor.OwnerDateEdit.ForceRefocusTimeSectionTimeEdit(evtSource);
1496  return;
1497 }
1498 if(editor.ownerListBox && editor.ownerListBox.IsEditorElement(evtSource) && !editor.IsEditorElement(evtSource)) {
1499  editor.ownerListBox.ForceRefocusEditor(evt);
1500  ASPx.SetFocusedEditor(editor.ownerListBox);
1501  return;
1502 }
1503 if(editor.IsEditorElement(evtSource) && !editor.IsElementBelongToInputElement(evtSource))
1504  editor.ForceRefocusEditor(evt);
1505});
1506ASPx.Evt.AttachEventToDocument(ASPx.Evt.GetMouseWheelEventName(), function(evt) {
1507 var editor = ASPx.GetFocusedEditor();
1508 if(editor != null && ASPx.IsExistsElement(editor.GetMainElement()) && editor.focused && editor.receiveGlobalMouseWheel)
1509  editor.OnMouseWheel(evt);
1510});
1511ASPx.KBSIKeyDown = function(name, evt){
1512 var control = ASPx.GetControlCollection().Get(name);
1513 if(control != null){
1514  var isProcessed = control.OnSpecialKeyDown(evt);
1515  if(isProcessed)
1516   return ASPx.Evt.PreventEventAndBubble(evt);
1517 }
1518};
1519ASPx.KBSIKeyPress = function(name, evt){
1520 var control = ASPx.GetControlCollection().Get(name);
1521 if(control != null){
1522  var isProcessed = control.OnSpecialKeyPress(evt);
1523  if(isProcessed)
1524   return ASPx.Evt.PreventEventAndBubble(evt);
1525 }
1526};
1527ASPx.KBSIKeyUp = function(name, evt){
1528 var control = ASPx.GetControlCollection().Get(name);
1529 if(control != null){
1530  var isProcessed = control.OnSpecialKeyUp(evt);
1531  if(isProcessed)
1532   return ASPx.Evt.PreventEventAndBubble(evt);
1533 }
1534};
1535ASPx.ClearProcessingProc = function(edit) {
1536 return edit.Clear();
1537};
1538ASPx.ValidateProcessingProc = function(edit) {
1539 edit.OnValidation(ValidationType.MassValidation);
1540 return edit.GetIsValid();
1541};
1542ASPx.EditorsValidProcessingProc = function(edit) {
1543 return edit.GetIsValid();
1544};
1545var CheckEditElementHelper = ASPx.CreateClass(ASPx.CheckableElementHelper, {
1546 AttachToMainElement: function(internalCheckBox) {
1547  ASPx.CheckableElementHelper.prototype.AttachToMainElement.call(this, internalCheckBox);
1548  this.AttachToLabelElement(this.GetLabelElement(internalCheckBox.container), internalCheckBox);
1549 },
1550 AttachToLabelElement: function(labelElement, internalCheckBox) {
1551  var _this = this;
1552  if(labelElement) {
1553   ASPx.Evt.AttachEventToElement(labelElement, "click", 
1554    function (evt) { 
1555     _this.InvokeClick(internalCheckBox, evt);
1556    }
1557   );
1558   ASPx.Evt.AttachEventToElement(labelElement, "mousedown",
1559    function (evt) {
1560     internalCheckBox.Refocus();
1561    }
1562   );
1563  }
1564 },
1565 GetLabelElement: function(container) {
1566  var labelElement = ASPx.GetNodeByTagName(container, "LABEL", 0);
1567  if(!labelElement) {
1568   var labelCell = ASPx.GetNodeByClassName(container, "dxichTextCellSys", 0);
1569   labelElement = ASPx.GetNodeByTagName(labelCell, "SPAN", 0);
1570  }
1571  return labelElement;
1572 }
1573});
1574CheckEditElementHelper.Instance = new CheckEditElementHelper();
1575var CalendarSharedParameters = ASPx.CreateClass(null, {
1576 updateCalendarCallbackCommand: "UPDATE",
1577 constructor: function() {
1578  this.minDate = null;
1579  this.maxDate = null;
1580  this.disabledDates = [];
1581  this.calendarCustomDraw = false;
1582  this.hasCustomDisabledDatesViaCallback = false;
1583  this.dateRangeMode = false;
1584  this.currentDateEdit = null;
1585  this.DaysSelectingOnMouseOver = new ASPxClientEvent();
1586  this.VisibleDaysMouseOut = new ASPxClientEvent();
1587  this.CalendarSelectionChangedInternal = new ASPxClientEvent();
1588 },
1589 Assign: function(source) {
1590  this.minDate = source.minDate ? source.minDate : null;
1591  this.maxDate = source.maxDate ? source.maxDate : null;
1592  this.calendarCustomDraw = source.calendarCustomDraw ? source.calendarCustomDraw : false;

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