https://coasevilla.org/DXR.axd?r=1_9,1_10,1_253,1_21,1_62,1_11,1_12,1_13,1_180-iQKTr

1var ASPx = ASPx || {};
2var dx = dx || {};
3(function module(ASPx, dx) {
4ASPx.modules = { Utils: module };
5if(!ASPx.attachToReady)
6 ASPx.attachToReady = function (callback) { ASPx.Evt.AttachEventToElement(window, "load", callback); };
7if(!ASPx.attachToLoad)
8 ASPx.attachToLoad = function(callback) { ASPx.Evt.AttachEventToDocumentCore("DOMContentLoaded", callback); };
9ASPx.EmptyObject = { };
10ASPx.FalseFunction = function() { return false; };
11ASPx.SSLSecureBlankUrl = '/DXR.axd?r=1_86-iQKTr';
12ASPx.EmptyImageUrl = '/DXR.axd?r=1_87-iQKTr';
13ASPx.VersionInfo = 'Version=\'23.2.3.0\', File Version=\'23.2.3.0\', Date Modified=\'03/12/2023 3:00:00\'';
14ASPx.Platform = 'ASP';
15ASPx.DoctypeMode = 'Html5';
16ASPx.InvalidDimension = -10000;
17ASPx.InvalidPosition = -10000;
18ASPx.AbsoluteLeftPosition = -10000;
19ASPx.EmptyGuid = "00000000-0000-0000-0000-000000000000";
20ASPx.CallbackSeparator = ":";
21ASPx.ItemIndexSeparator = "i";
22ASPx.CallbackResultPrefix = "/*DX*/";
23ASPx.StyleValueEncodedSemicolon = "DXsmcln";
24ASPx.AccessibilityEmptyUrl = "javascript:;";
25ASPx.AccessibilityPronounceTimeout = 500;
26ASPx.MaxMobileWindowWidth = 576;
27ASPx.PossibleNumberDecimalSeparators = [",", "."];
28ASPx.CultureInfo = {
29 twoDigitYearMax: 2029,
30 ts: ":",
31 ds: "/",
32 am: "AM",
33 pm: "PM",
34 monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "

34November", "December", ""],
35 genMonthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", ""],
36 abbrMonthNames: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ""],
37 abbrDayNames: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
38 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
39 invariantCultureDecimalPoint: ".",
40 numDecimalPoint: ".",
41 numPrec: 2,
42 numGroupSeparator: ",", 
43 numGroups: [ 3 ],
44 numNegPattern: 1,
45 numPosInf: "Infinity", 
46 numNegInf: "-Infinity", 
47 numNan: "NaN",
48 currency: "$",
49 currDecimalPoint: ".",
50 currPrec: 2,
51 currGroupSeparator: ",",
52 currGroups: [ 3 ],
53 currPosPattern: 0,
54 currNegPattern: 0,
55 percentPattern: 0,
56 shortTime: "h:mm tt",
57 longTime: "h:mm:ss tt",
58 shortDate: "M/d/yyyy",
59 longDate: "dddd, MMMM d, yyyy",
60 monthDay: "MMMM d",
61 yearMonth: "MMMM yyyy"
62};
63ASPx.CultureInfo.genMonthNames = ASPx.CultureInfo.monthNames;
64ASPx.Position = {
65 Left: "Left",
66 Right: "Right",
67 Top: "Top",
68 Bottom: "Bottom"
69};

70ASPx.FOCUS_TIMEOUT = 100;
71function setInnerHtmlInternal(el, trustedHtmlString) { 
72 el.innerHTML = trustedHtmlString;
73}
74var DateUtils = { };
75DateUtils.GetInvariantDateString = function(date) {
76 if(!date)
77  return "01/01/0001";
78 var day = date.getDate();
79 var month = date.getMonth() + 1;
80 var year = date.getFullYear();
81 var result = "";
82 if(month < 10)
83  result += "0";
84 result += month.toString() + "/";
85 if(day < 10)
86  result += "0";
87 result += day.toString() + "/";
88 if(year < 1000)
89  result += "0";
90 result += year.toString();
91 return result;
92};
93DateUtils.GetInvariantDateTimeString = function(date) {
94 var dateTimeString = DateUtils.GetInvariantDateString(date);
95 var time = {
96  h: date.getHours(),
97  m: date.getMinutes(),
98  s: date.getSeconds()
99 };
100 for(var key in time) {
101  if(time.hasOwnProperty(key)) {
102   var str = time[key].toString();
103   if(str.length < 2)
104    str = "0" + str;
105   time[key] = str;
106  }
107 }
108 dateTimeString += " " + time.h + ":" + time.m + ":" + time.s;
109 var msec = date.getMilliseconds();
110 if(msec > 0)
111  dateTimeString += "." + ("000" + msec.toString()).substr(-3);
112 return dateTimeString;
113};
114DateUtils.ExpandTwoDigitYear = function(value) {
115 value += 1900;
116 if(value + 99 < ASPx.CultureInfo.twoDigitYearMax)
117  value += 100;
118 return value;  
119};
120DateUtils.GetTimeZoneOffsetDifference = function(firstDate, secondDate) {
121 if(!secondDate)
122  secondDate = DateUtils.GetUtcDate(firstDate);
123 return 60000 * (firstDate.getTimezoneOffset() - secondDate.getTimezoneOffset());
124};
125DateUtils.GetTimeZoneOffset = function(date) {
126 var isECMA262Support = (ASPx.Browser.Chrome && ASPx.Browser.Version >= 67) || ASPx.Browser.EdgeWebKit;
127 if(!isECMA262Support)
128  return date.getTimezoneOffset() * 60000;
129 var utcDate = DateUtils.GetUtcDate(date);
130 var utcTimezoneOffsetDifference = DateUtils.GetTimeZoneOffsetDifference(date);
131 if(utcTimezoneOffsetDifference !== 0)
132  utcDate.setTime(utcDate.valueOf() + utcTimezoneOffsetDifference);
133 return utcDate - date;
134};
135DateUtils.GetUtcDate = function(date) {
136 var utcFullYear = date.getUTCFullYear();
137 var result = new Date(utcFullYear, date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
138 if(utcFullYear < 100)
139  result.setFullYear(utcFullYear);
140 return result;
141};
142DateUtils.ToUtcTime = function(date) {
143 var result = new Date();
144 result.setTime(date.valueOf() + ASPx.DateUtils.GetTimeZoneOffset(date));
145 return result;
146};
147DateUtils.ToLocalTime = function(date) {
148 var result = new Date();
149 result.setTime(date.valueOf() - ASPx.DateUtils.GetTimeZoneOffset(date));
150 return result; 
151};
152DateUtils.AreDatesEqualExact = function(date1, date2) {
153 if(date1 == null && date2 == null)
154  return true;
155 if(date1 == null || date2 == null)
156  return false;
157 return date1.getTime() == date2.getTime(); 
158};
159DateUtils.FixTimezoneGap = function(oldDate, newDate) {
160 var diff = newDate.getHours() - oldDate.getHours();
161 if(diff == 0)
162  return;
163 var sign = (diff == 1 || diff == -23) ? -1 : 1;
164 var trial = new Date(newDate.getTime() + sign * 3600000);
165 var isDateChangedAsExpected = newDate.getHours() - trial.getHours() === diff;
166 if(isDateChangedAsExpected && (sign > 0 || trial.getDate() == newDate.getDate()))
167  newDate.setTime(trial.getTime());
168};
169DateUtils.GetDecadeStartYear = function(year) {
170 return 10 * Math.floor(year / 10);
171};
172DateUtils.GetCenturyStartYear = function(year) {
173 return 100 * Math.floor(year / 100);
174};
175DateUtils.GetCorrectedYear = function(date, pickerType) {
176 var year = date.getFullYear();
177 return pickerType != ASPx.DatePickerType.Decades ? year : DateUtils.GetDecadeStartYear(year);
178};
179DateUtils.GetCorrectedMonth = function(date, pickerType) {
180 return pickerType < ASPx.DatePickerType.Years ? date.getMonth() : 0;
181};
182DateUtils.GetCorrectedDay = function(date, pickerType) {
183 return pickerType == ASPx.DatePickerType.Days ? date.getDate() : 1;
184};
185DateUtils.CorrectDateByPickerType = function(date, pickerType) {
186 if(!ASPx.IsExists(pickerType))
187  pickerType = ASPx.DatePickerType.Days;
188 if(!date || pickerType == ASPx.DatePickerType.Days)
189  return date;
190 var correctedYear = DateUtils.GetCorrectedYear(date, pickerType);
191 var result = new Date(
192  correctedYear,
193  DateUtils.GetCorrectedMonth(date, pickerType),
194  DateUtils.GetCorrectedDay(date, pickerType),
195  date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()
196 );
197 result.setFullYear(correctedYear);
198 return result;
199};
200DateUtils.GetYearRangeFormatString = function(startYear, rangeLength) {
201 return startYear + " - " + (startYear + rangeLength - 1);
202};
203ASPx.DateUtils = DateUtils;
204var Timer = { };
205Timer.ClearTimer = function(timerID){
206 if(timerID > -1)
207  window.clearTimeout(timerID);
208 return -1;
209};

210Timer.ClearInterval = function(timerID){
211 if(timerID > -1)
212  window.clearInterval(timerID);
213 return -1;
214};
215var setControlBoundTimer = function(handler, control, setTimerFunction, clearTimerFunction, delay) {
216 var timerId;
217 var getTimerId = function() { return timerId; };
218 var controlMainElement = control.GetMainElement();
219 var boundHandler = function() {
220  var controlExists = control && ASPx.GetControlCollection().Get(control.name) === control && control.GetMainElement() === controlMainElement;
221  if(controlExists)
222   handler.aspxBind(control)();
223  else {
224   clearTimerFunction(getTimerId());
225   controlMainElement = null;
226  }
227 };
228 timerId = setTimerFunction(boundHandler, delay);
229 return timerId;
230};
231Timer.SetControlBoundTimeout = function(handler, control, delay) {
232 return setControlBoundTimer(handler, control, window.setTimeout, Timer.ClearTimer, delay);
233};
234Timer.SetControlBoundInterval = function(handler, control, delay) {
235 return setControlBoundTimer(handler, control, window.setInterval, Timer.ClearInterval, delay);
236};
237Timer.Throttle = function(func, delay) {
238 var isThrottled = false,
239   savedArgs,
240   savedThis = this;
241 function wrapper() {
242  if(isThrottled) {
243   savedArgs = arguments;
244   savedThis = this;
245   return;
246  }
247  func.apply(this, arguments);
248  isThrottled = true;
249  setTimeout(function() {
250   isThrottled = false;
251   if(savedArgs) {
252    wrapper.apply(savedThis, savedArgs);
253    savedArgs = null;
254   }
255  }, delay);
256 }
257 wrapper.cancel = function() {
258  clearTimeout(delay);
259  delay = savedArgs = savedThis = null;
260 };
261 return wrapper;
262};
263ASPx.Timer = Timer;
264var Browser = { };
265Browser.UserAgent = navigator.userAgent.toLowerCase();
266Browser.Mozilla = false;
267Browser.IE = false;
268Browser.Firefox = false;
269Browser.Netscape = false;
270Browser.Safari = false;
271Browser.Chrome = false;
272Browser.Opera = false;
273Browser.Edge = false;
274Browser.EdgeWebKit = false;
275Browser.Version = undefined; 
276Browser.MajorVersion = undefined; 
277Browser.WindowsPlatform = false;
278Browser.MacOSPlatform = false;
279Browser.MacOSMobilePlatform = false;
280Browser.AndroidMobilePlatform = false;
281Browser.PlaformMajorVersion = false;
282Browser.WindowsPhonePlatform = false;
283Browser.AndroidDefaultBrowser = false;
284Browser.AndroidChromeBrowser = false;
285Browser.SamsungAndroidDevice = false;
286Browser.WebKitTouchUI = false;
287Browser.MSTouchUI = false;
288Browser.TouchUI = false;
289Browser.WebKitFamily = false; 
290Browser.NetscapeFamily = false; 
291Browser.VirtualKeyboardSupported = false;
292Browser.Info = "";
293Browser.IsQuirksMode = document.compatMode === "BackCompat";
294function indentPlatformMajorVersion(userAgent) {
295 var regex = /(?:(?:windows nt|macintosh|mac os|cpu os|cpu iphone os|android|windows phone|linux) )(\d+)(?:[-0-9_.])*/;
296 var matches = regex.exec(userAgent);
297 if(matches)
298  Browser.PlaformMajorVersion = matches[1];
299}
300function getIECompatibleVersionString() {
301 if(document.compatible) {
302  for(var i = 0; i < document.compatible.length; i++)
303   if(document.compatible[i].userAgent === "IE" && document.compatible[i].version)
304    return document.compatible[i].version.toLowerCase();
305 }
306 return "";
307}
308Browser.IdentUserAgent = function(userAgent, ignoreDocumentMode) {
309 var browserTypesOrderedList = ["Mozilla", "IE", "Firefox", "Netscape", "Safari", "Chrome", "Opera", "Opera10", "EdgeWebKit", "Edge" ];
310 var defaultBrowserType = "IE";
311 var defaultPlatform = "Win";
312 var defaultVersions = { Safari: 2, Chrome: 0.1, Mozilla: 1.9, Netscape: 8, Firefox: 2, Opera: 9, IE: 6, Edge: 12 };
313 if(!userAgent || userAgent.length == 0) {
314  fillUserAgentInfo(browserTypesOrderedList, defaultBrowserType, defaultVersions[defaultBrowserType], defaultPlatform);
315  return;
316 }
317 userAgent = userAgent.toLowerCase();
318 indentPlatformMajorVersion(userAgent);
319 try {
320  var platformIdentStrings = {
321   "Windows": "Win",
322   "Macintosh": "Mac",
323   "Mac OS": "Mac",
324   "Mac_PowerPC": "Mac",
325   "cpu os": "MacMobile",
326   "cpu iphone os": "MacMobile",
327   "Android": "Android",
328   "!Windows Phone": "WinPhone",
329   "!WPDesktop": "WinPhone",
330   "!ZuneWP": "WinPhone"
331  };
332  var optSlashOrSpace = "(?:/|\\s*)?";
333  var version = "(\\d+)(?:\\.((?:\\d+?[1-9])|\\d)0*?)?";
334  var optComma = "(?:,)?";
335  var appleVersion = "(\\d+)(?:\\.((?:\\d+?[1-9])|\\d)" + optComma + "0*?)?"; 
336  var optVersion = "(?:" + version + ")?";
337  var patterns = {
338   Safari: "applewebkit(?:.*?(?:version/" + appleVersion + "[\\.\\w\\d]*?(?:\\s+mobile\/\\S*)?\\s+safari))?",
339   Chrome: "(?:chrome|crios)(?!frame)" + optSlashOrSpace + optVersion,
340   Mozilla: "mozilla(?:.*rv:" + optVersion + ".*Gecko)?",
341   Netscape: "(?:netscape|navigator)\\d*/?\\s*" + optVersion,
342   Firefox: "firefox" + optSlashOrSpace + optVersion,
343   Opera: "(?:opera|\sopr)" + optSlashOrSpace + optVersion,
344   Opera10: "opera.*\\s*version" + optSlashOrSpace + optVersion,
345   IE: "msie\\s*" + optVersion,
346   EdgeWebKit: "edg" + optSlashOrSpace + optVersion,
347   Edge: "edge" + optSlashOrSpace + optVersion
348  };
349  var browserType;
350  var version = -1;
351  for(var i = 0; i < browserTypesOrderedList.length; i++) {
352   var browserTypeCandidate = browserTypesOrderedList[i];
353   var regExp = new RegExp(patterns[browserTypeCandidate], "i");
354   if(regExp.compile)
355    regExp.compile(patterns[browserTypeCandidate], "i");
356   var matches = regExp.exec(userAgent);
357   if(matches && matches.index >= 0) {
358    if(browserType == "IE" && version >= 11 && browserTypeCandidate == "Safari") 
359     continue;
360    browserType = browserTypeCandidate;
361    if(browserType == "Opera10")
362     browserType = "Opera";
363    var tridentPattern = "trident" + optSlashOrSpace + optVersion;
364    version = Browser.GetBrowserVersion(userAgent, matches, tridentPattern, getIECompatibleVersionString());
365    if(browserType == "Mozilla" && version >= 11)
366     browserType = "IE";
367   }
368  }
369  if(!browserType)
370   browserType = defaultBrowserType;
371  var browserVersionDetected = version != -1;
372  if(!browserVersionDetected)
373   version = defaultVersions[browserType];
374  var platform;
375  var minOccurenceIndex = Number.MAX_VALUE;

376  for(var identStr in platformIdentStrings) {
377   if(!platformIdentStrings.hasOwnProperty(identStr)) continue;
378   var importantIdent = identStr.substr(0,1) == "!";
379   var occurenceIndex = userAgent.indexOf((importantIdent ? identStr.substr(1) : identStr).toLowerCase());
380   if(occurenceIndex >= 0 && (occurenceIndex < minOccurenceIndex || importantIdent)) {
381    minOccurenceIndex = importantIdent ? 0 : occurenceIndex;
382    platform = platformIdentStrings[identStr];
383   }
384  }
385  var samsungPattern = "SM-[A-Z]";
386  var matches = userAgent.toUpperCase().match(samsungPattern);
387  var isSamsungAndroidDevice = matches && matches.length > 0;
388  if(platform == "WinPhone" && version < 9)
389   version = Math.floor(getVersionFromTrident(userAgent, "trident" + optSlashOrSpace + optVersion));
390  if(!ignoreDocumentMode && browserType == "IE" && version > 7 && document.documentMode < version)
391   version = document.documentMode;
392  if(platform == "WinPhone")
393   version = Math.max(9, version);
394  if(!platform)
395   platform = defaultPlatform;
396  if(platform == platformIdentStrings["cpu os"] && !browserVersionDetected) 
397   version = 4;
398  fillUserAgentInfo(browserTypesOrderedList, browserType, version, platform, isSamsungAndroidDevice);
399 } catch(e) {
400  fillUserAgentInfo(browserTypesOrderedList, defaultBrowserType, defaultVersions[defaultBrowserType], defaultPlatform);
401 }
402};
403function getVersionFromMatches(matches) {
404 var result = -1;
405 var versionStr = "";
406 if(matches[1]) {
407  versionStr += matches[1];
408  if(matches[2])
409   versionStr += "." + matches[2];
410 }
411 if(versionStr != "") {
412  result = parseFloat(versionStr);
413  if(isNaN(result))
414   result = -1;
415 }
416 return result;
417}
418function getVersionFromTrident(userAgent, tridentPattern) {
419 var tridentDiffFromVersion = 4;
420 var matches = new RegExp(tridentPattern, "i").exec(userAgent);
421 return getVersionFromMatches(matches) + tridentDiffFromVersion;
422}
423Browser.GetBrowserVersion = function(userAgent, matches, tridentPattern, ieCompatibleVersionString) {
424 var version = getVersionFromMatches(matches);
425 if(ieCompatibleVersionString) {
426  var versionFromTrident = getVersionFromTrident(userAgent, tridentPattern);
427  if(ieCompatibleVersionString === "edge" || parseInt(ieCompatibleVersionString) === versionFromTrident)
428   return versionFromTrident;
429 }
430 return version;
431};
432function fillUserAgentInfo(browserTypesOrderedList, browserType, version, platform, isSamsungAndroidDevice) {
433 for(var i = 0; i < browserTypesOrderedList.length; i++) {
434  var type = browserTypesOrderedList[i];
435  Browser[type] = type == browserType;
436 }
437 Browser.Version = Math.floor(10.0 * version) / 10.0;
438 Browser.MajorVersion = Math.floor(Browser.Version);
439 Browser.WindowsPlatform = platform == "Win" || platform == "WinPhone";
440 Browser.MacOSPlatform = platform == "Mac";
441 var isMacWithTouchSupport = platform == "Mac" && (!!window.ontouchstart || getMaxTouchPoints() > 0); 
442 Browser.MacOSMobilePlatform = platform == "MacMobile" || isMacWithTouchSupport;
443 if(Browser.MacOSMobilePlatform)
444  Browser.MacOSPlatform = false;
445 Browser.AndroidMobilePlatform = platform == "Android";
446 Browser.WindowsPhonePlatform = platform == "WinPhone";
447 Browser.WebKitFamily = Browser.Safari || Browser.Chrome || Browser.Opera && Browser.MajorVersion >= 15 || Browser.EdgeWebKit;
448 Browser.NetscapeFamily = Browser.Netscape || Browser.Mozilla || Browser.Firefox;
449 Browser.WebKitTouchUI = Browser.MacOSMobilePlatform || Browser.AndroidMobilePlatform;
450 var isIETouchUI = Browser.IE && Browser.MajorVersion > 9 && Browser.WindowsPlatform && Browser.UserAgent.toLowerCase().indexOf("touch") >= 0;
451 Browser.MSTouchUI = isIETouchUI || ((Browser.Edge || (Browser.EdgeWebKit && !Browser.AndroidMobilePlatform)) && !!getMaxTouchPoints());
452 Browser.TouchUI = Browser.WebKitTouchUI || Browser.MSTouchUI;
453 Browser.MobileUI = Browser.WebKitTouchUI || Browser.WindowsPhonePlatform;
454 Browser.AndroidDefaultBrowser = Browser.AndroidMobilePlatform && !Browser.Chrome;
455 Browser.AndroidChromeBrowser = Browser.AndroidMobilePlatform && Browser.Chrome;
456 if(isSamsungAndroidDevice)
457  Browser.SamsungAndroidDevice = isSamsungAndroidDevice;
458 if(Browser.MSTouchUI) {
459  var isARMArchitecture = Browser.UserAgent.toLowerCase().indexOf("arm;") > -1;    
460  Browser.VirtualKeyboardSupported = isARMArchitecture || Browser.WindowsPhonePlatform;   
461 } else {
462  Browser.VirtualKeyboardSupported = Browser.MobileUI;
463 }
464 fillDocumentElementBrowserTypeClassNames(browserTypesOrderedList);
465}
466function getMaxTouchPoints() { 
467 var result = navigator.maxTouchPoints;

468 if(window.testingTouchMode)
469  result = 10;
470 return result;
471}
472function fillDocumentElementBrowserTypeClassNames(browserTypesOrderedList) {
473 var documentElementClassName = "";
474 var browserTypeslist = browserTypesOrderedList.concat(["WindowsPlatform", "MacOSPlatform", "MacOSMobilePlatform", "AndroidMobilePlatform",
475   "WindowsPhonePlatform", "WebKitFamily", "WebKitTouchUI", "MSTouchUI", "TouchUI", "AndroidDefaultBrowser", "MobileUI"]);
476 for(var i = 0; i < browserTypeslist.length; i++) {
477  var type = browserTypeslist[i];
478  if(Browser[type])
479   documentElementClassName += "dx" + type + " ";
480 }
481 documentElementClassName += "dxBrowserVersion-" + Browser.MajorVersion;
482 if(document && document.documentElement) {
483  if(document.documentElement.className != "")
484   documentElementClassName = " " + documentElementClassName;
485  document.documentElement.className += documentElementClassName;
486  Browser.Info = documentElementClassName;
487 }
488}
489Browser.SupportsStickyPositioning = function() {
490 return this.Chrome && this.MajorVersion >= 56
491  || this.Firefox && this.MajorVersion >= 32
492  || this.Safari && this.MajorVersion >= 6 && this.Version !== "6"
493  || this.Opera && this.MajorVersion >= 42;
494};
495Browser.IdentUserAgent(Browser.UserAgent);
496ASPx.Browser = Browser;
497ASPx.BlankUrl = Browser.Opera ? "about:blank" : "";
498ASPx.FillDocumentElementDXThemeCssClassName = function(dxThemeName) {
499 ASPx.AddClassNameToElement(document.documentElement, "dxTheme-" + dxThemeName);
500};
501var Data = { };
502Data.ArrayInsert = function(array, element, position){
503 if(0 <= position && position < array.length){
504  for(var i = array.length; i > position; i --)
505   array[i] = array[i - 1];
506  array[position] = element;
507 }
508 else
509  array.push(element);
510};
511Data.ArrayRemove = function(array, element){
512 var index = Data.ArrayIndexOf(array, element);
513 if(index > -1) Data.ArrayRemoveAt(array, index);
514};
515Data.ArrayRemoveAt = function(array, index){
516 if(index >= 0  && index < array.length){
517  for(var i = index; i < array.length - 1; i++)
518   array[i] = array[i + 1];
519  array.pop();
520 }
521};
522Data.ArrayClear = function(array){
523 while(array.length > 0)
524  array.pop();
525};
526Data.ArrayIndexOf = function(array, element, comparer) {
527 if(!comparer) {
528  for(var i = 0; i < array.length; i++) {
529   if(array[i] == element)
530    return i;
531  }
532 } else {
533  for(var i = 0; i < array.length; i++) {
534   if(comparer(array[i], element))
535    return i;
536  }
537 }
538 return -1;
539};
540Data.ArrayContains = function(array, element) { 
541 return Data.ArrayIndexOf(array, element) >= 0;
542};
543Data.ArrayEqual = function(array1, array2) {
544 var count1 = array1.length;
545 var count2 = array2.length;
546 if(count1 != count2)
547  return false;
548 for(var i = 0; i < count1; i++)
549  if(array1[i] != array2[i])
550   return false;
551 return true;
552};
553Data.ArraySame = function(array1, array2) {
554 if(array1.length !== array2.length)
555  return false;
556 return array1.every(function(elem) { return Data.ArrayContains(array2, elem); });
557};
558Data.ArrayGetIntegerEdgeValues = function(array) {
559 var arrayToSort = Data.CollectionToArray(array);
560 Data.ArrayIntegerAscendingSort(arrayToSort);
561 return {
562  start: arrayToSort[0],
563  end: arrayToSort[arrayToSort.length - 1]
564 };
565};
566Data.ArrayIntegerAscendingSort = function(array){
567 Data.ArrayIntegerSort(array);
568};
569Data.ArrayIntegerSort = function(array, desc) {
570 array.sort(function(i1, i2) {
571  var res = 0;
572  if(i1 > i2)
573   res = 1;
574  else if(i1 < i2)
575   res = -1;
576  if(desc)
577   res *= -1;
578  return res;
579 });
580};
581Data.CollectionsUnionToArray = function(firstCollection, secondCollection) {
582 var result = [];
583 var firstCollectionLength = firstCollection.length;
584 var secondCollectionLength = secondCollection.length;
585 for(var i = 0; i < firstCollectionLength + secondCollectionLength; i++) {
586  if(i < firstCollectionLength)
587   result.push(firstCollection[i]);
588  else
589   result.push(secondCollection[i - firstCollectionLength]);
590 }
591 return result;
592};
593Data.CollectionToArray = function(collection) {
594 var array = [];
595 for(var i = 0; i < collection.length; i++)
596  array.push(collection[i]);
597 return array;
598};

599Data.CreateHashTableFromArray = function(array) {
600 var hash = [];
601 for(var i = 0; i < array.length; i++)
602  hash[array[i]] = 1;
603 return hash;
604};
605Data.CreateIndexHashTableFromArray = function(array) {
606 var hash = [];
607 for(var i = 0; i < array.length; i++)
608  hash[array[i]] = i;
609 return hash;
610};
611Data.ArrayToHash = function(array, getKeyFunc, getValueFunc) {
612 if(!(array instanceof Array)) 
613  return { };
614 return array.reduce(function(map, element, index) { 
615  var key = getKeyFunc(element, index);
616  var value = getValueFunc(element, index);
617  map[key] = value;
618  return map; 
619 }, { });
620};
621Data.Sum = function(array, getValueFunc) {
622 if(!(array instanceof Array)) 
623  return 0;
624 return array.reduce(function(prevValue, item) {
625  var value = getValueFunc ? getValueFunc(item) : item;
626  if(!ASPx.IsNumber(value))
627   value = 0;
628  return prevValue + value;
629 }, 0);
630};
631Data.Min = function(array, getValueFunc) { return CalculateArrayMinMax(array, getValueFunc, false); };
632Data.Max = function(array, getValueFunc) { return CalculateArrayMinMax(array, getValueFunc, true); };
633var CalculateArrayMinMax = function(array, getValueFunc, isMax) {
634 if(!(array instanceof Array)) 
635  return 0;
636 var startValue = isMax ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
637 return array.reduce(function(prevValue, item) {
638  var value = getValueFunc ? getValueFunc(item) : item;
639  if(!ASPx.IsNumber(value))
640   value = startValue;
641  var func = isMax ? Math.max : Math.min;
642  return func(value, prevValue);
643 }, startValue);
644};
645var defaultBinarySearchComparer = function(array, index, value) {
646 var arrayElement = array[index];
647 if(arrayElement == value)
648  return 0;
649 else
650  return arrayElement < value ? -1 : 1;
651};
652Data.NearestLeftBinarySearchComparer = function(array, index, value) { 
653 var arrayElement = array[index];
654 var leftPoint = arrayElement < value;
655 var lastLeftPoint = leftPoint && index == array.length - 1;
656 var nearestLeftPoint = lastLeftPoint || (leftPoint && array[index + 1] >= value);
657 if(nearestLeftPoint)
658  return 0;
659 else
660  return arrayElement < value ? -1 : 1;
661};
662Data.ArrayBinarySearch = function(array, value, binarySearchComparer, startIndex, length) {
663 if(!binarySearchComparer)
664  binarySearchComparer = defaultBinarySearchComparer;
665 if(!ASPx.IsExists(startIndex))
666  startIndex = 0;
667 if(!ASPx.IsExists(length))
668  length = array.length - startIndex;
669 var endIndex = (startIndex + length) - 1;
670 while(startIndex <= endIndex) {
671  var middle = (startIndex + ((endIndex - startIndex) >> 1));
672  var compareResult = binarySearchComparer(array, middle, value);
673  if(compareResult == 0)
674   return middle;
675  if(compareResult < 0)
676   startIndex = middle + 1;
677  else
678   endIndex = middle - 1;
679 }
680 return -(startIndex + 1);
681};
682Data.ArrayFlatten = function(arrayOfArrays) {
683 return [].concat.apply([], arrayOfArrays);
684};
685Data.GetDistinctArray = function(array) {
686 var resultArray = [];
687 for(var i = 0; i < array.length; i++) {
688  var currentEntry = array[i];
689  if(Data.ArrayIndexOf(resultArray, currentEntry) == -1) {
690   resultArray.push(currentEntry);
691  }
692 }
693 return resultArray;
694};
695Data.ForEach = function(arr, callback) {
696 if(Array.prototype.forEach) {
697  Array.prototype.forEach.call(arr, callback);
698 } else {
699  for(var i = 0, len = arr.length; i < len; i++) {
700   callback(arr[i], i, arr);
701  }
702 }
703};
704Data.MergeHashTables = function(target, object) {
705 if(!object || typeof (object) == "string")
706  return target;
707 if(!target)
708  target = {};
709 for(var key in object)
710  if(key && !(key in target))
711   target[key] = object[key];
712 return target;
713};
714Data.Range = function(count, start) {
715 count = parseInt(count) || 0;
716 start = parseInt(start) || 0;
717 if(count < 0) count = 0;
718 if(start < 0) start = 0;
719 return Array.apply(null, Array(count)).map(function(val, i) { return start + i; });
720};
721ASPx.Data = Data;
722var Cookie = { };
723Cookie.DelCookie = function(name){
724 setCookieInternal(name, "", new Date(1970, 1, 1));
725};
726Cookie.GetCookie = function(name) {
727 name = escape(name);
728 var cookies = document.cookie.split(';');
729 for(var i = 0; i < cookies.length; i++) {
730  var cookie = Str.Trim(cookies[i]);
731  if(cookie.indexOf(name + "=") == 0)
732   return unescape(cookie.substring(name.length + 1, cookie.length));
733  else if(cookie.indexOf(name + ";") == 0 || cookie === name)
734   return "";
735 }
736 return null;
737};
738Cookie.SetCookie = function(name, value, expirationDate){
739 if(!ASPx.IsExists(value)) {
740  Cookie.DelCookie(name);
741  return;
742 }
743 if(!ASPx.Ident.IsDate(expirationDate)) {
744  expirationDate = new Date();
745  expirationDate.setFullYear(expirationDate.getFullYear() + 1);
746 }
747 setCookieInternal(name, value, expirationDate);
748};
749function setCookieInternal(name, value, date){
750 document.cookie = escape(name) + "=" + escape(value.toString()) + "; expires=" + date.toGMTString() + "; path=/";
751}
752ASPx.Cookie = Cookie;

753ASPx.ImageUtils = {
754 GetImageSrc: function (image){
755  return image.src;
756 },
757 SetImageSrc: function(image, src){
758  image.src = src;
759 },
760 SetSize: function(image, width, height){
761  image.style.width = width + "px";
762  image.style.height = height + "px";
763 },
764 GetSize: function(image, isWidth) {
765  return (isWidth ? ASPx.GetElementOffsetWidth(image) : ASPx.GetElementOffsetHeight(image));
766 }
767};
768var Str = { };
769Str.ApplyReplacement = function(text, replecementTable) {
770 if(typeof(text) != "string")
771  text = text.toString();
772 for(var i = 0; i < replecementTable.length; i++) {
773  var replacement = replecementTable[i];
774  text = text.replace(replacement[0], replacement[1]);
775 }
776 return text;
777};
778Str.CompleteReplace = function(text, regexp, newSubStr) {
779 if(typeof(text) != "string")
780  text = text.toString();
781 var textPrev;
782 do {
783  textPrev = text;
784  text = text.replace(regexp, newSubStr);
785 } while(text != textPrev);
786 return text;
787};
788Str.EncodeHtml = function(html) {
789 return Str.ApplyReplacement(html, [
790  [ /&amp;/g,  '&ampx;'  ], [ /&/g, '&amp;'  ],
791  [ /&quot;/g, '&quotx;' ], [ /"/g, '&quot;' ],
792  [ /&lt;/g,   '&ltx;'   ], [ /</g, '&lt;'   ],
793  [ /&gt;/g,   '&gtx;'   ], [ />/g, '&gt;'   ]
794 ]);
795};
796Str.DecodeHtml = function(html) {
797 return Str.ApplyReplacement(html, [
798  [ /&gt;/g,   '>' ], [ /&gtx;/g,  '&gt;'   ],
799  [ /&lt;/g,   '<' ], [ /&ltx;/g,  '&lt;'   ],
800  [ /&quot;/g, '"' ], [ /&quotx;/g,'&quot;' ],
801  [ /&amp;/g,  '&' ], [ /&ampx;/g, '&amp;'  ]
802 ]);
803};
804Str.DecodeHtmlViaTextArea = function(html) {
805 var textArea = document.createElement("TEXTAREA");
806 setInnerHtmlInternal(textArea, html);
807 return textArea.value;
808};
809Str.TrimStart = function(str) { 
810 return trimInternal(str, true);
811};
812Str.TrimEnd = function(str) { 
813 return trimInternal(str, false, true);
814};
815Str.Trim = function(str) { 
816 return trimInternal(str, true, true); 
817};
818Str.EscapeForRegEx = function(str) {
819 return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
820};

821var whiteSpaces = { 
822 0x0009: 1, 0x000a: 1, 0x000b: 1, 0x000c: 1, 0x000d: 1, 0x0020: 1, 0x0085: 1, 
823 0x00a0: 1, 0x1680: 1, 0x180e: 1, 0x2000: 1, 0x2001: 1, 0x2002: 1, 0x2003: 1, 
824 0x2004: 1, 0x2005: 1, 0x2006: 1, 0x2007: 1, 0x2008: 1, 0x2009: 1, 0x200a: 1, 
825 0x200b: 1, 0x2028: 1, 0x2029: 1, 0x202f: 1, 0x205f: 1, 0x3000: 1, 0xfeff: 1
826};
827var caretWidth = 1;
828function trimInternal(source, trimStart, trimEnd) {
829 var len = source.length;
830 if(!len)
831  return source;
832 var result = "";
833 if(len < 0xBABA1) 
834  result = trimSource(source, trimStart, trimEnd);
835 else
836  result = trimLargeSource(source, len, trimStart, trimEnd);
837 return Str.ClearString(result);
838}
839function trimSource(source, trimStart, trimEnd) {
840 var result = source;
841 if(trimStart)
842  result = result.replace(/^\s+/, "");
843 if(trimEnd)
844  result = result.replace(/\s+$/, "");
845 return result;
846}
847function trimLargeSource(source, len, trimStart, trimEnd) {
848 var start = 0;
849 if(trimEnd) {
850  while(len > 0 && whiteSpaces[source.charCodeAt(len - 1)]) {
851   len--;
852  }
853 }
854 if(trimStart && len > 0) {
855  while(start < len && whiteSpaces[source.charCodeAt(start)]) {
856   start++;
857  }
858 }
859 return source.substring(start, len);
860}
861var inlineStringLength = 12;
862Str.ClearString = function(str) { 
863 if(!ASPx.Browser.Chrome)
864  return str;
865 return str.length < inlineStringLength ? str : JSON.parse(JSON.stringify(str));
866};
867Str.Insert = function(str, subStr, index) { 
868 var leftText = str.slice(0, index);
869 var rightText = str.slice(index);
870 return leftText + subStr + rightText;
871};
872Str.InsertEx = function(str, subStr, startIndex, endIndex) { 
873 var leftText = str.slice(0, startIndex);
874 var rightText = str.slice(endIndex);
875 return leftText + subStr + rightText;
876};
877var greekSLFSigmaChar = String.fromCharCode(962);
878var greekSLSigmaChar = String.fromCharCode(963);
879Str.PrepareStringForFilter = function(s, saveCaseSensitive){
880 if(!saveCaseSensitive)
881  s = s.toLowerCase();
882 if(ASPx.Browser.WebKitFamily) {
883  return s.replace(new RegExp(greekSLFSigmaChar, "g"), greekSLSigmaChar);
884 }
885 return s;
886};
887Str.GetCoincideCharCount = function(text, filter, textMatchingDelegate) {
888 var coincideText = ASPx.Str.PrepareStringForFilter(filter);
889 var originText = ASPx.Str.PrepareStringForFilter(text);
890 while(coincideText != "" && !textMatchingDelegate(originText, coincideText)) {
891  coincideText = coincideText.slice(0, -1);
892 }
893 return coincideText.length;
894};
895Str.EndsWith = function(str, suffix) {
896 return str.indexOf(suffix, str.length - suffix.length) !== -1;
897};
898ASPx.Str = Str;
899var Xml = { };
900Xml.Parse = function(xmlStr) {
901 if(window.DOMParser) {
902  var parser = new DOMParser();
903  return parser.parseFromString(xmlStr, "text/xml");
904 }
905 else if(window.ActiveXObject) {
906  var xmlDoc = new window.ActiveXObject("Microsoft.XMLDOM");
907  if(xmlDoc) {
908   xmlDoc.async = false;
909   xmlDoc.loadXML(xmlStr);
910   return xmlDoc;
911  }
912 }
913 return null;
914};
915ASPx.Xml = Xml;
916ASPx.Key = {
917 F1     : 112,
918 F2     : 113,
919 F3     : 114,
920 F4     : 115,
921 F5     : 116,
922 F6     : 117,
923 F7     : 118,
924 F8     : 119,

925 F9     : 120,
926 F10    : 121,
927 F11    : 122,
928 F12    : 123,
929 Ctrl   : 17,
930 Shift  : 16,
931 Alt    : 18,
932 Enter  : 13,
933 Home   : 36,
934 End    : 35,
935 Left   : 37,
936 Right  : 39,
937 Up     : 38,
938 Down   : 40,
939 PageUp    : 33,
940 PageDown  : 34,
941 Esc    : 27,
942 Space  : 32,
943 Tab    : 9,
944 Backspace : 8,
945 Delete    : 46,
946 Insert    : 45,
947 ContextMenu  : 93,
948 Windows   : 91,
949 Decimal   : 110,
950 CapsLock  : 20
951};
952ASPx.ModifierKey = {
953 None: 0,
954 Ctrl: 1 << (0 + 16),
955 Shift: 1 << (2 + 16),
956 Alt: 1 << (4 + 16),
957 Meta: 1 << (8 + 16)
958};
959ASPx.KeyCode = {
960 Backspace : 8,
961 Tab    : 9,
962 Enter  : 13,
963 Pause  : 19,
964 CapsLock  : 20,
965 Esc    : 27,
966 Space  : 32,
967 PageUp    : 33,
968 PageDown  : 34,
969 End    : 35,
970 Home   : 36,
971 Left   : 37,
972 Up     : 38,
973 Right  : 39,
974 Down   : 40,
975 Insert    : 45,
976 Delete    : 46,
977 Key_0  : 48,
978 Key_1  : 49,
979 Key_2  : 50,
980 Key_3  : 51,
981 Key_4  : 52,
982 Key_5  : 53,
983 Key_6  : 54,
984 Key_7  : 55,
985 Key_8  : 56,
986 Key_9  : 57,
987 Key_a  : 65,
988 Key_b  : 66,
989 Key_c  : 67,
990 Key_d  : 68,
991 Key_e  : 69,
992 Key_f  : 70,
993 Key_g  : 71,
994 Key_h  : 72,
995 Key_i  : 73,
996 Key_j  : 74,
997 Key_k  : 75,
998 Key_l  : 76,
999 Key_m  : 77,
1000 Key_n  : 78,
1001 Key_o  : 79,
1002 Key_p  : 80,
1003 Key_q  : 81,
1004 Key_r  : 82,
1005 Key_s  : 83,
1006 Key_t  : 84,
1007 Key_u  : 85,
1008 Key_v  : 86,
1009 Key_w  : 87,
1010 Key_x  : 88,
1011 Key_y  : 89,
1012 Key_z  : 90,
1013 Windows   : 91,
1014 ContextMenu  : 93,
1015 Numpad_0  : 96,
1016 Numpad_1  : 97,
1017 Numpad_2  : 98,
1018 Numpad_3  : 99,
1019 Numpad_4  : 100,
1020 Numpad_5  : 101,
1021 Numpad_6  : 102,
1022 Numpad_7  : 103,
1023 Numpad_8  : 104,
1024 Numpad_9  : 105,
1025 Multiply  : 106,
1026 Add    : 107,
1027 Subtract  : 109,
1028 Decimal   : 110,
1029 Divide    : 111,
1030 F1     : 112,
1031 F2     : 113,
1032 F3     : 114,
1033 F4     : 115,
1034 F5     : 116,
1035 F6     : 117,
1036 F7     : 118,
1037 F8     : 119,

1038 F9     : 120,
1039 F10    : 121,
1040 F11    : 122,
1041 F12    : 123,
1042 NumLock   : 144,
1043 ScrollLock   : 145,
1044 Semicolon : 186,
1045 Equals    : 187,
1046 Comma  : 188,
1047 Dash   : 189,
1048 Period    : 190,
1049 ForwardSlash : 191,
1050 GraveAccent  : 192,
1051 OpenBracket  : 219,
1052 BackSlash : 220,
1053 CloseBracket : 221,
1054 SingleQuote  : 222
1055};
1056ASPx.ScrollBarMode = { Hidden: 0, Visible: 1, Auto: 2 };
1057ASPx.ColumnResizeMode = { None: 0, Control: 1, NextColumn: 2 };
1058var Selection = { };
1059Selection.Set = function(input, startPos, endPos, scrollToSelection, isApi) {
1060 if(!ASPx.IsExistsElement(input))
1061  return;
1062 var isInputFocused = ASPx.GetActiveElement() === input;
1063 var isInputNativeFocusLocked = ASPx.VirtualKeyboardUI.getInputNativeFocusLocked();
1064 if(!isApi && Browser.VirtualKeyboardSupported && (!isInputFocused || isInputNativeFocusLocked))
1065  return;
1066 var textLen = input.value.length;
1067 startPos = ASPx.GetDefinedValue(startPos, 0);
1068 endPos = ASPx.GetDefinedValue(endPos, textLen);
1069 if(startPos < 0)
1070  startPos = 0;
1071 if(endPos < 0 || endPos > textLen)
1072  endPos = textLen;
1073 if(startPos > endPos)
1074  startPos = endPos;
1075 var makeReadOnly = false;
1076 if(Browser.WebKitFamily && input.readOnly) {
1077  input.readOnly = false;
1078  makeReadOnly = true;
1079 }
1080 try {
1081  if(Browser.Firefox && Browser.Version >= 8) 
1082   input.setSelectionRange(startPos, endPos, "backward");
1083  else {
1084   forceScrollToSelectionRange(input, startPos, endPos);
1085   input.setSelectionRange(startPos, endPos);
1086  }
1087  if(Browser.Opera || Browser.Firefox || Browser.Chrome || Browser.Edge || Browser.EdgeWebKit) 
1088   input.focus();
1089 } catch(e) { }
1090 if(scrollToSelection && input.tagName == 'TEXTAREA') {
1091  var scrollHeight = input.scrollHeight;
1092  var approxCaretPos = startPos;
1093  var scrollTop = Math.max(Math.round(approxCaretPos * scrollHeight / textLen  - input.clientHeight / 2), 0);
1094  input.scrollTop = scrollTop;
1095 }
1096 if(makeReadOnly)
1097  input.readOnly = true;
1098};
1099var getTextWidthBeforePos = function(input, pos) {
1100 return ASPx.GetSizeOfText(input.value.toString().substr(0, pos), ASPx.GetCurrentStyle(input)).width;
1101};
1102var forceScrollToSelectionRange = function(input, startPos, endPos) {
1103 if(endPos === input.value.length)
1104  input.scrollLeft = input.scrollWidth;
1105 else if(startPos === 0 && endPos === 0)
1106  input.scrollLeft = 0;
1107 else {
1108  var inputRawWidth = ASPx.GetElementOffsetWidth(input) - ASPx.GetLeftRightBordersAndPaddingsSummaryValue(input);
1109  if(inputRawWidth < input.scrollWidth) {
1110   var widthBeforeEndPos = getTextWidthBeforePos(input, endPos) + caretWidth;
1111   if(input.scrollLeft < widthBeforeEndPos - inputRawWidth)
1112    input.scrollLeft = widthBeforeEndPos - inputRawWidth;
1113   else {
1114    var widthBeforeStartPos = getTextWidthBeforePos(input, startPos) - caretWidth;
1115    if(input.scrollLeft > widthBeforeStartPos)
1116     input.scrollLeft = widthBeforeStartPos;
1117   }
1118  }
1119 }
1120};
1121Selection.GetInfo = function(input) {
1122 var start, end;
1123 try {
1124  start = input.selectionStart;
1125  end = input.selectionEnd;
1126 } catch (e) {
1127 }
1128 return { startPos: start, endPos: end };
1129};
1130Selection.GetExtInfo = function(input) {
1131 var start = 0, end = 0;
1132 try {
1133  start = input.selectionStart;
1134  end = input.selectionEnd;
1135 } catch (e) {
1136 }
1137 return {startPos: start, endPos: end}; 
1138};
1139Selection.SetCaretPosition = function(input, caretPos) {
1140 if(typeof caretPos === "undefined" || caretPos < 0)
1141  caretPos = input.value.length;
1142 Selection.Set(input, caretPos, caretPos, true);
1143};
1144Selection.GetCaretPosition = function(element, isDialogMode) {
1145 var pos = 0;
1146 if("selectionStart" in element) {
1147  pos = element.selectionStart;
1148 } else if("selection" in document) {
1149  element.focus();
1150  var sel = document.selection.createRange(),
1151   selLength = document.selection.createRange().text.length;
1152  sel.moveStart("character", -element.value.length);
1153  pos = sel.text.length - selLength;
1154 }
1155 if(isDialogMode && !pos) {
1156  pos = element.value.length - 1;
1157 }
1158 return pos;
1159};
1160Selection.Clear = function() {
1161 try {
1162  if(window.getSelection) {
1163   window.getSelection().removeAllRanges();
1164  }
1165  else if(document.selection) {
1166   if(document.selection.empty)
1167    document.selection.empty();
1168   else if(document.selection.clear)
1169    document.selection.clear();
1170  }
1171 } catch(e) {
1172 }
1173};
1174Selection.ClearOnMouseMove = function(evt) {
1175 Selection.Clear();
1176};
1177Selection.SetElementSelectionEnabled = function(element, value) {
1178 var userSelectValue = value ? "" : "none";
1179 var func = value ? Evt.DetachEventFromElement : Evt.AttachEventToElement;
1180 if(Browser.Firefox)
1181  element.style.MozUserSelect = userSelectValue;
1182 else if(Browser.WebKitFamily)
1183  element.style.webkitUserSelect = userSelectValue;
1184 else if(Browser.Edge)
1185  element.style.msUserSelect = userSelectValue;
1186 else if(Browser.Opera)
1187  func(element, "mousemove", Selection.Clear);
1188 else {
1189  func(element, "selectstart", ASPx.FalseFunction);
1190  func(element, "mousemove", Selection.Clear);
1191 }
1192};
1193Selection.SetElementAsUnselectable = function(element, isWithChild, recursive) {
1194 if(element && element.nodeType == 1) {
1195  element.unselectable = "on";
1196  if(Browser.NetscapeFamily)
1197   element.onmousedown = ASPx.FalseFunction;
1198  if(Browser.WebKitFamily)
1199   Evt.AttachEventToElement(element, "mousedown", Evt.PreventEventAndBubble);

1200  if(isWithChild === true){
1201   for(var j = 0; j < element.childNodes.length; j ++)
1202    Selection.SetElementAsUnselectable(element.childNodes[j], (!!recursive ? true : false), (!!recursive));
1203  }
1204 }
1205};
1206Selection.AreEqual = function(selection1, selection2) {
1207 return selection1.startPos === selection2.startPos && selection1.endPos === selection2.endPos;
1208};
1209ASPx.Selection = Selection;
1210var MouseScroller = { };
1211MouseScroller.MinimumOffset = 10;
1212MouseScroller.Create = function(getElement, getScrollXElement, getScrollYElement, needPreventScrolling, vertRecursive, onMouseDown, onMouseMove, onMouseUp, onMouseUpMissed) {
1213 var element = getElement();
1214 if(!element) 
1215  return;
1216 if(!element.dxMouseScroller)
1217  element.dxMouseScroller = new MouseScroller.Extender(getElement, getScrollXElement, getScrollYElement, needPreventScrolling, vertRecursive, onMouseDown, onMouseMove, onMouseUp, onMouseUpMissed);
1218 return element.dxMouseScroller;
1219};
1220MouseScroller.Extender = function(getElement, getScrollXElement, getScrollYElement, needPreventScrolling, vertRecursive, onMouseDown, onMouseMove, onMouseUp, onMouseUpMissed) {
1221 this.getElement = getElement;
1222 this.getScrollXElement = getScrollXElement;
1223 this.getScrollYElement = getScrollYElement;
1224 this.needPreventScrolling = needPreventScrolling;
1225 this.vertRecursive = !!vertRecursive;
1226 this.createHandlers(onMouseDown || function() { }, onMouseMove || function() { }, onMouseUp || function() { }, onMouseUpMissed || function() { });
1227 this.update();
1228};
1229MouseScroller.Extender.prototype = {
1230 update: function() {
1231  if(this.element)
1232   Evt.DetachEventFromElement(this.element, ASPx.TouchUIHelper.touchMouseDownEventName, this.mouseDownHandler);
1233  this.element = this.getElement();
1234  Evt.AttachEventToElement(this.element, ASPx.TouchUIHelper.touchMouseDownEventName, this.mouseDownHandler);  
1235  Evt.AttachEventToElement(this.element, "click", this.mouseClickHandler);   
1236  if(Browser.MSTouchUI && this.element.className.indexOf(ASPx.TouchUIHelper.msTouchDraggableClassName) < 0)
1237   this.element.className += " " + ASPx.TouchUIHelper.msTouchDraggableClassName;
1238  this.scrollXElement = this.getScrollXElement();
1239  this.scrollYElement = this.getScrollYElement();
1240 },
1241 createHandlers: function(onMouseDown, onMouseMove, onMouseUp, onMouseUpMissed) {
1242  var mouseDownCounter = 0;
1243  this.onMouseDown = onMouseDown;
1244  this.onMouseMove = onMouseMove;
1245  this.onMouseUp = onMouseUp;  
1246  this.mouseDownHandler = function(e) {
1247   if(mouseDownCounter++ > 0) {
1248    this.finishScrolling();
1249    onMouseUpMissed();
1250   }
1251   var eventSource = Evt.GetEventSource(e);
1252   var requirePreventCustonScroll = ASPx.IsExists(ASPx.TouchUIHelper.RequirePreventCustomScroll) && ASPx.TouchUIHelper.RequirePreventCustomScroll(eventSource, this.element);
1253   this.requirePreventScroll = requirePreventCustonScroll || this.needPreventScrolling && this.needPreventScrolling(eventSource);
1254   if(this.requirePreventScroll)
1255    return;
1256   this.scrollableTreeLine = this.GetScrollableElements();
1257   this.firstX = this.prevX = Evt.GetEventX(e);
1258   this.firstY = this.prevY = Evt.GetEventY(e);
1259   Evt.AttachEventToDocument(ASPx.TouchUIHelper.touchMouseMoveEventName, this.mouseMoveHandler);
1260   Evt.AttachEventToDocument(ASPx.TouchUIHelper.touchMouseUpEventName, this.mouseUpHandler);
1261   this.onMouseDown(e);
1262  }.aspxBind(this);
1263  this.mouseMoveHandler = function(e) {
1264   if(ASPx.TouchUIHelper.isGesture)
1265    return;
1266   var x = Evt.GetEventX(e);
1267   var y = Evt.GetEventY(e);
1268   var xDiff = this.prevX - x;
1269   var yDiff = this.prevY - y;
1270   if(this.vertRecursive) {
1271    var isTopDirection = yDiff < 0;
1272    this.scrollYElement = this.GetElementForVertScrolling(isTopDirection, this.prevIsTopDirection, this.scrollYElement);
1273    this.prevIsTopDirection = isTopDirection;
1274   }
1275   if(this.scrollXElement && xDiff != 0)
1276    this.scrollXElement.scrollLeft += xDiff;
1277   if(this.scrollYElement && yDiff != 0) {
1278    this.scrollYElement.scrollTop += yDiff;
1279    var isOuterScrollableElement = this.scrollableTreeLine[this.scrollableTreeLine.length - 1] == this.scrollYElement;
1280    if(isOuterScrollableElement)
1281     y += yDiff;
1282   }
1283   this.prevX = x;
1284   this.prevY = y;
1285   Evt.PreventEvent(e);
1286   this.onMouseMove(e);
1287  }.aspxBind(this);
1288  this.mouseUpHandler = function(e) {
1289   this.finishScrolling();
1290   this.onMouseUp(e);
1291  }.aspxBind(this);
1292  this.mouseClickHandler = function(e){

1293   if(this.requirePreventScroll || (ASPx.IsExists(e.isTrusted) && !e.isTrusted))
1294    return;
1295   var xDiff = this.firstX - Evt.GetEventX(e);
1296   var yDiff = this.firstY - Evt.GetEventY(e);
1297   if(xDiff > MouseScroller.MinimumOffset || yDiff > MouseScroller.MinimumOffset)
1298    return Evt.PreventEventAndBubble(e);
1299  }.aspxBind(this);
1300  this.finishScrolling = function() {
1301   Evt.DetachEventFromDocument(ASPx.TouchUIHelper.touchMouseMoveEventName, this.mouseMoveHandler);
1302   Evt.DetachEventFromDocument(ASPx.TouchUIHelper.touchMouseUpEventName, this.mouseUpHandler);
1303   this.scrollableTreeLine = [];
1304   this.prevIsTopDirection = null;
1305   mouseDownCounter--;
1306  };
1307 },
1308 GetScrollableElements: function() {
1309  if(!this.vertRecursive) return [ ];
1310  var isHtmlScrollableElement = !ASPx.Browser.IsQuirksMode && !ASPx.Browser.Safari;
1311  var outerScrollableElementTag = isHtmlScrollableElement ? "HTML" : "BODY";
1312  return ASPx.GetElementTreeLine(this.element, null, function(el) { return el == document; })
1313   .filter(function(el) {
1314    var tagName = el.tagName;
1315    if(isHtmlScrollableElement && tagName == "BODY")
1316     return false;
1317    return ASPx.IsScrollableElement(el, false, true) || tagName == outerScrollableElementTag || el.dxScrollable;
1318   }.bind(this));
1319 },
1320 GetElementForVertScrolling: function(currentIsTop, prevIsTop, prevElement) {
1321  if(prevElement && currentIsTop === prevIsTop && this.GetVertScrollExcess(prevElement, currentIsTop) > 0)
1322   return prevElement;
1323  for(var i = 0; i < this.scrollableTreeLine.length; i++) {
1324   var element = this.scrollableTreeLine[i];
1325   var excess = this.GetVertScrollExcess(element, currentIsTop);
1326   if(excess > 0)
1327    return element;
1328  }
1329  return null;
1330 },
1331 GetVertScrollExcess: function(element, isTop) {
1332  if(isTop)
1333   return element.scrollTop;
1334  var isDocument = element.tagName == "HTML" || ASPx.Browser.Safari && !ASPx.Browser.IsQuirksMode && element.tagName == "BODY";
1335  var clientHeight = isDocument ? ASPx.GetDocumentClientHeight() : element.clientHeight;
1336  return element.scrollHeight - clientHeight - element.scrollTop;
1337 }
1338};
1339ASPx.MouseScroller = MouseScroller;
1340var Evt = { };
1341Evt.GetEvent = function(evt){
1342 return evt; 
1343};
1344Evt.IsEventPrevented = function(evt) {
1345 return evt.defaultPrevented || evt.returnValue === false;
1346};
1347Evt.PreventEvent = function(evt){
1348 if(evt.preventDefault) {
1349  if(evt.cancelable)
1350   evt.preventDefault();
1351 }
1352 else
1353  evt.returnValue = false;
1354 return false;
1355};
1356Evt.PreventEventAndBubble = function(evt){
1357 Evt.PreventEvent(evt);
1358 if(evt.stopPropagation)
1359  evt.stopPropagation();
1360 evt.cancelBubble = true;
1361 return false;
1362};
1363Evt.CancelBubble = function(evt){
1364 evt.stopPropagation();
1365 return false;
1366};
1367Evt.PreventImageDragging = function(image) {
1368 if(image)
1369  image.ondragstart = function() { return false; };
1370};
1371Evt.PreventDragStart = function(evt) {
1372 evt = Evt.GetEvent(evt);
1373 var element = Evt.GetEventSource(evt);
1374 if(element.releaseCapture)
1375  element.releaseCapture(); 
1376 return false;
1377};
1378Evt.PreventElementDrag = function(element) {
1379 Evt.AttachEventToElement(element, "mousedown", Evt.PreventEvent);
1380};
1381Evt.PreventElementDragAndSelect = function(element, skipMouseMove, skipIESelect){
1382 if(Browser.WebKitFamily)
1383  Evt.AttachEventToElement(element, "selectstart", Evt.PreventEventAndBubble);
1384};
1385Evt.GetEventSource = function(evt){
1386 if(!ASPx.IsExists(evt)) return null; 
1387 return evt.srcElement ? evt.srcElement : evt.target;
1388};
1389Evt.GetKeyCode = function(srcEvt) {
1390 return Browser.NetscapeFamily || Browser.Opera ? srcEvt.which : srcEvt.keyCode;
1391};
1392function clientEventRequiresDocScrollCorrection() {
1393 var isSafariVerLess3 = Browser.Safari && Browser.Version < 3,
1394  isMacOSMobileVerLess51 = Browser.MacOSMobilePlatform && Browser.Version < 5.1;
1395 return Browser.AndroidDefaultBrowser || Browser.AndroidChromeBrowser || !(isSafariVerLess3 || isMacOSMobileVerLess51);
1396}
1397Evt.GetEventX = function(evt){
1398 if(ASPx.TouchUIHelper.isTouchEvent(evt))
1399  return ASPx.TouchUIHelper.getEventX(evt);
1400 return evt.clientX + (clientEventRequiresDocScrollCorrection() ? ASPx.GetDocumentScrollLeft() : 0);
1401};
1402Evt.GetEventY = function(evt){
1403 if(ASPx.TouchUIHelper.isTouchEvent(evt))
1404  return ASPx.TouchUIHelper.getEventY(evt);
1405 return evt.clientY + (clientEventRequiresDocScrollCorrection() ? ASPx.GetDocumentScrollTop() : 0 );
1406};

1407Evt.IsLeftButtonPressed = function(evt) {
1408 if(ASPx.TouchUIHelper.isTouchEvent(evt))
1409  return true;
1410 evt = Evt.GetEvent(evt);
1411 if(!evt) return false;
1412 if(Browser.WebKitFamily) {
1413  if(evt.type === "pointermove")
1414   return evt.buttons === 1;
1415  return evt.which == 1;
1416 } else if(Browser.NetscapeFamily || Browser.Edge) {
1417  if(evt.type === ASPx.TouchUIHelper.touchMouseMoveEventName)
1418   return evt.buttons === 1;
1419  return evt.which == 1;
1420 } else if(Browser.Opera)
1421  return evt.button == 0;
1422 return true;
1423};
1424Evt.IsRightButtonPressed = function(evt){
1425 evt = Evt.GetEvent(evt);
1426 if(!ASPx.IsExists(evt)) return false;
1427 if(Browser.IE || Browser.Edge) {
1428  if(evt.type === "pointermove")
1429   return evt.buttons === 2;
1430  return evt.button == 2;
1431 }
1432 else if(Browser.NetscapeFamily || Browser.WebKitFamily)
1433  return evt.which == 3;
1434 else if (Browser.Opera)
1435  return evt.button == 1;
1436 return true;
1437};
1438Evt.GetWheelDelta = function(evt) {
1439 var ret;
1440 if(Browser.NetscapeFamily && Browser.MajorVersion < 17)
1441  ret = -evt.detail;
1442 else if(Browser.Safari)
1443  ret = evt.wheelDelta;
1444 else
1445  ret = -evt.deltaY;
1446 if(Browser.Opera && Browser.Version < 9)
1447  ret = -ret;
1448 return ret;
1449};
1450Evt.IsWheelEventWithDirection = function(evt) {
1451 return ASPx.Data.ArrayContains(["wheel", "mousewheel"], evt.type);
1452};
1453Evt.GetWheelDeltaX = function(evt) {
1454 if(evt.type === "wheel")
1455  return -evt.deltaX;
1456 if(evt.type === "mousewheel")
1457  return evt.wheelDeltaX;
1458};
1459Evt.GetWheelDeltaY = function(evt) {
1460 if(evt.type === "wheel")
1461  return -evt.deltaY;
1462 if(evt.type === "mousewheel")
1463  return evt.wheelDeltaY;
1464};
1465Evt.IsPassiveListenersSupported = function() {
1466 if(Browser.Chrome && Browser.MajorVersion > 69 || Browser.Edge && Browser.MajorVersion > 15 || Browser.Firefox && Browser.MajorVersion > 62)
1467  return true;
1468 if(Evt.isPassiveListenersSupported === undefined) {
1469  Evt.isPassiveListenersSupported = false;
1470  try {
1471   var options = Object.defineProperty({}, "passive", { get: function() { Evt.isPassiveListenersSupported = true; } });
1472   window.addEventListener("test", options, options);
1473   window.removeEventListener("test", options, options);
1474  }
1475  catch(err) { Evt.isPassiveListenersSupported = false; }
1476 }
1477 return !!Evt.isPassiveListenersSupported;
1478};
1479Evt.AttachEventToElement = function(element, eventName, func, onlyBubbling, passive) {
1480 if(element.addEventListener)
1481  element.addEventListener(eventName, func, Evt.IsPassiveListenersSupported() ? { capture: !onlyBubbling, passive: !!passive } : !onlyBubbling);
1482 else
1483  element.attachEvent("on" + eventName, func);
1484};
1485Evt.DetachEventFromElement = function(element, eventName, func, onlyBubbling) {
1486 if(element.removeEventListener)
1487  element.removeEventListener(eventName, func, Evt.IsPassiveListenersSupported() ? { capture: !onlyBubbling } : !onlyBubbling);
1488 else
1489  element.detachEvent("on" + eventName, func);
1490};
1491Evt.AttachEventToDocument = function(eventName, func) {
1492 var attachingAllowed = ASPx.TouchUIHelper.onEventAttachingToDocument(eventName, func);
1493 if(attachingAllowed)
1494  Evt.AttachEventToDocumentCore(eventName, func);
1495};
1496Evt.AttachEventToDocumentCore = function(eventName, func) {
1497 Evt.AttachEventToElement(document, eventName, func);
1498};
1499Evt.DetachEventFromDocument = function(eventName, func) {
1500 Evt.DetachEventFromDocumentCore(eventName, func);
1501 ASPx.TouchUIHelper.onEventDettachedFromDocument(eventName, func);
1502};
1503Evt.DetachEventFromDocumentCore = function(eventName, func){
1504 Evt.DetachEventFromElement(document, eventName, func);
1505};
1506Evt.GetMouseWheelEventName = function() {
1507 if(Browser.Safari)
1508  return "mousewheel";
1509 if(Browser.NetscapeFamily && Browser.MajorVersion < 17)
1510  return "DOMMouseScroll";
1511 return "wheel";
1512};
1513Evt.AttachMouseEnterToElement = function (element, onMouseOverHandler, onMouseOutHandler) {
1514 Evt.AttachEventToElement(element, ASPx.TouchUIHelper.pointerEnabled ? ASPx.TouchUIHelper.pointerOverEventName : "mouseover", function (evt) { mouseEnterHandler(evt, element, onMouseOverHandler, onMouseOutHandler); });
1515 Evt.AttachEventToElement(element, ASPx.TouchUIHelper.pointerEnabled ? ASPx.TouchUIHelper.pointerOutEventName : "mouseout", function (evt) { mouseEnterHandler(evt, element, onMouseOverHandler, onMouseOutHandler); });
1516};
1517Evt.GetEventRelatedTarget = function(evt, isMouseOverEvent) {
1518 return evt.relatedTarget || (isMouseOverEvent ? evt.srcElement : evt.toElement);
1519};
1520function mouseEnterHandler(evt, element, onMouseOverHandler, onMouseOutHandler) {
1521 var isMouseOverExecuted = !!element.dxMouseOverExecuted;
1522 var isMouseOverEvent = (evt.type == "mouseover" || evt.type == ASPx.TouchUIHelper.pointerOverEventName);
1523 if(isMouseOverEvent && isMouseOverExecuted || !isMouseOverEvent && !isMouseOverExecuted)
1524  return;
1525 var source = Evt.GetEventRelatedTarget(evt, isMouseOverEvent);
1526 if(!ASPx.GetIsParent(element, source)) {
1527  element.dxMouseOverExecuted = isMouseOverEvent;
1528  if(isMouseOverEvent)
1529   onMouseOverHandler(element);
1530  else
1531   onMouseOutHandler(element);
1532 }
1533 else if(isMouseOverEvent && !isMouseOverExecuted) {
1534  element.dxMouseOverExecuted = true;
1535  onMouseOverHandler(element);
1536 }
1537}
1538Evt.DispatchEvent = function(target, eventName, canBubble, cancellable) {
1539 var event = document.createEvent("Event");
1540 event.initEvent(eventName, canBubble || false, cancellable || false);
1541 target.dispatchEvent(event);
1542};
1543Evt.EmulateDocumentOnMouseDown = function(evt) {
1544 Evt.EmulateOnMouseDown(document, evt);
1545};

1546Evt.EmulateOnMouseDown = function(element, evt) {
1547 if(!Browser.WebKitFamily){
1548  var emulatedEvt = document.createEvent("MouseEvents");
1549  emulatedEvt.initMouseEvent("mousedown", true, true, window, 0, evt.screenX, evt.screenY, 
1550   evt.clientX, evt.clientY, evt.ctrlKey, evt.altKey, evt.shiftKey, false, 0, null);
1551  element.dispatchEvent(emulatedEvt);
1552 }
1553};
1554Evt.EmulateOnMouseEvent = function (type, element, evt) {
1555 evt.type = type;
1556 var emulatedEvt = document.createEvent("MouseEvents");
1557 emulatedEvt.initMouseEvent(type, true, true, window, 0, evt.screenX, evt.screenY,
1558  evt.clientX, evt.clientY, evt.ctrlKey, evt.altKey, evt.shiftKey, false, 0, null);
1559 emulatedEvt.target = element;
1560 element.dispatchEvent(emulatedEvt);
1561};
1562Evt.EmulateMouseClick = function (element, evt) {
1563 var x = ASPx.GetElementOffsetWidth(element) / 2;
1564 var y = ASPx.GetElementOffsetHeight(element) / 2;
1565 if (!evt)
1566  evt = {
1567   bubbles: true,
1568   cancelable: true,
1569   view: window,
1570   detail: 1,
1571   screenX: 0,
1572   screenY: 0,
1573   clientX: x,
1574   clientY: y,
1575   ctrlKey: false,
1576   altKey: false,
1577   shiftKey: false,
1578   metaKey: false,
1579   button: 0,
1580   relatedTarget: null
1581  };
1582 Evt.EmulateOnMouseEvent("mousedown", element, evt);
1583 Evt.EmulateOnMouseEvent("mouseup", element, evt);
1584 Evt.EmulateOnMouseEvent("click", element, evt);
1585};
1586Evt.DoElementClick = function(element) {
1587 try{
1588  element.click();
1589 }
1590 catch(e){ 
1591 }
1592};
1593Evt.IsActionKeyPressed = function(evt) {
1594 return evt.keyCode === ASPx.Key.Space ||
1595     evt.keyCode === ASPx.Key.Enter ||
1596    (evt.keyCode === ASPx.Key.Down && evt.altKey);
1597};
1598Evt.InvokeMouseClickByKeyDown = function(evt, handler) {
1599 if(Evt.IsActionKeyPressed(evt)) {
1600  ASPx.Evt.PreventEvent(evt); 
1601  if(!handler)
1602   ASPx.Evt.GetEventSource(evt).onclick();
1603  else
1604   handler(evt);
1605 }
1606};
1607Evt.AttachContextMenuToElement = function (element, handler, onlyBubbling) {
1608 if (ASPx.TouchUIHelper.useLongTapHelper())
1609  element.detachContextMenuEventHandler = ASPx.TouchUIHelper.attachLongTapHandler(element, handler, onlyBubbling);
1610 else
1611  Evt.AttachEventToElement(element, "contextmenu", handler, onlyBubbling);
1612};
1613Evt.DetachContextMenuFromElement = function (element, handler) {
1614 if (element.detachContextMenuEventHandler)
1615  element.detachContextMenuEventHandler();
1616 else
1617  Evt.DetachEventFromElement(element, "contextmenu", handler);
1618};
1619Evt.PreventContextMenuOnElement = function(element) {
1620 Evt.AttachContextMenuToElement(element, function(evt) {
1621  Evt.PreventEvent(evt);
1622 });
1623};
1624ASPx.Evt = Evt;
1625var Attr = { };
1626Attr.GetAttribute = function(obj, attrName){
1627 if(obj.getAttribute)
1628  return obj.getAttribute(attrName);
1629 else if(obj.getPropertyValue) {
1630  if(Browser.Firefox) { 
1631   try {
1632    return obj.getPropertyValue(attrName);
1633   } catch(e) {
1634    return obj[attrName];
1635   }
1636  }
1637  return obj.getPropertyValue(attrName);
1638 }
1639 return null;
1640};
1641Attr.SetAttribute = function(obj, attrName, value){
1642 if(obj.setAttribute)
1643  obj.setAttribute(attrName, value);
1644 else if(obj.setProperty)
1645  obj.setProperty(attrName, value, "");
1646};
1647Attr.ToggleAttribute = function(obj, attrName, value, condition) {
1648 if(condition)
1649  Attr.SetAttribute(obj, attrName, value);
1650 else
1651  Attr.RemoveAttribute(obj, attrName);
1652};
1653Attr.RemoveAttribute = function(obj, attrName){
1654 if(obj.removeAttribute)
1655  obj.removeAttribute(attrName);
1656 else if(obj.removeProperty)
1657  obj.removeProperty(attrName);
1658};
1659Attr.IsExistsAttribute = function(obj, attrName){
1660 var value = Attr.GetAttribute(obj, attrName);
1661 return (value != null) && (value !== "");
1662};
1663Attr.SetOrRemoveAttribute = function(obj, attrName, value) {
1664 if(!value)
1665  Attr.RemoveAttribute(obj, attrName);
1666 else
1667  Attr.SetAttribute(obj, attrName, value);
1668};
1669Attr.SaveAttribute = function(obj, attrName, savedObj, savedAttrName){
1670 if(!Attr.IsExistsAttribute(savedObj, savedAttrName)){
1671  var oldValue = Attr.IsExistsAttribute(obj, attrName) ? Attr.GetAttribute(obj, attrName) : ASPx.EmptyObject;
1672  Attr.SetAttribute(savedObj, savedAttrName, oldValue);
1673 }
1674};
1675Attr.SaveStyleAttribute = function(obj, attrName){
1676 Attr.SaveAttribute(obj.style, attrName, obj, "saved" + attrName);
1677};
1678Attr.ChangeAttributeExtended = function(obj, attrName, savedObj, savedAttrName, newValue){
1679 Attr.SaveAttribute(obj, attrName, savedObj, savedAttrName);
1680 Attr.SetAttribute(obj, attrName, newValue);
1681};
1682Attr.ChangeAttribute = function(obj, attrName, newValue){
1683 Attr.ChangeAttributeExtended(obj, attrName, obj, "saved" + attrName, newValue);
1684};
1685Attr.ChangeStyleAttribute = function(obj, attrName, newValue){
1686 Attr.ChangeAttributeExtended(obj.style, attrName, obj, "saved" + attrName, newValue);
1687};
1688Attr.ResetAttributeExtended = function(obj, attrName, savedObj, savedAttrName){
1689 Attr.SaveAttribute(obj, attrName, savedObj, savedAttrName);
1690 Attr.SetAttribute(obj, attrName, "");
1691 Attr.RemoveAttribute(obj, attrName);
1692};
1693Attr.ResetAttribute = function(obj, attrName){
1694 Attr.ResetAttributeExtended(obj, attrName, obj, "saved" + attrName);
1695};
1696Attr.ResetStyleAttribute = function(obj, attrName){
1697 Attr.ResetAttributeExtended(obj.style, attrName, obj, "saved" + attrName);
1698};
1699Attr.RestoreAttributeExtended = function(obj, attrName, savedObj, savedAttrName){
1700 if(Attr.IsExistsAttribute(savedObj, savedAttrName)){
1701  var oldValue = Attr.GetAttribute(savedObj, savedAttrName);
1702  if(oldValue != ASPx.EmptyObject)
1703   Attr.SetAttribute(obj, attrName, oldValue);
1704  else
1705   Attr.RemoveAttribute(obj, attrName);
1706  Attr.RemoveAttribute(savedObj, savedAttrName);
1707  return true;
1708 }
1709 return false;
1710};
1711Attr.RestoreAttribute = function(obj, attrName){
1712 return Attr.RestoreAttributeExtended(obj, attrName, obj, "saved" + attrName);
1713};
1714Attr.RestoreStyleAttribute = function(obj, attrName){
1715 return Attr.RestoreAttributeExtended(obj.style, attrName, obj, "saved" + attrName);
1716};
1717Attr.CopyAllAttributes = function(sourceElem, destElement) {
1718 var attrs = sourceElem.attributes;
1719 for(var n = 0; n < attrs.length; n++) {
1720  var attr = attrs[n];
1721  if(attr.specified) {
1722   var attrName = attr.nodeName;
1723   var attrValue = sourceElem.getAttribute(attrName, 2);
1724   if(attrValue == null)
1725    attrValue = attr.nodeValue;
1726   destElement.setAttribute(attrName, attrValue, 0); 
1727  }
1728 }
1729 if(sourceElem.style.cssText !== '')
1730  destElement.style.cssText = sourceElem.style.cssText;
1731};
1732Attr.RemoveAllAttributes = function(element, excludedAttributes) {
1733 var excludedAttributesHashTable = {};
1734 if(excludedAttributes)
1735  excludedAttributesHashTable = Data.CreateHashTableFromArray(excludedAttributes);
1736 if(element.attributes) {
1737  var attrArray = element.attributes;
1738  for(var i = 0; i < attrArray.length; i++) {
1739   var attrName = attrArray[i].name;
1740   if(!ASPx.IsExists(excludedAttributesHashTable[attrName.toLowerCase()])) {
1741    try {
1742     attrArray.removeNamedItem(attrName);
1743    } catch (e) { }
1744   }
1745  }
1746 }
1747};
1748Attr.RemoveStyleAttribute = function(element, attrName) {
1749 if(element.style) {
1750  if(Browser.Firefox && element.style[attrName]) 
1751   element.style[attrName] = "";
1752  if(element.style.removeAttribute && element.style.removeAttribute != "")
1753   element.style.removeAttribute(attrName);
1754  else if(element.style.removeProperty && element.style.removeProperty != "")
1755   element.style.removeProperty(attrName);
1756 }
1757};
1758Attr.RemoveAllStyles = function(element) {
1759 if(element.style) {
1760  for(var key in element.style)
1761   Attr.RemoveStyleAttribute(element, key);
1762    Attr.RemoveAttribute(element, "style");
1763 }
1764};
1765Attr.GetTabIndexAttributeName = function(){
1766 return "tabindex";
1767};
1768Attr.ChangeTabIndexAttribute = function(element){
1769 var attribute = Attr.GetTabIndexAttributeName(); 
1770 if(Attr.GetAttribute(element, attribute) != -1)
1771    Attr.ChangeAttribute(element, attribute, -1);
1772};
1773Attr.SaveTabIndexAttributeAndReset = function(element) {
1774 var attribute = Attr.GetTabIndexAttributeName();
1775 Attr.SaveAttribute(element, attribute, element, "saved" + attribute);
1776 Attr.SetAttribute(element, attribute, -1);
1777};
1778Attr.RestoreTabIndexAttribute = function(element){
1779 var attribute = Attr.GetTabIndexAttributeName();
1780 if(Attr.IsExistsAttribute(element, attribute)) {
1781  if(Attr.GetAttribute(element, attribute) == -1) {
1782   if(Attr.IsExistsAttribute(element, "saved" + attribute)){
1783    var oldValue = Attr.GetAttribute(element, "saved" + attribute);
1784    if(oldValue != ASPx.EmptyObject)
1785     Attr.SetAttribute(element, attribute, oldValue);
1786    else {
1787     if(Browser.WebKitFamily) 
1788      Attr.SetAttribute(element, attribute, 0); 
1789     Attr.RemoveAttribute(element, attribute);   
1790    }
1791    Attr.RemoveAttribute(element, "saved" + attribute); 
1792   }
1793  }
1794 }
1795};
1796Attr.ChangeAttributesMethod = function(enabled){
1797 return enabled ? Attr.RestoreAttribute : Attr.ResetAttribute;
1798};
1799Attr.InitiallyChangeAttributesMethod = function(enabled){
1800 return enabled ? Attr.ChangeAttribute : Attr.ResetAttribute;
1801};
1802Attr.ChangeStyleAttributesMethod = function(enabled){
1803 return enabled ? Attr.RestoreStyleAttribute : Attr.ResetStyleAttribute;
1804};
1805Attr.InitiallyChangeStyleAttributesMethod = function(enabled){
1806 return enabled ? Attr.ChangeStyleAttribute : Attr.ResetStyleAttribute;
1807};
1808Attr.ChangeEventsMethod = function(enabled){
1809 return enabled ? Evt.AttachEventToElement : Evt.DetachEventFromElement;
1810};
1811Attr.ChangeDocumentEventsMethod = function(enabled){
1812 return enabled ? Evt.AttachEventToDocument : Evt.DetachEventFromDocument;
1813};
1814Attr.ChangeCellSpanCount = function(cell, value, isColumnSpan) {
1815 if(!cell) return;
1816 var propertyKey = isColumnSpan ? "colSpan" : "rowSpan";
1817 var prevValue = cell[propertyKey];
1818 if(value > 1)
1819  cell[propertyKey] = value;
1820 else if(prevValue !== 1)
1821  Attr.RemoveAttribute(cell, propertyKey);
1822};
1823Attr.AppendScriptType = function(script) {
1824 if(!isHtml5Mode())
1825  script.type = "text/javascript";
1826};
1827Attr.AppendStyleType = function(style) {
1828 if(!isHtml5Mode())
1829  style.type = "text/css";
1830};
1831function isHtml5Mode() {
1832 return ASPx.DoctypeMode === "Html5";
1833}
1834ASPx.Attr = Attr;
1835var Aria = {
1836 atomic: "aria-atomic",
1837 checked: "aria-checked",
1838 descendant: "aria-activedescendant",
1839 described: "aria-describedby",
1840 disabled: "aria-disabled",
1841 expanded: "aria-expanded",
1842 haspopup: "aria-haspopup",
1843 invalid: "aria-invalid",
1844 label: "aria-label",
1845 labelled: "aria-labelledby",
1846 level: "aria-level",
1847 owns: "aria-owns",
1848 posinset: "aria-posinset",
1849 role: "role",
1850 selected: "aria-selected",
1851 setsize: "aria-setsize",
1852 valuemax: "aria-valuemax",
1853 valuemin: "aria-valuemin",
1854 valuenow: "aria-valuenow"
1855};
1856Aria.SetOrRemoveDescendant = function(obj, value) {
1857 ASPx.Attr.SetOrRemoveAttribute(obj, Aria.descendant, value);
1858};
1859Aria.SetOrRemoveLabel = function(obj, value) {
1860 ASPx.Attr.SetOrRemoveAttribute(obj, Aria.label, value);
1861};
1862Aria.SetOrRemoveDisabled = function(obj, value) {
1863 ASPx.Attr.SetOrRemoveAttribute(obj, Aria.disabled, value);
1864};
1865Aria.AppendLabel = function(obj, value, checkExists) {
1866 var currentValue = ASPx.Attr.GetAttribute(obj, Aria.label) || "";
1867 var resultParts = [ ];
1868 if(currentValue)
1869  resultParts.push(currentValue);
1870 var needAppendValue = value && (!checkExists || currentValue.indexOf(value) == -1);
1871 if(needAppendValue)
1872  resultParts.push(value);
1873 ASPx.Attr.SetAttribute(obj, Aria.label, resultParts.join(" "));
1874};
1875Aria.SetOrRemoveLabelled = function(obj, value) {
1876 ASPx.Attr.SetOrRemoveAttribute(obj, Aria.labelled, value);
1877};
1878Aria.SetApplicationRole = function(obj) {
1879  ASPx.Attr.SetAttribute(obj, Aria.role, "application");
1880};
1881Aria.SetSilence = function(obj) {
1882 ASPx.Attr.SetAttribute(obj, Aria.label, ";");
1883};

1884Aria.SetExpanded = function(obj, expanded) {
1885 if(!obj || !ASPx.Attr.GetAttribute(obj, Aria.expanded)) return;
1886 Aria.SetBoolAttribute(obj, Aria.expanded, expanded);
1887};
1888Aria.SetAtomic = function(obj, value) {
1889 Aria.SetBoolAttribute(obj, Aria.atomic, value);
1890};
1891Aria.SetBoolAttribute = function(obj, attribute, value) {
1892 if(value)
1893  ASPx.Attr.SetAttribute(obj, attribute, true);
1894 else 
1895  ASPx.Attr.SetAttribute(obj, attribute, false);
1896};
1897ASPx.Attr.Aria = Aria;
1898var Color = { };
1899function _aspxToHex(d) {
1900 return (d < 16) ? ("0" + d.toString(16)) : d.toString(16);
1901}
1902Color.RGBRegexp = /rgb\s*\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*\)/;
1903Color.RGBARegexp = /rgba?\s*\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,?\s*([0-9]*\.?[0-9]*)\s*\)/;
1904Color.ColorToHexadecimal = function(colorValue, isRGBA) {
1905 if(typeof(colorValue) == "number") {
1906  var r = colorValue & 0xFF;
1907  var g = (colorValue >> 8) & 0xFF;
1908  var b = (colorValue >> 16) & 0xFF;
1909  return "#" + _aspxToHex(r) + _aspxToHex(g) + _aspxToHex(b);
1910 }
1911 if(colorValue && (colorValue.substr(0, 3).toLowerCase() == "rgb")) {
1912  var regResult = colorValue.toLowerCase().match(isRGBA ? Color.RGBARegexp : Color.RGBRegexp);
1913  if(regResult) {
1914   var r = parseInt(regResult[1]);
1915   var g = parseInt(regResult[2]);
1916   var b = parseInt(regResult[3]);
1917   if (isRGBA)
1918    return { r: r, g: g, b: b, a: regResult[4] !== undefined ? parseFloat(regResult[4]) : 1 };
1919   return "#" + _aspxToHex(r) + _aspxToHex(g) + _aspxToHex(b);
1920  }
1921  return null;
1922 } 
1923 if(colorValue && (colorValue.charAt(0) == "#"))
1924  return colorValue;
1925 return null;
1926};
1927Color.Names = {
1928 AddColorNames: function(stringResourcesObj) {
1929  if(stringResourcesObj) {
1930   for(var key in stringResourcesObj)
1931    if(stringResourcesObj.hasOwnProperty(key))
1932     this[key] = stringResourcesObj[key];
1933  }
1934 }
1935};
1936ASPx.Color = Color;
1937var Url = { };
1938Url.Navigate = function(url, target) {
1939 var javascriptPrefix = "javascript:";
1940 if(!url || url === "")
1941  return;
1942 else if(url.indexOf(javascriptPrefix) != -1)
1943  eval(url.substr(javascriptPrefix.length));
1944 else {
1945  try {
1946   if(target != "")
1947    navigateTo(url, target);
1948   else
1949    location.href = url;
1950  }
1951  catch(e) {
1952  }
1953 }
1954};
1955Url.NavigateByLink = function(linkElement) {
1956 Url.Navigate(Attr.GetAttribute(linkElement, "href"), linkElement.target);
1957};
1958Url.GetAbsoluteUrl = function(url) {
1959 if(url)
1960  url = Url.getURLObject(url).href;
1961 return url;
1962};
1963Url.Redirect = function(url) {
1964 window.location.href = url;
1965};
1966var absolutePathPrefixes = 
1967 [ "about:", "file:///", "ftp://", "gopher://", "http://", "https://", "javascript:", "mailto:", "news:", "res://", "telnet://", "view-source:" ];
1968Url.isAbsoluteUrl = function(url) {
1969 if (url) {
1970  for (var i = 0; i < absolutePathPrefixes.length; i++) {
1971   if(url.indexOf(absolutePathPrefixes[i]) == 0)
1972    return true;
1973  }
1974 }
1975 return false;
1976};
1977Url.getURLObject = function(url) {
1978 var link = document.createElement('A');
1979 link.href = url || "";
1980 return { 
1981  href: link.href,
1982  protocol: link.protocol,
1983  host: link.host,
1984  port: link.port,
1985  pathname: link.pathname,
1986  search: link.search,
1987  hash: link.hash
1988 }; 
1989};
1990Url.getRootRelativeUrl = function(url) {
1991 return getRelativeUrl(url, !Url.isRootRelativeUrl(url), true); 
1992};
1993Url.getPathRelativeUrl = function(url) {
1994 return getRelativeUrl(url, !Url.isPathRelativeUrl(url), false);
1995};
1996function getRelativeUrl(url, isValid, isRootRelative) {
1997 if(url && !(/data:([^;]+\/?[^;]*)(;charset=[^;]*)?(;base64,)/.test(url)) && isValid) {
1998  var urlObject = Url.getURLObject(url);
1999  var baseUrlObject = Url.getURLObject();
2000  if(!Url.isAbsoluteUrl(url) || urlObject.host === baseUrlObject.host && urlObject.protocol === baseUrlObject.protocol) {
2001   url = urlObject.pathname;
2002   if(!isRootRelative)
2003    url = getPathRelativeUrl(baseUrlObject.pathname, url);
2004   url = url + urlObject.search + urlObject.hash;
2005  }
2006 }
2007 return url;   
2008}
2009function getPathRelativeUrl(baseUrl, url) {
2010 var requestSegments = getSegments(baseUrl, false);
2011 var urlSegments = getSegments(url, true);
2012 return buildPathRelativeUrl(requestSegments, urlSegments, 0, 0, "");
2013}
2014function getSegments(url, addTail) {
2015 var segments = [];
2016 var startIndex = 0;
2017 var endIndex = -1;
2018 while ((endIndex = url.indexOf("/", startIndex)) != -1) {
2019  segments.push(url.substring(startIndex, ++endIndex));
2020  startIndex = endIndex;
2021 }
2022 if(addTail && startIndex < url.length)
2023  segments.push(url.substring(startIndex, url.length)); 
2024 return segments;
2025}
2026function buildPathRelativeUrl(requestSegments, urlSegments, reqIndex, urlIndex, buffer) {
2027 if(urlIndex >= urlSegments.length)
2028  return buffer;
2029 if(reqIndex >= requestSegments.length)
2030  return buildPathRelativeUrl(requestSegments, urlSegments, reqIndex, urlIndex + 1, buffer + urlSegments[urlIndex]);
2031 if(requestSegments[reqIndex] === urlSegments[urlIndex] && urlIndex === reqIndex)
2032  return buildPathRelativeUrl(requestSegments, urlSegments, reqIndex + 1, urlIndex + 1, buffer);
2033 return buildPathRelativeUrl(requestSegments, urlSegments, reqIndex + 1, urlIndex, buffer + "../");
2034}
2035Url.isPathRelativeUrl = function(url) {
2036 return !!url && !Url.isAbsoluteUrl(url) && url.indexOf("/") != 0;  
2037};
2038Url.isRootRelativeUrl = function(url) {
2039 return !!url && !Url.isAbsoluteUrl(url) && url.indexOf("/") == 0 && url.indexOf("//") != 0;
2040};
2041function navigateTo(url, target) {
2042 var lowerCaseTarget = target.toLowerCase();
2043 if("_top" == lowerCaseTarget)
2044  top.location.href = url;
2045 else if("_self" == lowerCaseTarget)
2046  location.href = url;
2047 else if("_search" == lowerCaseTarget)
2048  openInNewWindow(url);
2049 else if("_media" == lowerCaseTarget)
2050  openInNewWindow(url);
2051 else if("_parent" == lowerCaseTarget)
2052  window.parent.location.href = url;
2053 else if("_blank" == lowerCaseTarget)
2054  openInNewWindow(url);
2055 else {
2056  var frame = getFrame(top.frames, target);
2057  if(frame != null)
2058   frame.location.href = url;
2059  else
2060   openInNewWindow(url);
2061 }
2062}
2063function openInNewWindow(url) {
2064 if(ASPx.Browser.Safari)
2065  openInNewWindowViaIframe(url);
2066 else {
2067  var newWindow = window.open();
2068  newWindow.opener = null;
2069  newWindow.location = url;
2070 }
2071}
2072function openInNewWindowViaIframe(url) {
2073 var iframe = document.createElement('iframe');

2074 iframe.style.display = 'none';
2075 document.body.appendChild(iframe);
2076 var iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
2077 var openArgs = '"' + url + '"';
2078 var script = iframeDoc.createElement('script');
2079 script.type = 'text/javascript';
2080 script.text = 'window.parent = null; ' +
2081  'window.top = null;' +
2082  'window.frameElement = null;' +
2083  'var child = window.open(' + openArgs + ');' +
2084  'child.opener = null';
2085 iframeDoc.body.appendChild(script);
2086 document.body.removeChild(iframe);
2087}
2088ASPx.Url = Url;
2089var Json = { };
2090function isValid(JsonString) {
2091 return !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(JsonString.replace(/"(\\.|[^"\\])*"/g, '')));
2092}
2093Json.Eval = function(jsonString, controlName) {
2094 if(isValid(jsonString)) {
2095  return eval("(" + jsonString + ")");
2096 } else {
2097  throw new Error(controlName + " received incorrect JSON-data: " + jsonString);
2098 }
2099};
2100Json.ToJson = function(param, skipEncodeHtml){
2101 var paramType = typeof(param);
2102 if((paramType == "undefined") || (param == null))
2103  return null;
2104 if((paramType == "object") && (typeof(param.__toJson) == "function"))
2105  return param.__toJson();
2106 if((paramType == "number") || (paramType == "boolean"))
2107  return param;
2108 if(param.constructor == Date)
2109  return dateToJson(param);
2110 if(paramType == "string") {
2111  var result = param.replace(/\\/g, "\\\\");
2112  result = result.replace(/"/g, "\\\"");
2113  result = result.replace(/\n/g, "\\n");
2114  result = result.replace(/\r/g, "\\r");
2115  if(!skipEncodeHtml) {
2116   result = result.replace(/</g, "\\u003c");
2117   result = result.replace(/>/g, "\\u003e");
2118  }
2119  return "\"" + result + "\"";
2120 }
2121 if(param.constructor == Array){
2122  var values = [];
2123  for(var i = 0; i < param.length; i++) {
2124   var jsonValue = Json.ToJson(param[i], skipEncodeHtml);
2125   if(jsonValue === null)
2126    jsonValue = "null";
2127   values.push(jsonValue);
2128  }
2129  return "[" + values.join(",") + "]";
2130 }
2131 var exceptKeys = {};
2132 if(ASPx.Ident.IsArray(param.__toJsonExceptKeys))
2133  exceptKeys = Data.CreateHashTableFromArray(param.__toJsonExceptKeys);
2134 exceptKeys["__toJsonExceptKeys"] = 1;
2135 var values = [];
2136 for(var key in param) {
2137  if(param.hasOwnProperty(key)) {
2138   if(ASPx.IsFunction(param[key]))
2139    continue;
2140   if(exceptKeys[key] == 1)
2141    continue;
2142   values.push(Json.ToJson(key) + ":" + Json.ToJson(param[key], skipEncodeHtml));
2143  }
2144 }
2145 return "{" + values.join(",") + "}";
2146};
2147function dateToJson(date) {
2148 var result = [ 
2149  date.getFullYear(),
2150  date.getMonth(),
2151  date.getDate()
2152 ];
2153 var time = {
2154  h: date.getHours(),
2155  m: date.getMinutes(),
2156  s: date.getSeconds(),
2157  ms: date.getMilliseconds()
2158 };
2159 if(time.h || time.m || time.s || time.ms)
2160  result.push(time.h);
2161 if(time.m || time.s || time.ms)
2162  result.push(time.m);
2163 if(time.s || time.ms)
2164  result.push(time.s);
2165 if(time.ms)
2166  result.push(time.ms);
2167 return "new Date(" + result.join() + ")";
2168}
2169ASPx.Json = Json;
2170ASPx.CreateClass = function(parentClass, properties) {
2171 if(arguments.length == 1) {
2172  properties = parentClass;
2173  parentClass = null;
2174 }
2175 var ret = function() {
2176  if(ret.preparing) 
2177   return delete(ret.preparing);
2178  if(ret.constr) {
2179   this.constructor = ret;
2180   ret.constr.apply(this, arguments);
2181  }
2182 };
2183 ret.prototype = {};
2184 if(parentClass) {
2185  parentClass.preparing = true;
2186  for(var name in parentClass) {
2187   if(parentClass.hasOwnProperty(name) && name != 'constr' && ASPx.IsFunction(parentClass[name]) && !ret[name])
2188    ret[name] = parentClass[name].aspxBind(parentClass);
2189  }
2190  ret.prototype = new parentClass;
2191  ret.prototype.constructor = parentClass;
2192  ret.constr = parentClass;
2193 }
2194 if(properties) {
2195  var constructorName = "constructor";
2196  for(var name in properties) {
2197   if(!properties.hasOwnProperty(name)) 
2198    continue;
2199   var getter = Object.getOwnPropertyDescriptor(properties, name).get;
2200   var setter = Object.getOwnPropertyDescriptor(properties, name).set;
2201   if(getter || setter)
2202    Object.defineProperty(ret.prototype, name, {
2203     set: setter,
2204     get: getter,
2205     enumerable: true,
2206     configurable: true
2207    });

2208   if(name != constructorName && !getter && !setter)
2209    ret.prototype[name] = properties[name];
2210  }
2211  if(properties[constructorName] && properties[constructorName] != Object)
2212   ret.constr = properties[constructorName];
2213 }
2214 return ret;
2215};
2216var registeredMixins = {};
2217ASPx.GetMixin = function (name, baseClass) {
2218 var mixinCache = baseClass._mixins || (baseClass._mixins = {});
2219 var resultClass = mixinCache[name];
2220 if (!resultClass) {
2221  var mixinCodeBuilder = registeredMixins[name];
2222  if (!mixinCodeBuilder)
2223   throw new Error("mixin with the '" + name + "' is not registered");
2224  var mixinCode = mixinCodeBuilder(baseClass);
2225  mixinCode.mixinName = name;
2226  resultClass = ASPx.CreateClass(baseClass, mixinCode);
2227  mixinCache[name] = resultClass;
2228 }
2229 return resultClass;
2230};
2231ASPx.RegisterMixin = function() {
2232 var name = arguments.length == 1 ? "mixin_" + ASPx.CreateGuid() : arguments[0];
2233 var mixinCodeBuilder = arguments[arguments.length - 1];
2234 if (registeredMixins[name])
2235  throw new Error("mixin with the '" + name + "' name is already defined");
2236 registeredMixins[name] = mixinCodeBuilder;
2237 return function(baseClass) { return ASPx.GetMixin(name, baseClass); };
2238};
2239ASPx.FormatCallbackArg = function(prefix, arg) {
2240 if(prefix == null && arg == null)
2241  return ""; 
2242 if(prefix == null) prefix = "";
2243 if(arg == null) arg = "";
2244 if(arg != null && !ASPx.IsExists(arg.length) && ASPx.IsExists(arg.value))
2245  arg = arg.value;
2246 arg = arg.toString();
2247 return [prefix, '|', arg.length, '|' , arg].join('');
2248};
2249ASPx.FormatCallbackArgs = function(callbackData) {
2250 var sb = [ ];
2251 for(var i = 0; i < callbackData.length; i++)
2252  sb.push(ASPx.FormatCallbackArg(callbackData[i][0], callbackData[i][1]));
2253 return sb.join("");
2254};
2255ASPx.ParseShortcutString = function(shortcutString) {
2256 if(!shortcutString)
2257  return 0;
2258 var isCtrlKey = false;
2259 var isShiftKey = false;
2260 var isAltKey = false;
2261 var isMetaKey = false;
2262 var keyCode = null;
2263 var shcKeys = shortcutString.toString().split("+");
2264 if(shcKeys.length > 0) {
2265  for(var i = 0; i < shcKeys.length; i++) {
2266   var key = Str.Trim(shcKeys[i].toUpperCase());
2267   switch (key) {
2268    case "CONTROL":
2269    case "CONTROLKEY":
2270    case "CTRL":
2271     isCtrlKey = true;
2272     break;
2273    case "SHIFT":
2274    case "SHIFTKEY":
2275     isShiftKey = true;
2276     break;
2277    case "ALT":
2278     isAltKey = true;
2279     break;
2280    case "CMD":
2281     isMetaKey = true;
2282     break;
2283    case "F1": keyCode = ASPx.Key.F1; break;
2284    case "F2": keyCode = ASPx.Key.F2; break;
2285    case "F3": keyCode = ASPx.Key.F3; break;
2286    case "F4": keyCode = ASPx.Key.F4; break;
2287    case "F5": keyCode = ASPx.Key.F5; break;
2288    case "F6": keyCode = ASPx.Key.F6; break;
2289    case "F7": keyCode = ASPx.Key.F7; break;
2290    case "F8": keyCode = ASPx.Key.F8; break;
2291    case "F9": keyCode = ASPx.Key.F9; break;
2292    case "F10":   keyCode = ASPx.Key.F10; break;
2293    case "F11":   keyCode = ASPx.Key.F11; break;
2294    case "F12":   keyCode = ASPx.Key.F12; break;
2295    case "RETURN":
2296    case "ENTER": keyCode = ASPx.Key.Enter; break;
2297    case "HOME":  keyCode = ASPx.Key.Home; break;
2298    case "END":   keyCode = ASPx.Key.End; break;
2299    case "LEFT":  keyCode = ASPx.Key.Left; break;
2300    case "RIGHT": keyCode = ASPx.Key.Right; break;
2301    case "UP": keyCode = ASPx.Key.Up; break;
2302    case "DOWN":  keyCode = ASPx.Key.Down; break;
2303    case "PAGEUP": keyCode = ASPx.Key.PageUp; break;
2304    case "PAGEDOWN": keyCode = ASPx.Key.PageDown; break;
2305    case "SPACE": keyCode = ASPx.Key.Space; break;
2306    case "TAB":   keyCode = ASPx.Key.Tab; break;
2307    case "BACKSPACE": 
2308    case "BACK": keyCode = ASPx.Key.Backspace; break;
2309    case "CONTEXT": keyCode = ASPx.Key.ContextMenu; break;
2310    case "ESCAPE":
2311    case "ESC":
2312     keyCode = ASPx.Key.Esc;
2313     break;
2314    case "DELETE":
2315    case "DEL":
2316     keyCode = ASPx.Key.Delete;
2317     break;
2318    case "INSERT":
2319    case "INS":
2320     keyCode = ASPx.Key.Insert;
2321     break;
2322    case "PLUS":
2323     keyCode = "+".charCodeAt(0);
2324     break;
2325    default:
2326     keyCode = key.charCodeAt(0);
2327     break;
2328   }
2329  }
2330 } else
2331  ASPx.ShowErrorAlert("Invalid shortcut");
2332 return ASPx.GetShortcutCode(keyCode, isCtrlKey, isShiftKey, isAltKey, isMetaKey);
2333};
2334ASPx.GetShortcutCode = function(keyCode, isCtrlKey, isShiftKey, isAltKey, isMetaKey) {
2335 var value = keyCode;
2336 value |= isCtrlKey ? ASPx.ModifierKey.Ctrl : 0;
2337 value |= isShiftKey ? ASPx.ModifierKey.Shift : 0;
2338 value |= isAltKey ? ASPx.ModifierKey.Alt : 0;
2339 value |= isMetaKey ? ASPx.ModifierKey.Meta : 0;
2340 return value;
2341};
2342ASPx.GetShortcutCodeByEvent = function(evt) {
2343 return ASPx.GetShortcutCode(Evt.GetKeyCode(evt), evt.ctrlKey, evt.shiftKey, evt.altKey, ASPx.Browser.MacOSPlatform ? evt.metaKey : false);
2344};

2345ASPx.IsPasteShortcut = function(evt) {
2346 if(evt.type === "paste")
2347  return true;
2348 var keyCode = Evt.GetKeyCode(evt);
2349 if(Browser.NetscapeFamily && evt.which == 0)  
2350  keyCode = evt.keyCode;
2351 return (evt.ctrlKey && (keyCode == 118  || (keyCode == 86))) ||
2352     (evt.shiftKey && !evt.ctrlKey && !evt.altKey &&
2353     (keyCode == ASPx.Key.Insert)) ;
2354};
2355var NotPrintableKeyCodes = null;
2356ASPx.IsPrintableKey = function(keyCode) {
2357 if (!NotPrintableKeyCodes)
2358  NotPrintableKeyCodes = Object.keys(ASPx.Key).map(function(key) { return ASPx.Key[key]; });
2359 return !ASPx.Data.ArrayContains(NotPrintableKeyCodes, keyCode);
2360};
2361ASPx.SetFocus = function(element, selectAction) {
2362 function focusCore(element, selectAction){
2363  try {
2364    element.focus();
2365    if(selectAction) {
2366     var currentSelection = Selection.GetInfo(element);
2367     if(currentSelection.startPos == currentSelection.endPos) {
2368      switch(selectAction) {
2369       case "start":
2370        Selection.SetCaretPosition(element, 0);
2371        break;
2372       case "all":
2373        Selection.Set(element);
2374        break;
2375      }
2376     }
2377    }
2378   } catch (e) {
2379  }
2380 }
2381 if(ASPxClientUtils.iOSPlatform || ASPxClientUtils.androidPlatform) 
2382  focusCore(element, selectAction);
2383 else {
2384  window.setTimeout(function() { 
2385   focusCore(element, selectAction);
2386  }, ASPx.FOCUS_TIMEOUT);
2387 }
2388};
2389ASPx.IsFocusableCore = function(element, skipContainerVisibilityCheck) {
2390 var current = element;
2391 while(current && current.nodeType == 1) {
2392  if(current == element || !skipContainerVisibilityCheck(current)) {
2393   var tagName = current.tagName.toUpperCase();
2394   if(tagName == "BODY")
2395    return true;
2396   var disabledElementTags = ["INPUT", "BUTTON", "TEXTAREA", "SELECT", "OPTION"];
2397   if(disabledElementTags.indexOf(tagName) !== -1 && current.disabled || !ASPx.GetElementDisplay(current) || !ASPx.GetElementVisibility(current))
2398    return false;
2399  }
2400  current = current.parentNode;
2401 }
2402 return true;
2403};
2404ASPx.IsFocusable = function(element) {
2405 return ASPx.IsFocusableCore(element, ASPx.FalseFunction);
2406};
2407ASPx.RemoveFocus = function(parent) {
2408 var div = document.createElement('div');
2409 div.tabIndex = "-1";
2410 concealDivElement(div);
2411 parent.appendChild(div);
2412 if(ASPx.IsFocusable(div))
2413  div.focus();
2414 ASPx.RemoveElement(div);
2415};
2416function concealDivElement(div){
2417 div.style.position = "absolute";
2418 div.style.left = 0;
2419 div.style.top = 0;
2420 if(ASPx.Browser.WebKitFamily) {
2421  div.style.opacity = 0;
2422  div.style.width = 1;
2423  div.style.height = 1;
2424 } else {
2425  div.style.border = 0;
2426  div.style.width = 0;
2427  div.style.height = 0;
2428 }
2429}
2430var ActionElementsCache = ASPx.CreateClass(null, {
2431 constructor: function() {
2432  this.usageCounter = 0;
2433  this.elements = [ ];
2434  this.values = [ ];
2435 },
2436 IsActive: function() { return this.usageCounter > 0; },
2437 BeginUsage: function() {
2438  this.usageCounter++;
2439 },
2440 EndUsage: function() {
2441  this.usageCounter--;
2442  if(this.usageCounter === 0)
2443   this.Clear();
2444 },
2445 Add: function(element, value) {
2446  var index = this.elements.length;
2447  this.elements[index] = element;
2448  this.values[index] = value;
2449 },
2450 Get: function(element) { 
2451  var index = this.elements.indexOf(element);
2452  var hasValue = index > -1;
2453  var value = hasValue ? this.values[index] : undefined;
2454  return { hasValue: hasValue, value: value };
2455 },
2456 Clear: function() { 
2457  this.elements = [ ];
2458  this.values = [ ];
2459 }
2460});
2461ASPx.ActionElementsCache = new ActionElementsCache();
2462ASPx.IsActionElement = function(element) {
2463 if(!ASPx.IsExistsElement(element))
2464  return false;
2465 var useCache = ASPx.ActionElementsCache.IsActive();
2466 if(useCache) {
2467  var cacheValue = ASPx.ActionElementsCache.Get(element);
2468  if(cacheValue.hasValue)
2469   return cacheValue.value;
2470 }
2471 var isActionElement = ASPx.IsActionElementCore(element);
2472 if(useCache)
2473  ASPx.ActionElementsCache.Add(element, isActionElement);
2474 return isActionElement;
2475};
2476ASPx.IsActionElementCore = function(element) {
2477 var tabIndex = parseInt(ASPx.Attr.GetAttribute(element, ASPx.Attr.GetTabIndexAttributeName()));
2478 var hasTabIndex = !isNaN(tabIndex);
2479 var hasNonNegativeTabIndex = hasTabIndex && tabIndex > -1;
2480 var hasNegativeTabIndex = hasTabIndex && tabIndex < 0;
2481 var tagName = element.tagName;
2482 var focusableElementTags = ["BUTTON", "SELECT", "TEXTAREA", "OPTION", "IFRAME"];
2483 var isFocusableCore = ASPx.IsFocusable(element);
2484 var isFocusableTag = focusableElementTags.indexOf(tagName) !== -1;
2485 var isFocusableLink = tagName === "A" && (!!element.href || hasNonNegativeTabIndex);
2486 var isFocusableInput = tagName === "INPUT" && element.type.toLowerCase() !== "hidden";
2487 var isFocusableByTabIndex = tagName !== "INPUT" && hasNonNegativeTabIndex;
2488 var isEditableDiv = tagName == "DIV" && element.contentEditable === "true";
2489 return isFocusableCore && !hasNegativeTabIndex && (isFocusableTag || isFocusableLink || isFocusableInput || isFocusableByTabIndex || isEditableDiv);
2490};

2491ASPx.GetCanBeActiveElementsInContainer = function(container) {
2492 var canBeActiveTags = ["INPUT", "A", "UL", "BUTTON", "TEXTAREA", "SELECT", "IFRAME"],
2493  canBeActiveElements = [];
2494 Data.ForEach(canBeActiveTags, function(tag) {
2495  var elements = container.getElementsByTagName(tag);
2496  canBeActiveElements = canBeActiveElements.concat([].slice.call(elements));
2497 });
2498 return canBeActiveElements;
2499};
2500function isActionElementAllowedByPredicate(element, predicate) {
2501  var allowedByPredicate = !predicate || predicate(element);
2502  return allowedByPredicate && ASPx.IsActionElement(element);
2503}
2504ASPx.FindChildActionElements = function(container, predicate) {
2505 return ASPx.GetNodes(container, function(el) {
2506  return isActionElementAllowedByPredicate(el, predicate);
2507 });
2508};
2509ASPx.FindAllSortedActionElements = function(container, predicate) {
2510 var result = [ ];
2511 if(!container || !container.getElementsByTagName) return result;
2512 var actionElements = ASPx.FindChildActionElements(container, predicate);
2513 var getTabOrderValue = function(el) {
2514  var tabIndex = parseInt(ASPx.Attr.GetAttribute(el, ASPx.Attr.GetTabIndexAttributeName()));
2515  return isNaN(tabIndex) ? 0 : tabIndex;
2516 };
2517 var positiveTabIndexElements = actionElements.filter(function(x) { return getTabOrderValue(x) > 0; });
2518 var nonPositiveTabIndexElements = actionElements.filter(function(x) { return getTabOrderValue(x) === 0; });
2519 var sortedTabIndexElements = positiveTabIndexElements.sort(function(x, y) { return getTabOrderValue(x) - getTabOrderValue(y); });
2520 result = sortedTabIndexElements.concat(nonPositiveTabIndexElements);
2521 return result;
2522};
2523ASPx.FindFirstChildActionElement = function(container, predicate) {
2524 if(!container || isActionElementAllowedByPredicate(container, predicate))
2525  return !container ? null : container;
2526 var sortedActionElements = ASPx.FindAllSortedActionElements(container, predicate);
2527 return sortedActionElements[0];
2528};
2529ASPx.FindLastChildActionElement = function(container, predicate) {
2530 if(!container)
2531  return null;
2532 var sortedActionElements = ASPx.FindAllSortedActionElements(container, predicate);
2533 var actionElement = sortedActionElements[sortedActionElements.length - 1];
2534 if(!actionElement && isActionElementAllowedByPredicate(container, predicate))
2535  actionElement = container;
2536 return actionElement;
2537};
2538ASPx.GetParentClientControls = function(name) {
2539 var nameParts = name.split("_");
2540 var result = [ ];
2541 var controlCollection = ASPx.GetControlCollection();
2542 for(var i = 1; i <= nameParts.length; i++) {
2543  var controlName = nameParts.slice(0, i).join("_");
2544  var control = controlCollection.Get(controlName);
2545  if(control)
2546   result.push(control);
2547 }
2548 return result;
2549};
2550ASPx.GetRootClientControl = function(childControlName) {
2551 var parentControls = ASPx.GetParentClientControls(childControlName);
2552 return parentControls[0];
2553};
2554ASPx.GetClientControlByElementID = function(elementID) {
2555 var parentControls = ASPx.GetParentClientControls(elementID);
2556 return parentControls[parentControls.length - 1];
2557};
2558ASPx.IsExists = function(obj){
2559 return (typeof(obj) != "undefined") && (obj != null);
2560};
2561ASPx.IsFunction = function(obj){
2562 return typeof(obj) == "function";
2563};
2564ASPx.IsNumber = function(str) {
2565 return !isNaN(parseFloat(str)) && isFinite(str);
2566};
2567ASPx.GetDefinedValue = function(value, defaultValue){
2568 return (typeof(value) != "undefined") ? value : defaultValue;
2569};
2570ASPx.CorrectJSFloatNumber = function(number) {
2571 var ret = 21; 
2572 var numString = number.toPrecision(21);
2573 numString = numString.replace("-", ""); 
2574 var integerDigitsCount = numString.indexOf(ASPx.PossibleNumberDecimalSeparators[0]);
2575 if(integerDigitsCount < 0)
2576  integerDigitsCount = numString.indexOf(ASPx.PossibleNumberDecimalSeparators[1]);
2577 var floatDigitsCount = numString.length - integerDigitsCount - 1;
2578 if(floatDigitsCount < 10)
2579  return number;
2580 if(integerDigitsCount > 0) {
2581  ret = integerDigitsCount + 12;
2582 }
2583 var toPrecisionNumber = Math.min(ret, 21);
2584 var newValueString = number.toPrecision(toPrecisionNumber);
2585 return parseFloat(newValueString, 10);
2586};
2587ASPx.CorrectRounding = function(number, step) { 
2588 var regex = /[,|.](.*)/,
2589  isFloatValue = regex.test(number),
2590  isFloatStep = regex.test(step);
2591 if(isFloatValue || isFloatStep) {
2592  var valueAccuracy = (isFloatValue) ? regex.exec(number)[0].length - 1 : 0,
2593   stepAccuracy = (isFloatStep) ? regex.exec(step)[0].length - 1 : 0,
2594   accuracy = Math.max(valueAccuracy, stepAccuracy);
2595  var multiplier = Math.pow(10, accuracy);
2596  number = Math.round((number + step) * multiplier) / multiplier;
2597  return number;
2598 }
2599 return number + step;
2600};

2601ASPx.GetActiveElement = function() {
2602 try{ return document.activeElement; } catch(e) { return null; }
2603};
2604var verticalScrollBarWidth;
2605ASPx.GetVerticalScrollBarWidth = function(nonZero) {
2606 if(typeof(verticalScrollBarWidth) === "undefined") {
2607  var container = document.createElement("DIV");
2608  container.style.cssText = "position: absolute; top: 0px; left: 0px; visibility: hidden; width: 200px; height: 150px; overflow: hidden; box-sizing: content-box";
2609  document.body.appendChild(container);
2610  var child = document.createElement("P");
2611  container.appendChild(child);
2612  child.style.cssText = "width: 100%; height: 200px;";
2613  var widthWithoutScrollBar = child.offsetWidth;
2614  container.style.overflow = "scroll";
2615  var widthWithScrollBar = child.offsetWidth;
2616  if(widthWithoutScrollBar == widthWithScrollBar)
2617   widthWithScrollBar = container.clientWidth;
2618  verticalScrollBarWidth = widthWithoutScrollBar - widthWithScrollBar;
2619  document.body.removeChild(container);
2620 }
2621 if(nonZero && verticalScrollBarWidth === 0) {
2622  if(ASPx.Browser.MacOSPlatform || ASPx.Browser.Firefox)
2623   return 12;
2624  if(ASPx.Browser.WebKitTouchUI)
2625   return 1;
2626 }
2627 return verticalScrollBarWidth;
2628};
2629function hideScrollBarCore(element, scrollName) {
2630 if(element.tagName == "IFRAME") {
2631  if((element.scrolling == "yes") || (element.scrolling == "auto")) {
2632   Attr.ChangeAttribute(element, "scrolling", "no");
2633   return true;
2634  }
2635 }
2636 else if(element.tagName == "DIV") {
2637  if((element.style[scrollName] == "scroll") || (element.style[scrollName] == "auto")) {
2638   Attr.ChangeStyleAttribute(element, scrollName, "hidden");
2639   return true;
2640  }
2641 }
2642 return false;
2643}
2644function restoreScrollBarCore(element, scrollName) {
2645 if(element.tagName == "IFRAME")
2646  return Attr.RestoreAttribute(element, "scrolling");
2647 else if(element.tagName == "DIV")
2648  return Attr.RestoreStyleAttribute(element, scrollName);
2649 return false;
2650}
2651ASPx.SetScrollBarVisibilityCore = function(element, scrollName, isVisible) {
2652 return isVisible ? restoreScrollBarCore(element, scrollName) : hideScrollBarCore(element, scrollName);
2653};
2654ASPx.SetScrollBarVisibility = function(element, isVisible) {
2655 if(ASPx.SetScrollBarVisibilityCore(element, "overflow", isVisible)) 
2656  return true;
2657 var result = ASPx.SetScrollBarVisibilityCore(element, "overflowX", isVisible)
2658  || ASPx.SetScrollBarVisibilityCore(element, "overflowY", isVisible);
2659 return result;
2660};
2661ASPx.SetInnerHtml = function(element, html) {
2662 setInnerHtmlInternal(element, html);
2663};
2664ASPx.GetInnerText = function(container) {
2665 if(Browser.Safari && Browser.MajorVersion <= 5) {
2666  var filter = getHtml2PlainTextFilter();
2667  setInnerHtmlInternal(filter, container.innerHTML);
2668  ASPx.SetElementDisplay(filter, true);
2669  var innerText = filter.innerText;
2670  ASPx.SetElementDisplay(filter, false);
2671  return innerText;
2672 } else if(Browser.NetscapeFamily || Browser.WebKitFamily || (Browser.IE && Browser.Version >= 9) || Browser.Edge) {
2673  return container.textContent;
2674 } else
2675  return container.innerText;
2676};
2677ASPx.GetEllipsisTooltipText = function(element) {
2678 var innerText = ASPx.GetInnerText(element);
2679 innerText = ASPx.RemoveComment(innerText);
2680 return innerText;
2681};
2682ASPx.RemoveComment = function(text) {
2683 var result = text;
2684 var commentStart = "<!--";
2685 var commentEnd = "//-->";
2686 var positionStart = result.indexOf(commentStart);
2687 while(positionStart > -1) {
2688  var positionEnd = result.indexOf(commentEnd);
2689  var startStr = result.substring(0, positionStart);
2690  var endStr = result.substring(positionEnd + commentEnd.length);
2691  result = startStr + endStr;
2692  positionStart = result.indexOf(commentStart);
2693 }
2694 return result;
2695};
2696var html2PlainTextFilter = null;
2697function getHtml2PlainTextFilter() {
2698 if(html2PlainTextFilter == null) {
2699  html2PlainTextFilter = document.createElement("DIV");
2700  html2PlainTextFilter.style.width = "0";
2701  html2PlainTextFilter.style.height = "0";
2702  html2PlainTextFilter.style.overflow = "visible";
2703  ASPx.SetElementDisplay(html2PlainTextFilter, false);
2704  document.body.appendChild(html2PlainTextFilter);
2705 }
2706 return html2PlainTextFilter;
2707}
2708ASPx.CreateHiddenField = function(name, id, parent) {
2709 var input = document.createElement("INPUT");
2710 input.setAttribute("type", "hidden");
2711 if(name)
2712  input.setAttribute("name", name);
2713 if(id)
2714  input.setAttribute("id", id);
2715 if(parent)
2716  parent.appendChild(input);
2717 return input;
2718};
2719ASPx.CloneObject = function(srcObject) {
2720 if(typeof(srcObject) != 'object' || srcObject == null)
2721  return srcObject;
2722 var newObject = {};
2723 for(var i in srcObject)
2724  newObject[i] = srcObject[i];
2725 return newObject;
2726};
2727ASPx.InsertRowsBefore = function(table, rowsHtml, index) {
2728 var row = null;
2729 if(index >= 0 && index < table.rows.length)
2730  row = table.rows[index];
2731 insertRowsBefore(table, rowsHtml, row);
2732};
2733var insertRowsBefore = function(table, rowsHtml, row) {
2734 if(!row && table.tBodies.length > 0) {
2735  row = document.createElement("TR");
2736  table.tBodies[0].appendChild(row);

2737  row.shouldRemove = true;
2738 }
2739 if(row) {
2740  row.insertAdjacentHTML("beforeBegin", rowsHtml);
2741  if(row.shouldRemove)
2742   ASPx.RemoveElement(row);
2743 }
2744};
2745ASPx.IsPercentageSize = function(size) {
2746 return size && size.indexOf('%') != -1;
2747};
2748ASPx.GetElementById = function(id) {
2749 if(document.getElementById)
2750  return document.getElementById(id);
2751 else
2752  return document.all[id];
2753};
2754ASPx.GetElementByIdInDocument = function(documentObj, id) {
2755 if(documentObj.getElementById)
2756  return documentObj.getElementById(id);
2757 else
2758  return documentObj.all[id];
2759};
2760ASPx.GetIsParent = function(parentElement, element) {
2761 if(!parentElement || !element)
2762  return false;
2763 while(element){
2764  if(element === parentElement)
2765   return true;
2766  if(element.tagName === "BODY")
2767   return false;
2768  element = element.parentNode;
2769 }
2770 return false;
2771};
2772ASPx.GetParentById = function(element, id) {
2773 element = element.parentNode;
2774 while(element){
2775  if(element.id === id)
2776   return element;
2777  element = element.parentNode;
2778 }
2779 return null;
2780};
2781ASPx.GetParentByPartialId = function(element, idPart){
2782 while(element && element.tagName != "BODY") {
2783  if(element.id && element.id.match(idPart)) 
2784   return element;
2785  element = element.parentNode;
2786 }
2787 return null;
2788};
2789ASPx.GetParentByTagName = function(element, tagName) {
2790 tagName = tagName.toUpperCase();
2791 while(element) {
2792  if(element.tagName === "BODY")
2793   return null;
2794  if(element.tagName === tagName)
2795   return element;
2796  element = element.parentNode;
2797 }
2798 return null;
2799};
2800function getParentByCondition(element, conditionArg, condition) {
2801 while(element != null) {
2802  if(element.tagName == "BODY" || element.nodeName == "#document")
2803   return null;
2804  if (condition(element, conditionArg))
2805   return element;
2806  element = element.parentNode;
2807 }
2808 return null;
2809}
2810ASPx.GetParentByPartialClassName = function(element, className) {
2811 return getParentByCondition(element, className, ASPx.ElementContainsCssClass);
2812};
2813ASPx.GetParentByClassName = function(element, className) {
2814 return getParentByCondition(element, className, ASPx.ElementHasCssClass);
2815};
2816ASPx.GetParentBySelector = function (element, selector) {
2817 return getParentByCondition(element, selector, ASPx.ElementMatchesSelector);
2818};
2819ASPx.GetParentByTagNameAndAttributeValue = function(element, tagName, attrName, attrValue) {
2820 tagName = tagName.toUpperCase();
2821 while(element != null) {
2822  if(element.tagName == "BODY")
2823   return null;
2824  if(element.tagName == tagName && element[attrName] == attrValue)
2825   return element;
2826  element = element.parentNode;
2827 }
2828 return null;
2829};
2830ASPx.GetParent = function(element, testFunc){
2831 if (!ASPx.IsExists(testFunc)) return null;
2832 while(element != null && element.tagName != "BODY"){
2833  if(testFunc(element))
2834   return element;
2835  element = element.parentNode;
2836 }
2837 return null;
2838};
2839ASPx.GetElementTreeLine = function(element, stopTagName, stopFunc) {
2840 var result = [];
2841 stopTagName = stopTagName || "BODY";
2842 while(element != null) {
2843  if(!stopFunc && element.tagName == stopTagName)
2844   break;
2845  if(stopFunc && stopFunc(element))
2846   break;
2847  result.push(element);
2848  element = element.parentNode;
2849 }
2850 return result;
2851};
2852ASPx.IsScrollableElement = function(element, isHorzScrollable, isVertScrollable) {
2853 isHorzScrollable = ASPx.IsExists(isHorzScrollable) ? isHorzScrollable : true;
2854 isVertScrollable = ASPx.IsExists(isVertScrollable) ? isVertScrollable : true;
2855 var style = ASPx.GetCurrentStyle(element);
2856 var overflowStyleNames = ["overflow"];
2857 if(isHorzScrollable)
2858  overflowStyleNames.push("overflowX");
2859 if(isVertScrollable)
2860  overflowStyleNames.push("overflowY");
2861 for(var i = 0; i < overflowStyleNames.length; i++)
2862  if(style[overflowStyleNames[i]] == "scroll" || style[overflowStyleNames[i]] == "auto")
2863   return true;
2864 return false;
2865};
2866ASPx.GetPreviousSibling = function(el) {
2867 if(el.previousElementSibling) {
2868  return el.previousElementSibling;
2869 } else {
2870  while(el = el.previousSibling) {
2871   if(el.nodeType === 1)
2872    return el;
2873  }
2874 }
2875};
2876ASPx.ElementMatchesSelector = (function (e) {
2877 return (function (matches) {
2878  return function (el, selector) { return !!el && !!selector && matches.call(el, selector); };
2879 })(e.matches || e.matchesSelector || e.webkitMatchesSelector || e.mozMatchesSelector || e.msMatchesSelector || e.oMatchesSelector);
2880})(Element.prototype);
2881ASPx.ElementHasCssClass = function(element, className) {
2882 try {
2883  var elementClasses;
2884  var classList = ASPx.GetClassNameList(element);
2885  if(!classList) {
2886   var elementClassName = ASPx.GetClassName(element);
2887   if(!elementClassName) {
2888    return false;
2889   }
2890   elementClasses = elementClassName.split(" ");
2891  }
2892  var classNames = className.split(" ");
2893  for(var i = classNames.length - 1; i >= 0; i--) {
2894   if(classList) {
2895    if(classList.indexOf(classNames[i]) === -1)
2896     return false;
2897    continue;
2898   }
2899   if(Data.ArrayIndexOf(elementClasses, classNames[i]) < 0)
2900    return false;
2901  }
2902  return true;
2903 } catch(e) {
2904  return false;
2905 }
2906};
2907ASPx.ElementContainsCssClass = function(element, className) {
2908 try {
2909  var elementClassName = ASPx.GetClassName(element);
2910  if(!elementClassName) {
2911   return false;
2912  }
2913  return elementClassName.indexOf(className) != -1;
2914 } catch(e) {
2915  return false;
2916 }
2917};
2918ASPx.AddClassNameToElement = function (element, className) {
2919 if(!element || typeof(className) !== "string" ) return;
2920 className = className.trim();
2921 if(!ASPx.ElementHasCssClass(element, className) && className !== "") {
2922  var oldClassName = ASPx.GetClassName(element);
2923  ASPx.SetClassName(element, (oldClassName === "") ? className : oldClassName + " " + className);
2924 }
2925};
2926ASPx.AddClassNamesToElement = function(element, classNames) {
2927 Data.ForEach(classNames, function(className) { ASPx.AddClassNameToElement(element, className); });
2928};

2929ASPx.CombineCssClasses = function() {
2930 return Array.prototype.slice.call(arguments).join(" ");
2931};
2932ASPx.RemoveClassNameFromElement = function(element, className) {
2933 if(!element) return;
2934 var elementClassName = ASPx.GetClassName(element);
2935 var updClassName = " " + elementClassName + " ";
2936 var newClassName = updClassName.replace(" " + className + " ", " ");
2937 if(updClassName.length != newClassName.length)
2938  ASPx.SetClassName(element, Str.Trim(newClassName));  
2939};
2940ASPx.RemoveClassNamesFromElement = function(element, classNames) {
2941 if(!element) return;
2942 for(var i = 0; i < classNames.length; i++) {
2943  var className = classNames[i];
2944  element.classList.remove(className);
2945 }
2946};
2947ASPx.ToggleClassNameToElement = function(element, className, toggleState) {
2948 if(!toggleState)
2949  ASPx.RemoveClassNameFromElement(element, className);
2950 if(toggleState && !ASPx.ElementHasCssClass(element, className))
2951  ASPx.AddClassNameToElement(element, className);
2952};
2953ASPx.GetClassNameList = function(element) {
2954 var result = [];
2955 if(element) {
2956  if(element.tagName === "svg") {
2957   result = ASPx.GetClassName(element).replace(/^\s+|\s+$/g, '').split(/\s+/);
2958  }
2959  else {
2960   result = element.classList ? [].slice.call(element.classList) : ASPx.GetClassName(element).replace(/^\s+|\s+$/g, '').split(/\s+/);
2961  }
2962 }
2963 return result;
2964};
2965ASPx.GetClassName = function(element) {
2966 var result = "";
2967 if(element) {
2968  if(element.tagName === "svg") {
2969   result = element.className.baseVal;
2970  }
2971  else {
2972   result = element.className ? element.className : "";
2973  }
2974 }
2975 return result;
2976};
2977ASPx.SetClassName = function(element, className) {
2978 if(element.tagName === "svg") {
2979  element.className.baseVal = Str.Trim(className);
2980 }
2981 else {
2982  element.className = Str.Trim(className);
2983 }
2984};
2985ASPx.GetElementOffsetWidth = function(element) {
2986 if(element.tagName === "svg") {
2987  return element.getBoundingClientRect().width;
2988 }
2989 else {
2990  return element.offsetWidth;
2991 }
2992};
2993ASPx.GetElementOffsetHeight = function(element) {
2994 if(element.tagName === "svg") {
2995  return element.getBoundingClientRect().height;
2996 }
2997 else {
2998  return element.offsetHeight;
2999 }
3000};
3001function nodeListToArray(nodeList, filter) {
3002 var result = [];
3003 for(var i = 0, element; element = nodeList[i]; i++) {
3004  if(filter && !filter(element))
3005   continue;
3006  result.push(element);
3007 }
3008 return result;
3009}
3010ASPx.NodeListToArray = nodeListToArray;
3011function getItemByIndex(collection, index) {
3012 if(!index) index = 0;
3013 if(collection != null && collection.length > index)
3014  return collection[index];
3015 return null;
3016}
3017ASPx.GetChildNodesByQuerySelector = function (parent, selector) {
3018 return nodeListToArray(parent.querySelectorAll(selector), function (el) { return el.parentNode === parent; });
3019};
3020ASPx.GetChildNodesByClassName = function(parent, className) {
3021 if(!parent) return [];
3022 if(parent.querySelectorAll) {
3023  var children = parent.querySelectorAll('.' + className);
3024  return nodeListToArray(children, function(element) { 
3025   return element.parentNode === parent;
3026  });
3027 }
3028 return ASPx.GetChildNodes(parent, function(elem) { return elem.className && ASPx.ElementHasCssClass(elem, className); });
3029};
3030ASPx.GetChildNodesByPartialClassName = function(element, className) {
3031 return ASPx.GetChildElementNodesByPredicate(element,
3032  function(child) {
3033   return ASPx.ElementContainsCssClass(child, className);
3034  });
3035};
3036ASPx.GetChildByPartialClassName = function(element, className, index) {
3037 if(element != null){    
3038  var collection = ASPx.GetChildNodesByPartialClassName(element, className);
3039  return getItemByIndex(collection, index);
3040 }
3041 return null;
3042};
3043ASPx.GetChildByClassName = function(element, className, index) {
3044 if(element != null){    
3045  var collection = ASPx.GetChildNodesByClassName(element, className);
3046  return getItemByIndex(collection, index);
3047 }
3048 return null;
3049};
3050ASPx.GetNodesByPartialClassName = function(element, className) {
3051 if(element.querySelectorAll) {
3052  var list = element.querySelectorAll('*[class*=' + className + ']');
3053  return nodeListToArray(list);
3054 }
3055 var collection = element.all || element.getElementsByTagName('*');
3056 var ret = [ ];
3057 if(collection != null) {
3058  for(var i = 0; i < collection.length; i ++) {
3059   if(ASPx.ElementContainsCssClass(collection[i], className))

3060    ret.push(collection[i]);
3061  }
3062 }
3063 return ret;
3064};
3065ASPx.GetNodesByClassName = function(parent, className) {
3066 if(parent.querySelectorAll) {
3067  var children = parent.querySelectorAll('.' + className);
3068  return nodeListToArray(children);
3069 }
3070 return ASPx.GetNodes(parent, function(elem) { return elem.className && ASPx.ElementHasCssClass(elem, className); });
3071};
3072ASPx.GetNodeByClassName = function(element, className, index) {
3073 if(element != null){    
3074  var collection = ASPx.GetNodesByClassName(element, className);
3075  return getItemByIndex(collection, index);
3076 }
3077 return null;
3078};
3079ASPx.GetChildById = function(element, id) {
3080 if(element.all) {
3081  var child = element.all[id];
3082  if(!child) {
3083   child = element.all(id); 
3084   if(!child)
3085    return null; 
3086  } 
3087  if(!ASPx.IsExists(child.length)) 
3088   return child;
3089  else
3090   return ASPx.GetElementById(id);
3091 }
3092 else
3093  return ASPx.GetElementById(id);
3094};
3095ASPx.GetNodesByPartialId = function(element, partialName, list) {
3096 if(element.id && element.id.indexOf(partialName) > -1) 
3097  list.push(element);
3098 if(element.childNodes) {
3099  for(var i = 0; i < element.childNodes.length; i ++) 
3100   ASPx.GetNodesByPartialId(element.childNodes[i], partialName, list);
3101 }
3102};
3103ASPx.GetNodesByTagName = function(element, tagName) {
3104 var tagNameToUpper = tagName.toUpperCase();
3105 var result = null;
3106 if(element) {
3107  if(element.getElementsByTagName) {
3108   result = element.getElementsByTagName(tagNameToUpper);
3109   if(result.length === 0) {
3110    result = element.getElementsByTagName(tagName);
3111   }
3112  }
3113  else if(element.all && element.all.tags !== undefined)
3114   result = Browser.Netscape ? element.all.tags[tagNameToUpper] : element.all.tags(tagNameToUpper);
3115 }
3116 return result;
3117};
3118ASPx.GetNodeByTagName = function(element, tagName, index) {
3119 if(element != null){    
3120  var collection = ASPx.GetNodesByTagName(element, tagName);
3121  return getItemByIndex(collection, index);
3122 }
3123 return null;
3124};
3125ASPx.GetChildNodesByTagName = function(parent, tagName) {
3126 return ASPx.GetChildNodes(parent, function (child) { return child.tagName === tagName; });
3127};
3128ASPx.GetChildByTagName = function(element, tagName, index) {
3129 if(element != null){    
3130  var collection = ASPx.GetChildNodesByTagName(element, tagName);
3131  return getItemByIndex(collection, index);
3132 }
3133 return null;
3134};
3135ASPx.RetrieveByPredicate = function(scourceCollection, predicate) {
3136 var result = [];
3137 for(var i = 0; i < scourceCollection.length; i++) {
3138  var element = scourceCollection[i];
3139  if(!predicate || predicate(element)) 
3140   result.push(element);
3141 }
3142 return result;
3143};
3144ASPx.GetChildNodes = function(parent, predicate) {
3145 return ASPx.RetrieveByPredicate(parent.childNodes, predicate);
3146};
3147ASPx.GetNodes = function(parent, predicate) {
3148 var c = parent.all || parent.getElementsByTagName('*');
3149 return ASPx.RetrieveByPredicate(c, predicate);
3150};
3151ASPx.GetChildElementNodes = function(parent) {
3152 if(!parent) return null;
3153 return ASPx.GetChildNodes(parent, function(e) { return e.nodeType == 1; });
3154};
3155ASPx.GetChildElementNodesByPredicate = function(parent, predicate) {
3156 if(!parent) return null;
3157 if(!predicate) return ASPx.GetChildElementNodes(parent);
3158 return ASPx.GetChildNodes(parent, function(e) { return e.nodeType == 1 && predicate(e); });
3159};
3160ASPx.GetTextNode = function(element, index) {
3161 if(element != null){
3162  var collection = [ ];
3163  ASPx.GetTextNodes(element, collection);
3164  return getItemByIndex(collection, index);
3165 }
3166 return null;
3167};
3168ASPx.GetTextNodes = function(element, collection) {
3169 if(element.tagName === "svg")
3170  return;
3171 for(var i = 0; i < element.childNodes.length; i ++){
3172  var childNode = element.childNodes[i];
3173  if(ASPx.IsExists(childNode.nodeValue))
3174   collection.push(childNode);
3175  ASPx.GetTextNodes(childNode, collection);
3176 }
3177};
3178ASPx.GetNormalizedTextNode = function(element, index) {
3179 var textNode = ASPx.GetTextNode(element, index);
3180 if(textNode != null)
3181  ASPx.MergeAdjacentTextNodes(textNode);
3182 return textNode;
3183};
3184ASPx.MergeAdjacentTextNodes = function(firstTextNode) {
3185 if(!ASPx.IsExists(firstTextNode.nodeValue))
3186  return;
3187 var textNode = firstTextNode;
3188 while(textNode.nextSibling && ASPx.IsExists(textNode.nextSibling.nodeValue)) {
3189  textNode.nodeValue += textNode.nextSibling.nodeValue;
3190  textNode.parentNode.removeChild(textNode.nextSibling);
3191 }
3192};
3193ASPx.GetElementDocument = function(element) {
3194 return element.document || element.ownerDocument;
3195};
3196ASPx.RemoveElement = function(element) {
3197 if(element && element.parentNode)
3198  element.parentNode.removeChild(element);
3199};
3200ASPx.ReplaceTagName = function(element, newTagName, cloneChilds) {
3201 if(element.nodeType != 1)
3202  return null;
3203 if(element.nodeName == newTagName)
3204  return element;
3205 cloneChilds = cloneChilds !== undefined ? cloneChilds : true;
3206 var doc = element.ownerDocument;
3207 var newElem = doc.createElement(newTagName);
3208 Attr.CopyAllAttributes(element, newElem);
3209 if(cloneChilds) {
3210  for(var i = 0; i < element.childNodes.length; i++)
3211   newElem.appendChild(element.childNodes[i].cloneNode(true));
3212 }
3213 else {
3214  for(var child; child = element.firstChild; )
3215   newElem.appendChild(child);
3216 }
3217 element.parentNode.replaceChild(newElem, element);
3218 return newElem;
3219};
3220ASPx.RemoveOuterTags = function(element) {
3221 var docFragment = element.ownerDocument.createDocumentFragment();
3222 for(var i = 0; i < element.childNodes.length; i++)
3223  docFragment.appendChild(element.childNodes[i].cloneNode(true));
3224 element.parentNode.replaceChild(docFragment, element);
3225};
3226ASPx.WrapElementInNewElement = function(element, newElementTagName) { 
3227 var wrapElement = null;
3228 var docFragment = element.ownerDocument.createDocumentFragment();
3229 wrapElement = element.ownerDocument.createElement(newElementTagName);
3230 docFragment.appendChild(wrapElement);
3231 wrapElement.appendChild(element.cloneNode(true));
3232 element.parentNode.replaceChild(docFragment, element);
3233 return wrapElement;
3234};
3235ASPx.InsertElementAfter = function(newElement, targetElement) {
3236 var parentElem = targetElement.parentNode;
3237 if(parentElem.childNodes[parentElem.childNodes.length - 1] == targetElement)
3238  parentElem.appendChild(newElement);
3239 else if(newElement !== targetElement.nextSibling)
3240  parentElem.insertBefore(newElement, targetElement.nextSibling);
3241};
3242ASPx.SetElementOpacity = function(element, value) {
3243  element.style.opacity = value;
3244};
3245ASPx.GetElementOpacity = function(element) {
3246 return parseFloat(ASPx.GetCurrentStyle(element).opacity);
3247};
3248ASPx.HiddenChangable = "dx-hc";
3249ASPx.DefaultDisplayNoneSelectors = [ "dxmodalSys" ];
3250ASPx.DefaultDisplaySelectors = ["show"];
3251function getIsDefaultDisplayNone(element) {
3252 for(var i = 0; i < ASPx.DefaultDisplayNoneSelectors.length; i++) {
3253  if(ASPx.ElementHasCssClass(element, ASPx.DefaultDisplayNoneSelectors[i]))
3254   return true;
3255 }
3256 return false;
3257}
3258ASPx.GetElementDisplay = function(element, isCurrentStyle) {
3259 if(isCurrentStyle) {
3260  var currentStyle = ASPx.GetCurrentStyle(element);
3261  if(currentStyle)
3262   return currentStyle.display != "none";
3263 }
3264 if(getIsDefaultDisplayNone(element))
3265  return element.style.display != "none" && element.style.display != "" || ASPx.DefaultDisplaySelectors.some(function(s) { return ASPx.ElementHasCssClass(element, s); });
3266 return element.style.display != "none" && !ASPx.ElementHasCssClass(element, ASPx.HiddenChangable);
3267};
3268ASPx.SetElementDisplay = function(element, value) {
3269 if(!element) return;
3270 if(ASPx.ElementHasCssClass(element, ASPx.HiddenChangable))
3271  ASPx.RemoveClassNameFromElement(element, ASPx.HiddenChangable);
3272 if(typeof(value) === "string")
3273  element.style.display = value;
3274 else if(getIsDefaultDisplayNone(element))
3275  element.style.display = value ? (element.tagName === "TABLE" ? "table" : "block") : "";
3276 else if(!value)
3277  element.style.display = "none";
3278 else

3279  element.style.display = "";
3280};
3281ASPx.GetElementVisibility = function(element, isCurrentStyle) {
3282 if(isCurrentStyle) {
3283  var currentStyle = ASPx.GetCurrentStyle(element);
3284  if(currentStyle)
3285   return currentStyle.visibility != "hidden";
3286 }
3287 return element.style.visibility != "hidden";
3288};
3289ASPx.SetElementVisibility = function(element, value) {
3290 if(!element) return;
3291 if(typeof(value) === "string")
3292  element.style.visibility = value;
3293 else
3294  element.style.visibility = value ? "visible" : "hidden";
3295};
3296ASPx.IsElementVisible = function(element, isCurrentStyle) {
3297 if(!element) return false;
3298 while(element && element.tagName != "BODY") {
3299  if(!ASPx.GetElementDisplay(element, isCurrentStyle) || (!ASPx.GetElementVisibility(element, isCurrentStyle) && !Attr.IsExistsAttribute(element, "errorFrame")))
3300     return false;
3301  element = element.parentNode;
3302 }
3303 return true;
3304};
3305ASPx.IsElementDisplayed = function(element) {
3306 if(!element) return false;
3307 while(element && element.tagName != "BODY") {
3308  if(!ASPx.GetElementDisplay(element))
3309     return false;
3310  element = element.parentNode;
3311 }
3312 return true;
3313};
3314ASPx.GetElementInitializedFlag = function(element) {
3315 return element["dxinit"];
3316};
3317ASPx.SetElementInitializedFlag = function(element) {
3318 element["dxinit"] = true;
3319};
3320ASPx.AddStyleSheetLinkToDocument = function(doc, linkUrl) {
3321 var newLink = createStyleLink(doc, linkUrl);
3322 var head = ASPx.GetHeadElementOrCreateIfNotExist(doc);
3323 head.appendChild(newLink);
3324 return newLink;
3325};
3326ASPx.GetHeadElementOrCreateIfNotExist = function(doc) {
3327 var elements = ASPx.GetNodesByTagName(doc, "head");
3328 var head = null;
3329 if(elements.length == 0) {
3330  head = doc.createElement("head");
3331  head.visibility = "hidden";
3332  doc.insertBefore(head, doc.body);
3333 } else
3334  head = elements[0];
3335 return head;
3336};
3337function createStyleLink(doc, url) {
3338 var newLink = doc.createElement("link");
3339 Attr.SetAttribute(newLink, "href", url);
3340 Attr.SetAttribute(newLink, "rel", "stylesheet");
3341 Attr.AppendStyleType(newLink);
3342 return newLink;
3343}
3344ASPx.GetCurrentStyle = function(element) {
3345 if(document.defaultView && document.defaultView.getComputedStyle) { 
3346  var result = document.defaultView.getComputedStyle(element, null);
3347  if(!result && Browser.Firefox && window.frameElement) {
3348   var changes = [];
3349   var curElement = window.frameElement;
3350   while(!(result = document.defaultView.getComputedStyle(element, null))) {
3351    changes.push([curElement, curElement.style.display]);
3352    ASPx.SetStylesCore(curElement, "display", "block", true);
3353    curElement = curElement.tagName == "BODY" ? curElement.ownerDocument.defaultView.frameElement : curElement.parentNode;
3354   }
3355   result = ASPx.CloneObject(result);
3356   for(var ch, i = 0; ch = changes[i]; i++)
3357    ASPx.SetStylesCore(ch[0], "display", ch[1]);
3358   var dummy = document.body.offsetWidth; 
3359  }
3360  if(Browser.Firefox && Browser.MajorVersion >= 62 && window.frameElement && result.length === 0) { 
3361   result = ASPx.CloneObject(result);
3362   result.display = element.style.display;
3363  }
3364  return result;
3365 }
3366 return window.getComputedStyle(element, null);
3367};
3368ASPx.CreateStyleSheetInDocument = function(doc) {
3369 if(doc.createStyleSheet) {
3370  try {
3371   return doc.createStyleSheet();
3372  }
3373  catch(e) {
3374   var message = "The CSS link limit (31) has been exceeded. Please enable CSS merging or reduce the number of CSS files on the page. For details, see http://www.devexpress.com/Support/Center/p/K18487.aspx.";
3375   throw new Error(message);
3376  }
3377 }
3378 else {
3379  var styleSheet = doc.createElement("STYLE");
3380  ASPx.GetNodeByTagName(doc, "HEAD", 0).appendChild(styleSheet);
3381  return styleSheet.sheet;
3382 }
3383};
3384ASPx.currentStyleSheet = null;
3385ASPx.GetCurrentStyleSheet = function() {
3386 if(!ASPx.currentStyleSheet)
3387  ASPx.currentStyleSheet = ASPx.CreateStyleSheetInDocument(document);
3388 return ASPx.currentStyleSheet;
3389};
3390function getStyleSheetRules(styleSheet){
3391 try {
3392  if (styleSheet.href && styleSheet.href.indexOf("file:///") === 0)
3393   return null;
3394  return styleSheet.cssRules;
3395 }
3396 catch(e) {
3397  return null;
3398 }
3399}
3400ASPx.cachedCssRules = { };
3401ASPx.GetStyleSheetRules = function (className, stylesStorageDocument) {
3402 if(ASPx.cachedCssRules[className]) {
3403  if(ASPx.cachedCssRules[className] != ASPx.EmptyObject)
3404   return ASPx.cachedCssRules[className];
3405  return null;
3406 }
3407 var result = iterateStyleSheetRules(stylesStorageDocument, function(rule) {
3408  if(rule.selectorText == "." + className){
3409   ASPx.cachedCssRules[className] = rule;
3410   return rule;
3411  }
3412 });
3413 if(ASPx.IsExists(result))
3414  return result;
3415 ASPx.cachedCssRules[className] = ASPx.EmptyObject;
3416 return null;
3417};
3418function iterateStyleSheetRules(stylesStorageDocument, callback) {
3419 var doc = stylesStorageDocument || document;
3420 for(var i = 0; i < doc.styleSheets.length; i ++){
3421  var styleSheet = doc.styleSheets[i];

3422  var rules = getStyleSheetRules(styleSheet);
3423  if(rules != null){
3424   for(var j = 0; j < rules.length; j ++) {
3425    var result = callback(rules[j]);
3426    if(result !== undefined)
3427     return result;
3428   }
3429  }
3430 }
3431}
3432ASPx.ProcessStyleSheetRules = function(prefix, callback) {
3433 iterateStyleSheetRules(null, function(rule) {
3434  if(!!rule.selectorText && rule.selectorText.indexOf(prefix) === 0) {
3435   var name = rule.selectorText.substring(prefix.length);
3436   var result = callback(name, rule.style, rule);
3437   if(result !== undefined)
3438    return result;
3439  }
3440 });
3441};
3442ASPx.ClearCachedCssRules = function(){
3443 ASPx.cachedCssRules = { };
3444};
3445var styleCount = 0;
3446var styleNameCache = { };
3447ASPx.CreateImportantStyleRule = function(styleSheet, cssText, postfix, prefix) {
3448 styleSheet = styleSheet || ASPx.GetCurrentStyleSheet();
3449 var cacheKey = (postfix ? postfix + "||" : "") + cssText + (prefix ? "||" + prefix : "");
3450 if(styleNameCache[cacheKey])
3451  return styleNameCache[cacheKey];
3452 prefix = prefix ? prefix + " " : "";
3453 var className = "dxh" + styleCount + (postfix ? postfix : "");
3454 ASPx.AddStyleSheetRule(styleSheet, prefix + "." + className, ASPx.CreateImportantCssText(cssText));
3455 styleCount++;
3456 styleNameCache[cacheKey] = className;
3457 return className; 
3458};
3459ASPx.CreateImportantCssText = function(cssText) {
3460 var newText = "";
3461 var hasEncodedSemicolon = cssText.indexOf(ASPx.StyleValueEncodedSemicolon) > -1;
3462 var attributes = cssText.split(";");
3463 for(var i = 0; i < attributes.length; i++) {
3464  var rule = attributes[i];
3465  if(rule != "")
3466   newText += ASPx.CreateImportantCssRule(rule, hasEncodedSemicolon);
3467 }
3468 return newText;
3469};
3470ASPx.CreateImportantCssRule = function(rule, hasEncodedSemicolon) {
3471 var result = rule;
3472 if(hasEncodedSemicolon) {
3473  var regex = new RegExp(ASPx.StyleValueEncodedSemicolon, "g");
3474  result = result.replace(regex, ";");
3475 }
3476 result = result + " !important;";
3477 return result;
3478};
3479ASPx.AddStyleSheetRule = function(styleSheet, selector, cssText){
3480 if(!cssText) return;
3481 var index = styleSheet.cssRules.length;
3482 styleSheet.insertRule(selector + " { " + cssText + " }", index);
3483 return styleSheet.cssRules[index];
3484};
3485ASPx.GetPointerCursor = function() {
3486 return "pointer";
3487};
3488ASPx.SetPointerCursor = function(element) {
3489 if(element.style.cursor == "")
3490  element.style.cursor = ASPx.GetPointerCursor();
3491};
3492ASPx.SetElementFloat = function(element, value) {
3493 if(ASPx.IsExists(element.style.cssFloat))
3494  element.style.cssFloat = value;
3495 else if(ASPx.IsExists(element.style.styleFloat))
3496  element.style.styleFloat = value;
3497 else
3498  Attr.SetAttribute(element.style, "float", value);
3499};
3500ASPx.GetElementFloat = function(element) {
3501 var currentStyle = ASPx.GetCurrentStyle(element);
3502 if(ASPx.IsExists(currentStyle.cssFloat))
3503  return currentStyle.cssFloat;
3504 if(ASPx.IsExists(currentStyle.styleFloat))
3505  return currentStyle.styleFloat;
3506 return Attr.GetAttribute(currentStyle, "float");
3507};
3508function getElementDirection(element) {
3509 return ASPx.GetCurrentStyle(element).direction;
3510}
3511ASPx.IsElementRightToLeft = function(element) {
3512 return getElementDirection(element) == "rtl";
3513};
3514ASPx.AdjustVerticalMarginsInContainer = function(container) {
3515 var containerBorderAndPaddings = ASPx.GetTopBottomBordersAndPaddingsSummaryValue(container);
3516 var flowElements = [], floatElements = [], floatTextElements = [];
3517 var maxHeight = 0, maxFlowHeight = 0;
3518 for(var i = 0; i < container.childNodes.length; i++) {
3519  var element = container.childNodes[i];
3520  if(!element.offsetHeight) continue;
3521  ASPx.ClearVerticalMargins(element);
3522 }
3523 for(var i = 0; i < container.childNodes.length; i++) {
3524  var element = container.childNodes[i];
3525  if(!element.offsetHeight) continue;
3526  var float = ASPx.GetElementFloat(element);
3527  var isFloat = (float === "left" || float === "right");
3528  if(isFloat)
3529   floatElements.push(element);
3530  else {
3531   flowElements.push(element);
3532   if(element.tagName !== "IMG"){
3533    if(!ASPx.IsTextWrapped(element))
3534     element.style.verticalAlign = 'baseline'; 
3535    floatTextElements.push(element);
3536   }
3537   if(element.tagName === "DIV")
3538    Attr.ChangeStyleAttribute(element, "float", "left"); 
3539  }
3540  if(element.offsetHeight > maxHeight) 
3541   maxHeight = element.offsetHeight;
3542  if(!isFloat && element.offsetHeight > maxFlowHeight) 
3543   maxFlowHeight = element.offsetHeight;
3544 }
3545 for(var i = 0; i < flowElements.length; i++) 
3546  Attr.RestoreStyleAttribute(flowElements[i], "float");
3547 var containerBorderAndPaddings = ASPx.GetTopBottomBordersAndPaddingsSummaryValue(container);
3548 var containerHeight = container.offsetHeight - containerBorderAndPaddings;
3549 if(maxHeight == containerHeight) {
3550  var verticalAlign = ASPx.GetCurrentStyle(container).verticalAlign;
3551  for(var i = 0; i < floatTextElements.length; i++)
3552   floatTextElements[i].style.verticalAlign = '';
3553  containerHeight = container.offsetHeight - containerBorderAndPaddings;
3554  for(var i = 0; i < floatElements.length; i++)
3555   adjustVerticalMarginsCore(floatElements[i], containerHeight, verticalAlign, true);
3556  for(var i = 0; i < flowElements.length; i++) {
3557   if(maxFlowHeight != maxHeight)
3558    adjustVerticalMarginsCore(flowElements[i], containerHeight, verticalAlign);
3559  }
3560 }
3561};
3562ASPx.AdjustVerticalMargins = function(element) {
3563 ASPx.ClearVerticalMargins(element);
3564 var parentElement = element.parentNode;
3565 var parentHeight = parentElement.getBoundingClientRect().height - ASPx.GetTopBottomBordersAndPaddingsSummaryValue(parentElement);
3566 adjustVerticalMarginsCore(element, parentHeight, ASPx.GetCurrentStyle(parentElement).verticalAlign);
3567};
3568function adjustVerticalMarginsCore(element, parentHeight, verticalAlign, toBottom) {
3569 var marginTop;
3570 if(verticalAlign == "top")
3571  marginTop = 0;
3572 else if(verticalAlign == "bottom")
3573  marginTop = parentHeight - element.getBoundingClientRect().height;
3574 else

3575  marginTop = (parentHeight - element.getBoundingClientRect().height) / 2;
3576 if(marginTop !== 0){
3577  element.style.marginTop = marginTop + "px";
3578 }
3579}
3580ASPx.ClearVerticalMargins = function(element) {
3581 element.style.marginTop = "";
3582 element.style.marginBottom = "";
3583};
3584ASPx.AdjustHeightInContainer = function(container) {
3585 var height = container.offsetHeight - ASPx.GetTopBottomBordersAndPaddingsSummaryValue(container);
3586 for(var i = 0; i < container.childNodes.length; i++) {
3587  var element = container.childNodes[i];
3588  if(!element.offsetHeight) continue;
3589  ASPx.ClearHeight(element);
3590 }
3591 var elements = [];
3592 var childrenHeight = 0;
3593 for(var i = 0; i < container.childNodes.length; i++) {
3594  var element = container.childNodes[i];
3595  if(!element.offsetHeight) continue;
3596  childrenHeight += element.offsetHeight + ASPx.GetTopBottomMargins(element);
3597  elements.push(element);
3598 }
3599 if(elements.length > 0 && childrenHeight < height) {
3600  var correctedHeight = 0;
3601  for(var i = 0; i < elements.length; i++) {
3602   var elementHeight = 0;
3603   if(i < elements.length - 1){
3604    var elementHeight = Math.floor(height / elements.length);
3605    correctedHeight += elementHeight;
3606   }
3607   else{
3608    var elementHeight = height - correctedHeight;
3609    if(elementHeight < 0) elementHeight = 0;
3610   }
3611   adjustHeightCore(elements[i], elementHeight);
3612  }
3613 }
3614};
3615ASPx.AdjustHeight = function(element) {
3616 ASPx.ClearHeight(element);
3617 var parentElement = element.parentNode;
3618 var height = parentElement.getBoundingClientRect().height - ASPx.GetTopBottomBordersAndPaddingsSummaryValue(parentElement);
3619 adjustHeightCore(element, height);
3620};
3621function adjustHeightCore(element, height) {
3622 var height = height - ASPx.GetTopBottomBordersAndPaddingsSummaryValue(element);
3623 if(height < 0) height = 0;
3624 element.style.height = height + "px";
3625}
3626ASPx.ClearHeight = function(element) {
3627 element.style.height = "";
3628};
3629ASPx.ShrinkWrappedTextInContainer = function(container) {
3630 if(!container) return;
3631 for(var i = 0; i < container.childNodes.length; i++){
3632  var child = container.childNodes[i];
3633  if(child.style && ASPx.IsTextWrapped(child)) {
3634   Attr.ChangeStyleAttribute(child, "width", "1px");
3635   child.shrinkedTextContainer = true;
3636  }
3637 }
3638};
3639ASPx.AdjustWrappedTextInContainer = function(container) {
3640 if(!container) return;
3641 var textContainer, leftWidth = 0, rightWidth = 0;
3642 for(var i = 0; i < container.childNodes.length; i++){
3643  var child = container.childNodes[i];
3644  if(child.tagName === "BR")
3645   return;
3646  if(!child.tagName)
3647   continue;
3648  if(child.tagName !== "IMG"){
3649   textContainer = child;
3650   if(ASPx.IsTextWrapped(textContainer)){
3651    if(!textContainer.shrinkedTextContainer)
3652     textContainer.style.width = "";
3653    textContainer.style.marginRight = "";
3654   }
3655  }
3656  else {
3657   if(ASPx.GetElementOffsetWidth(child)=== 0)
3658    Evt.AttachEventToElement(child, "load", function(evt) { ASPx.AdjustWrappedTextInContainer(container); });
3659   else {
3660    var width = ASPx.GetElementOffsetWidth(child) + ASPx.GetLeftRightMargins(child);
3661    if(textContainer)
3662     rightWidth += width;
3663    else
3664     leftWidth += width;
3665   }
3666  }
3667 }
3668 if(textContainer && ASPx.IsTextWrapped(textContainer)) {
3669  var containerWidth = ASPx.GetElementOffsetWidth(container) - ASPx.GetLeftRightBordersAndPaddingsSummaryValue(container);
3670  if(textContainer.shrinkedTextContainer) {
3671   Attr.RestoreStyleAttribute(textContainer, "width");
3672   Attr.ChangeStyleAttribute(container, "width", containerWidth + "px");
3673  }
3674  if(ASPx.GetElementOffsetWidth(textContainer) + leftWidth + rightWidth >= containerWidth) {
3675    if(rightWidth > 0 && !textContainer.shrinkedTextContainer)
3676    textContainer.style.width = (containerWidth - rightWidth) + "px";
3677   else if(leftWidth > 0){
3678    if(ASPx.IsElementRightToLeft(container))
3679     textContainer.style.marginLeft = leftWidth + "px";
3680    else
3681     textContainer.style.marginRight = leftWidth + "px";
3682   }
3683  }
3684 }
3685};
3686ASPx.IsTextWrapped = function(element) {
3687 return element && ASPx.GetCurrentStyle(element).whiteSpace !== "nowrap";
3688};
3689ASPx.IsValidPosition = function(pos){
3690 return pos != ASPx.InvalidPosition && pos != -ASPx.InvalidPosition;
3691};
3692ASPx.getSpriteMainElement = function(element) {
3693 var cssClassMarker = "dx-acc";
3694 if(ASPx.ElementContainsCssClass(element, cssClassMarker))
3695  return element;
3696 if(element.parentNode && ASPx.ElementContainsCssClass(element.parentNode, cssClassMarker))
3697  return element.parentNode;
3698 return element;
3699};
3700ASPx.GetAbsoluteX = function(curEl){
3701 return ASPx.GetAbsolutePositionX(curEl);
3702};

3703ASPx.GetAbsoluteY = function(curEl){
3704 return ASPx.GetAbsolutePositionY(curEl);
3705};
3706ASPx.SetAbsoluteX = function(element, x){
3707 element.style.left = ASPx.PrepareClientPosForElement(x, element, true) + "px";
3708};
3709ASPx.SetAbsoluteY = function(element, y){
3710 element.style.top = ASPx.PrepareClientPosForElement(y, element, false) + "px";
3711};
3712ASPx.GetAbsolutePositionX = function(element){
3713 if(Browser.Firefox && Browser.Version >= 3)
3714  return getAbsolutePositionX_FF3(element);
3715 else if(Browser.Opera)
3716  return getAbsolutePositionX_Opera(element);
3717 else if(Browser.NetscapeFamily && (!Browser.Firefox || Browser.Version < 3))
3718  return getAbsolutePositionX_NS(element);
3719 else if(Browser.WebKitFamily || Browser.Edge)
3720  return getAbsolutePositionX_FF3(element);
3721 else
3722  return getAbsolutePositionX_Other(element);
3723};
3724function getAbsolutePositionX_Opera(curEl){
3725 var isFirstCycle = true;
3726 var pos = getAbsoluteScrollOffset_OperaFF(curEl, true);
3727 while(curEl != null) {
3728  pos += curEl.offsetLeft;
3729  if(!isFirstCycle)
3730   pos -= curEl.scrollLeft;
3731  curEl = curEl.offsetParent;
3732  isFirstCycle = false;
3733 }
3734 pos += document.body.scrollLeft;
3735 return pos;
3736}
3737function getAbsolutePositionX_FF3(element){
3738 if(element == null) return 0;
3739 var x = element.getBoundingClientRect().left + ASPx.GetDocumentScrollLeft();
3740 return x;
3741}
3742function getAbsolutePositionX_NS(curEl){
3743 var pos = getAbsoluteScrollOffset_OperaFF(curEl, true);
3744 var isFirstCycle = true;
3745 while(curEl != null) {
3746  pos += curEl.offsetLeft;
3747  if(!isFirstCycle && curEl.offsetParent != null)
3748   pos -= curEl.scrollLeft;
3749  if(!isFirstCycle && Browser.Firefox){
3750   var style = ASPx.GetCurrentStyle(curEl);
3751   if(curEl.tagName == "DIV" && style.overflow != "visible")
3752    pos += ASPx.PxToInt(style.borderLeftWidth);
3753  }
3754  isFirstCycle = false;
3755  curEl = curEl.offsetParent;
3756 }
3757 return pos;
3758}
3759function getAbsolutePositionX_Other(curEl){
3760 var pos = 0;
3761 var isFirstCycle = true;
3762 while(curEl != null) {
3763  pos += curEl.offsetLeft;
3764  if(!isFirstCycle && curEl.offsetParent != null)
3765   pos -= curEl.scrollLeft;
3766  isFirstCycle = false;
3767  curEl = curEl.offsetParent;
3768 }
3769 return pos;
3770}
3771ASPx.GetAbsolutePositionY = function(element){
3772 if(Browser.Firefox && Browser.Version >= 3)
3773  return getAbsolutePositionY_FF3(element);
3774 else if(Browser.Opera)
3775  return getAbsolutePositionY_Opera(element);
3776 else if(Browser.NetscapeFamily && (!Browser.Firefox || Browser.Version < 3))
3777  return getAbsolutePositionY_NS(element);
3778 else if(Browser.WebKitFamily || Browser.Edge)
3779  return getAbsolutePositionY_FF3(element);
3780 else
3781  return getAbsolutePositionY_Other(element);
3782};
3783function getAbsolutePositionY_Opera(curEl){
3784 var isFirstCycle = true;
3785 if(curEl && curEl.tagName == "TR" && curEl.cells.length > 0)
3786  curEl = curEl.cells[0];
3787 var pos = getAbsoluteScrollOffset_OperaFF(curEl, false);
3788 while(curEl != null) {
3789  pos += curEl.offsetTop;
3790  if(!isFirstCycle)
3791   pos -= curEl.scrollTop;
3792  curEl = curEl.offsetParent;
3793  isFirstCycle = false;
3794 }
3795 pos += document.body.scrollTop;
3796 return pos;
3797}
3798function getAbsolutePositionY_FF3(element){
3799 if(element == null) return 0;
3800 var y = element.getBoundingClientRect().top + ASPx.GetDocumentScrollTop();
3801 return y;
3802}
3803function getAbsolutePositionY_NS(curEl){
3804 var pos = getAbsoluteScrollOffset_OperaFF(curEl, false);
3805 var isFirstCycle = true;
3806 while(curEl != null) {
3807  pos += curEl.offsetTop;
3808  if(!isFirstCycle && curEl.offsetParent != null)
3809   pos -= curEl.scrollTop;
3810  if(!isFirstCycle && Browser.Firefox){
3811   var style = ASPx.GetCurrentStyle(curEl);
3812   if(curEl.tagName == "DIV" && style.overflow != "visible")
3813    pos += ASPx.PxToInt(style.borderTopWidth);
3814  }
3815  isFirstCycle = false;
3816  curEl = curEl.offsetParent;
3817 }
3818 return pos;
3819}
3820function getAbsoluteScrollOffset_OperaFF(curEl, isX) {
3821 var pos = 0;   
3822 var isFirstCycle = true;
3823 while(curEl != null) {
3824  if(curEl.tagName == "BODY")
3825   break;
3826  var style = ASPx.GetCurrentStyle(curEl);
3827  if(style.position == "absolute")
3828   break;
3829  if(!isFirstCycle && curEl.tagName == "DIV" && (style.position == "" || style.position == "static"))
3830   pos -= isX ? curEl.scrollLeft : curEl.scrollTop;
3831  curEl = curEl.parentNode;
3832  isFirstCycle = false;
3833 }
3834 return pos; 
3835}
3836function getAbsolutePositionY_Other(curEl){
3837 var pos = 0;
3838 var isFirstCycle = true;
3839 while(curEl != null) {
3840  pos += curEl.offsetTop;
3841  if(!isFirstCycle && curEl.offsetParent != null)
3842   pos -= curEl.scrollTop;
3843  isFirstCycle = false;
3844  curEl = curEl.offsetParent;
3845 }
3846 return pos;
3847}
3848function createElementMock(element) {
3849 var div = document.createElement('DIV');
3850 div.style.top = "0px";

3851 div.style.left = "0px";
3852 div.visibility = "hidden";
3853 div.style.position = ASPx.GetCurrentStyle(element).position;
3854 return div;
3855}
3856ASPx.PrepareClientPosElementForOtherParent = function(pos, element, otherParent, isX) {
3857 if(element.parentNode == otherParent)
3858  return ASPx.PrepareClientPosForElement(pos, element, isX);
3859 var elementMock = createElementMock(element);
3860 otherParent.appendChild(elementMock); 
3861 var preparedPos = ASPx.PrepareClientPosForElement(pos, elementMock, isX);
3862 otherParent.removeChild(elementMock);
3863 return preparedPos;
3864};
3865ASPx.PrepareClientPosForElement = function(pos, element, isX) {
3866 pos -= ASPx.GetPositionElementOffset(element, isX);
3867 return pos;
3868};
3869function getExperimentalPositionOffset(element, isX) {
3870 var div = createElementMock(element);
3871 if(div.style.position == "static")
3872  div.style.position = "absolute";
3873 element.parentNode.appendChild(div); 
3874 var realPos = isX ? ASPx.GetAbsoluteX(div) : ASPx.GetAbsoluteY(div);
3875 element.parentNode.removeChild(div);
3876 return realPos;
3877}
3878ASPx.GetPositionElementOffset = function(element, isX) {
3879 return getExperimentalPositionOffset(element, isX);
3880};
3881ASPx.GetSizeOfText = function(text, textCss) {
3882 var testContainer = document.createElement("tester");
3883 var defaultLineHeight = ASPx.Browser.Firefox ? "1" : "";
3884 testContainer.style.fontSize = textCss.fontSize;
3885 testContainer.style.fontFamily = textCss.fontFamily;
3886 testContainer.style.fontWeight = textCss.fontWeight;
3887 testContainer.style.letterSpacing = textCss.letterSpacing;
3888 testContainer.style.lineHeight = textCss.lineHeight || defaultLineHeight;
3889 testContainer.style.position = "absolute";
3890 testContainer.style.top = ASPx.InvalidPosition + "px";
3891 testContainer.style.left = ASPx.InvalidPosition + "px";
3892 testContainer.style.width = "auto";
3893 testContainer.style.whiteSpace = "nowrap";
3894 testContainer.appendChild(document.createTextNode(text));
3895 var testElement = document.body.appendChild(testContainer);
3896 var size = {
3897  "width": testElement.offsetWidth,
3898  "height": testElement.offsetHeight
3899 };
3900 document.body.removeChild(testElement);
3901 return size;
3902};
3903ASPx.PointToPixel = function(points, addPx) {  
3904 var result = 0;
3905 try {
3906  var indexOfPt = points.toLowerCase().indexOf("pt");
3907  if(indexOfPt > -1)
3908   result = parseInt(points.substr(0, indexOfPt)) * 96 / 72;
3909  else
3910   result = parseInt(points) * 96 / 72;
3911  if(addPx)
3912   result = result + "px";
3913 } catch(e) {}
3914 return result;
3915};
3916ASPx.PixelToPoint = function(pixels, addPt) { 
3917 var result = 0;
3918 try {
3919  var indexOfPx = pixels.toLowerCase().indexOf("px");
3920  if(indexOfPx > -1)
3921   result = parseInt(pixels.substr(0, indexOfPx)) * 72 / 96;
3922  else
3923   result = parseInt(pixels) * 72 / 96;
3924  if(addPt)
3925   result = result + "pt";
3926 } catch(e) {}
3927 return result;         
3928};
3929ASPx.PxToInt = function(px) {
3930 return pxToNumber(px, parseInt);
3931};
3932ASPx.PxToFloat = function(px) {
3933 return pxToNumber(px, parseFloat);
3934};
3935function pxToNumber(px, parseFunction) {
3936 var result = 0;
3937 if(px != null && px != "") {
3938  try {
3939   var indexOfPx = px.indexOf("px");
3940   if(indexOfPx > -1)
3941    result = parseFunction(px.substr(0, indexOfPx));
3942  } catch(e) { }
3943 }
3944 return result;
3945}
3946ASPx.PercentageToFloat = function(perc) {
3947 var result = 0;
3948 if(perc != null && perc != "") {
3949  try {
3950   var indexOfPerc = perc.indexOf("%");
3951   if(indexOfPerc > -1)
3952    result = parseFloat(perc.substr(0, indexOfPerc)) / 100;
3953  } catch(e) { }
3954 }
3955 return result;
3956};
3957ASPx.CreateGuid = function() {
3958 return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) { 
3959   var r = Math.random()*16|0,v=c=='x'?r:r&0x3|0x8;
3960  return v.toString(16);
3961 });
3962};
3963ASPx.GetLeftRightBordersAndPaddingsSummaryValue = function(element, currentStyle) {
3964 return ASPx.GetLeftRightPaddings(element, currentStyle) + ASPx.GetHorizontalBordersWidth(element, currentStyle);
3965};
3966ASPx.GetTopBottomBordersAndPaddingsSummaryValue = function(element, currentStyle) {
3967 return ASPx.GetTopBottomPaddings(element, currentStyle) + ASPx.GetVerticalBordersWidth(element, currentStyle);
3968};
3969ASPx.GetVerticalBordersWidth = function(element, style) {
3970 if(!ASPx.IsExists(style))
3971  style = ASPx.GetCurrentStyle(element);
3972 var res = 0;
3973 if(style.borderTopStyle != "none")
3974  res += ASPx.PxToFloat(style.borderTopWidth);
3975 if(style.borderBottomStyle != "none")
3976  res += ASPx.PxToFloat(style.borderBottomWidth);

3977 return res;
3978};
3979ASPx.GetHorizontalBordersWidth = function(element, style) {
3980 if(!ASPx.IsExists(style))
3981  style = ASPx.GetCurrentStyle(element);
3982 var res = 0;
3983 if(style.borderLeftStyle != "none")
3984  res += ASPx.PxToFloat(style.borderLeftWidth);
3985 if(style.borderRightStyle != "none")
3986  res += ASPx.PxToFloat(style.borderRightWidth);
3987 return res;
3988};
3989ASPx.GetTopBottomPaddings = function(element, style) {
3990 var currentStyle = style ? style : ASPx.GetCurrentStyle(element);
3991 return ASPx.PxToInt(currentStyle.paddingTop) + ASPx.PxToInt(currentStyle.paddingBottom);
3992};
3993ASPx.GetTopPaddings = function(element, style) {
3994 var currentStyle = style ? style : ASPx.GetCurrentStyle(element);
3995 return ASPx.PxToInt(currentStyle.paddingTop);
3996};
3997ASPx.GetBottomPaddings = function(element, style) {
3998 var currentStyle = style ? style : ASPx.GetCurrentStyle(element);
3999 return ASPx.PxToInt(currentStyle.paddingBottom);
4000};
4001ASPx.GetLeftRightPaddings = function(element, style) {
4002 var currentStyle = style ? style : ASPx.GetCurrentStyle(element);
4003 return ASPx.PxToInt(currentStyle.paddingLeft) + ASPx.PxToInt(currentStyle.paddingRight);
4004};
4005ASPx.GetTopBottomMargins = function(element, style) {
4006 var currentStyle = style ? style : ASPx.GetCurrentStyle(element);
4007 return ASPx.PxToInt(currentStyle.marginTop) + ASPx.PxToInt(currentStyle.marginBottom);
4008};
4009ASPx.GetLeftRightMargins = function(element, style) {
4010 var currentStyle = style ? style : ASPx.GetCurrentStyle(element);
4011 return ASPx.PxToInt(currentStyle.marginLeft) + ASPx.PxToInt(currentStyle.marginRight);
4012};
4013ASPx.GetClearClientWidth = function(element) {
4014 return ASPx.GetElementOffsetWidth(element)- ASPx.GetLeftRightBordersAndPaddingsSummaryValue(element);
4015};
4016ASPx.GetClearClientHeight = function(element) {
4017 return ASPx.GetElementOffsetHeight(element) - ASPx.GetTopBottomBordersAndPaddingsSummaryValue(element);
4018};
4019ASPx.SetOffsetWidth = function(element, widthValue, currentStyle) {
4020 if(!ASPx.IsExists(currentStyle))
4021  currentStyle = ASPx.GetCurrentStyle(element);
4022 var value = widthValue - ASPx.PxToInt(currentStyle.marginLeft) - ASPx.PxToInt(currentStyle.marginRight);
4023  value -= ASPx.GetLeftRightBordersAndPaddingsSummaryValue(element, currentStyle);
4024 if(value > -1)
4025  element.style.width = value + "px";
4026};
4027ASPx.SetOffsetHeight = function(element, heightValue, currentStyle) {
4028 if(!ASPx.IsExists(currentStyle))
4029  currentStyle = ASPx.GetCurrentStyle(element);
4030 var value = heightValue - ASPx.PxToInt(currentStyle.marginTop) - ASPx.PxToInt(currentStyle.marginBottom);
4031  value -= ASPx.GetTopBottomBordersAndPaddingsSummaryValue(element, currentStyle);
4032 if(value > -1)
4033  element.style.height = value + "px";
4034};
4035ASPx.FindOffsetParent = function(element) {
4036 var currentElement = element.parentNode;
4037 while(ASPx.IsExistsElement(currentElement) && currentElement.tagName != "BODY") {
4038  if(ASPx.GetElementOffsetWidth(currentElement) > 0 && ASPx.GetElementOffsetHeight(currentElement) > 0)
4039   return currentElement;
4040  currentElement = currentElement.parentNode;
4041 }
4042 return document.body;
4043};
4044ASPx.GetDocumentScrollTop = function(){
4045 if(Browser.WebKitFamily || Browser.Edge) {
4046  if(Browser.MacOSMobilePlatform) 
4047   return window.pageYOffset;
4048  if(Browser.WebKitFamily)
4049   return document.documentElement.scrollTop || document.body.scrollTop;
4050  return document.body.scrollTop;
4051 }
4052 else
4053  return document.documentElement.scrollTop;
4054};
4055ASPx.SetDocumentScrollTop = function(scrollTop) {
4056 if(!Browser.MacOSMobilePlatform && (Browser.Safari || (Browser.Chrome && Browser.Version < 60) || (Browser.Opera && Browser.MajorVersion >= 15) || Browser.Edge))  
4057  document.body.scrollTop = scrollTop;
4058 else
4059  document.documentElement.scrollTop = scrollTop;
4060};
4061ASPx.GetDocumentScrollLeft = function(){
4062 if(Browser.Edge)
4063  return document.body ? document.body.scrollLeft : document.documentElement.scrollLeft;
4064 if(Browser.WebKitFamily)
4065  return document.documentElement.scrollLeft || document.body.scrollLeft;
4066 return document.documentElement.scrollLeft;
4067};
4068ASPx.SetDocumentScrollLeft = function (scrollLeft) {
4069 if(!Browser.MacOSMobilePlatform && (Browser.Safari || (Browser.Chrome && Browser.Version < 60) || (Browser.Opera && Browser.MajorVersion >= 15) || Browser.Edge))  
4070  document.body.scrollLeft = scrollLeft;
4071 else

4072  document.documentElement.scrollLeft = scrollLeft;
4073};
4074ASPx.GetDocumentClientWidth = function(){
4075 if(document.documentElement.clientWidth == 0)
4076  return document.body.clientWidth;
4077 else
4078  return document.documentElement.clientWidth;
4079};
4080ASPx.GetDocumentClientHeight = function() {
4081 if(Browser.Firefox && window.innerHeight - document.documentElement.clientHeight > ASPx.GetVerticalScrollBarWidth()) {
4082  return window.innerHeight;
4083 } else if(Browser.Opera && Browser.Version < 9.6 || document.documentElement.clientHeight == 0) {
4084   return document.body.clientHeight;
4085 }
4086 return document.documentElement.clientHeight;
4087};
4088ASPx.GetDocumentWidth = function(){
4089 var bodyWidth = document.body.offsetWidth;
4090 var docWidth = document.documentElement.offsetWidth;
4091 var bodyScrollWidth = document.body.scrollWidth;
4092 var docScrollWidth = document.documentElement.scrollWidth;
4093 return getMaxDimensionOf(bodyWidth, docWidth, bodyScrollWidth, docScrollWidth);
4094};
4095ASPx.GetDocumentHeight = function(){
4096 var bodyHeight = document.body.offsetHeight;
4097 var docHeight = document.documentElement.offsetHeight;
4098 var bodyScrollHeight = document.body.scrollHeight;
4099 var docScrollHeight = document.documentElement.scrollHeight;
4100 var maxHeight = getMaxDimensionOf(bodyHeight, docHeight, bodyScrollHeight, docScrollHeight);
4101 if(Browser.Opera && Browser.Version >= 9.6){
4102  if(Browser.Version < 10)
4103   maxHeight = getMaxDimensionOf(bodyHeight, docHeight, bodyScrollHeight);
4104  var visibleHeightOfDocument = document.documentElement.clientHeight;
4105  if(maxHeight > visibleHeightOfDocument)
4106   maxHeight = getMaxDimensionOf(window.outerHeight, maxHeight);
4107  else
4108   maxHeight = document.documentElement.clientHeight;
4109  return maxHeight;
4110 }
4111 return maxHeight;
4112};
4113ASPx.GetDocumentMaxClientWidth = function(){
4114 var bodyWidth = document.body.offsetWidth;
4115 var docWidth = document.documentElement.offsetWidth;
4116 var docClientWidth = document.documentElement.clientWidth;
4117 return getMaxDimensionOf(bodyWidth, docWidth, docClientWidth);
4118};
4119ASPx.GetDocumentMaxClientHeight = function(){
4120 var bodyHeight = document.body.offsetHeight;
4121 var docHeight = document.documentElement.offsetHeight;
4122 var docClientHeight = document.documentElement.clientHeight;
4123 return getMaxDimensionOf(bodyHeight, docHeight, docClientHeight);
4124};
4125ASPx.verticalScrollIsNotHidden = null;
4126ASPx.horizontalScrollIsNotHidden = null;
4127ASPx.GetVerticalScrollIsNotHidden = function() {
4128 if(!ASPx.IsExists(ASPx.verticalScrollIsNotHidden))
4129  ASPx.verticalScrollIsNotHidden = ASPx.GetCurrentStyle(document.body).overflowY !== "hidden"
4130   && ASPx.GetCurrentStyle(document.documentElement).overflowY !== "hidden";
4131 return ASPx.verticalScrollIsNotHidden;
4132};
4133ASPx.GetHorizontalScrollIsNotHidden = function() {
4134 if(!ASPx.IsExists(ASPx.horizontalScrollIsNotHidden))
4135  ASPx.horizontalScrollIsNotHidden = ASPx.GetCurrentStyle(document.body).overflowX !== "hidden"
4136   && ASPx.GetCurrentStyle(document.documentElement).overflowX !== "hidden";
4137 return ASPx.horizontalScrollIsNotHidden;
4138};
4139ASPx.GetCurrentDocumentWidth = function() {
4140 var result = ASPx.GetDocumentClientWidth();
4141 if(!ASPx.Browser.Safari && ASPx.GetVerticalScrollIsNotHidden() && ASPx.GetDocumentHeight() > ASPx.GetDocumentClientHeight())
4142  result += ASPx.GetVerticalScrollBarWidth();
4143 return result;
4144};
4145ASPx.GetCurrentDocumentHeight = function() {
4146 var result = ASPx.GetDocumentClientHeight();
4147 if(!ASPx.Browser.Safari && ASPx.GetHorizontalScrollIsNotHidden() && ASPx.GetDocumentWidth() > ASPx.GetDocumentClientWidth())
4148  result += ASPx.GetVerticalScrollBarWidth();
4149 return result;
4150};
4151function getMaxDimensionOf(){
4152 var max = ASPx.InvalidDimension;
4153 for(var i = 0; i < arguments.length; i++){
4154  if(max < arguments[i])
4155   max = arguments[i];
4156 }
4157 return max;
4158}
4159ASPx.GetClientLeft = function(element) {
4160 return ASPx.IsExists(element.clientLeft) ? element.clientLeft : (ASPx.GetElementOffsetWidth(element)- element.clientWidth) / 2;
4161};
4162ASPx.GetClientTop = function(element) {
4163 return ASPx.IsExists(element.clientTop) ? element.clientTop : (ASPx.GetElementOffsetHeight(element) - element.clientHeight) / 2;
4164};
4165var requestAnimationFrameFunc = window.requestAnimationFrame || function(callback) { callback(); };
4166var cancelAnimationFrameFunc = window.cancelAnimationFrame || function(id) { };
4167ASPx.CancelAnimationFrame = function(id) { cancelAnimationFrameFunc(id); };
4168ASPx.RequestAnimationFrame = function (callback) { return requestAnimationFrameFunc(callback); };
4169ASPx.SetStyles = function(element, styles, makeImportant) {
4170 if(ASPx.IsExists(styles.cssText))
4171  element.style.cssText = styles.cssText;
4172 if(ASPx.IsExists(styles.className)) {
4173  ASPx.SetClassName(element, styles.className);
4174 }
4175 for(var property in styles) {
4176  if(!styles.hasOwnProperty(property))
4177   continue;
4178  var value = styles[property];
4179  switch (property) {
4180   case "cssText":
4181   case "className":
4182    break;
4183   case "float":
4184    ASPx.SetElementFloat(element, value);
4185    break;
4186   case "opacity":
4187    ASPx.SetElementOpacity(element, value);
4188    break;
4189   case "zIndex":
4190    ASPx.SetStylesCore(element, property, value, makeImportant);
4191    break;
4192   default:
4193    ASPx.SetStylesCore(element, property, value + (typeof (value) == "number" ? "px" : ""), makeImportant);
4194  }
4195 }
4196};
4197ASPx.SetStylesCore = function(element, property, value, makeImportant) {
4198 if(makeImportant) {
4199  var index = property.search("[A-Z]");
4200  if(index != -1)
4201   property = property.replace(property.charAt(index), "-" + property.charAt(index).toLowerCase());
4202  if(element.style.setProperty)
4203   element.style.setProperty(property, value, "important");
4204  else 
4205   element.style.cssText += ";" + property + ":" + value + "!important";
4206 }
4207 else
4208  element.style[property] = value;
4209};
4210ASPx.RemoveBordersAndShadows = function(el) {
4211 if(!el || !el.style)
4212  return;
4213 el.style.borderWidth = 0;
4214 if(ASPx.IsExists(el.style.boxShadow))
4215  el.style.boxShadow = "none";
4216 else if(ASPx.IsExists(el.style.MozBoxShadow))
4217  el.style.MozBoxShadow = "none";
4218 else if(ASPx.IsExists(el.style.webkitBoxShadow))
4219  el.style.webkitBoxShadow = "none";
4220};
4221ASPx.GetCellSpacing = function(element) {
4222 var val = parseInt(element.cellSpacing);
4223 if(!isNaN(val)) return val;
4224 val = parseInt(ASPx.GetCurrentStyle(element).borderSpacing);
4225 if(!isNaN(val)) return val;
4226 return 0;
4227};
4228ASPx.GetInnerScrollPositions = function(element) {
4229 var scrolls = [];
4230 getInnerScrollPositionsCore(element, scrolls);
4231 return scrolls;
4232};
4233function getInnerScrollPositionsCore(element, scrolls) {
4234 for(var child = element.firstChild; child; child = child.nextSibling) {
4235  var scrollTop = child.scrollTop,
4236   scrollLeft = child.scrollLeft;
4237  if(scrollTop > 0 || scrollLeft > 0)
4238   scrolls.push([child, scrollTop, scrollLeft]);
4239  getInnerScrollPositionsCore(child, scrolls);
4240 }
4241}
4242ASPx.RestoreInnerScrollPositions = function(scrolls) {
4243 for(var i = 0, scrollArr; scrollArr = scrolls[i]; i++) {
4244  if(scrollArr[1] > 0)
4245   scrollArr[0].scrollTop = scrollArr[1];
4246  if(scrollArr[2] > 0)
4247   scrollArr[0].scrollLeft = scrollArr[2];
4248 }
4249};
4250ASPx.GetOuterScrollPosition = function(element) {
4251 while(element && element.tagName !== "BODY") {
4252  var scrollTop = element.scrollTop,
4253   scrollLeft = element.scrollLeft;
4254  if(scrollTop > 0 || scrollLeft > 0) {
4255   return {
4256    scrollTop: scrollTop,
4257    scrollLeft: scrollLeft,
4258    element: element
4259   };
4260  }
4261  element = element.parentNode;
4262 }
4263 return {
4264  scrollTop: ASPx.GetDocumentScrollTop(),
4265  scrollLeft: ASPx.GetDocumentScrollLeft()
4266 };
4267};
4268ASPx.RestoreOuterScrollPosition = function(scrollInfo) {
4269 if(scrollInfo.element) {
4270  if(scrollInfo.scrollTop > 0)
4271   scrollInfo.element.scrollTop = scrollInfo.scrollTop;
4272  if(scrollInfo.scrollLeft > 0)
4273   scrollInfo.element.scrollLeft = scrollInfo.scrollLeft;
4274 }
4275 else {
4276  if(scrollInfo.scrollTop > 0)
4277   ASPx.SetDocumentScrollTop(scrollInfo.scrollTop);
4278  if(scrollInfo.scrollLeft > 0)
4279   ASPx.SetDocumentScrollLeft(scrollInfo.scrollLeft);
4280 }
4281};
4282ASPx.ChangeElementContainer = function(element, container, savePreviousContainer) {
4283 if(element.parentNode != container) {
4284  var parentNode = element.parentNode;
4285  parentNode.removeChild(element);

4286  container.appendChild(element);
4287  if(savePreviousContainer)
4288   element.previousContainer = parentNode;
4289 }
4290};
4291ASPx.RestoreElementContainer = function(element) {
4292 if(element.previousContainer) {
4293  ASPx.ChangeElementContainer(element, element.previousContainer, false);
4294  element.previousContainer = null;
4295 }
4296};
4297ASPx.MoveChildrenToElement = function(sourceElement, destinationElement){
4298 while(sourceElement.childNodes.length > 0)
4299  destinationElement.appendChild(sourceElement.childNodes[0]);
4300};
4301ASPx.GetScriptCode = function(script) {
4302 var useFirstChildElement = Browser.Chrome && Browser.Version < 11 || Browser.Safari && Browser.Version < 5; 
4303 var text = useFirstChildElement ? script.firstChild.data : script.text;
4304 var comment = "<!--";
4305 var pos = text.indexOf(comment);
4306 if(pos > -1)
4307  text = text.substr(pos + comment.length);
4308 return text;
4309};
4310ASPx.AppendScript = function(script) {
4311 var parent = document.getElementsByTagName("head")[0];
4312 if(!parent)
4313  parent = document.body;
4314 if(parent)
4315  parent.appendChild(script);
4316};
4317function getFrame(frames, name) {
4318 if(frames[name])
4319  return frames[name];
4320 for(var i = 0; i < frames.length; i++) {
4321  try {
4322   var frame = frames[i];
4323   if(frame.name == name) 
4324    return frame; 
4325   frame = getFrame(frame.frames, name);
4326   if(frame != null)   
4327    return frame; 
4328  } catch(e) {
4329  } 
4330 }
4331 return null;
4332}
4333ASPx.IsValidElement = function(element) {
4334 if(!element) 
4335  return false;
4336 if(!(Browser.Firefox && Browser.Version < 4)) {
4337  if(element.ownerDocument && element.ownerDocument.body && element.ownerDocument.body.compareDocumentPosition)
4338   return element.ownerDocument.body.compareDocumentPosition(element) % 2 === 0;
4339 }
4340 if(!Browser.Opera && element.offsetParent && element.parentNode.tagName)
4341  return true;
4342 while(element != null){
4343  if(element.tagName == "BODY")
4344   return true;
4345  element = element.parentNode;
4346 }
4347 return false;
4348};
4349ASPx.IsValidElements = function(elements) {
4350 if(!elements)
4351  return false; 
4352 for(var i = 0; i < elements.length; i++) {
4353  if(elements[i] && !ASPx.IsValidElement(elements[i]))
4354   return false;
4355 }
4356 return true;
4357};
4358ASPx.IsExistsElement = function(element) {
4359 return element && ASPx.IsValidElement(element);
4360};
4361ASPx.CreateHtmlElementFromString = function(str) {
4362 var dummy = ASPx.CreateHtmlElement();
4363 setInnerHtmlInternal(dummy, str);
4364 return dummy.firstChild;
4365};
4366ASPx.CreateHtmlElement = function(tagName, styles) {
4367 var element = document.createElement(tagName || "DIV");
4368 if(styles)
4369  ASPx.SetStyles(element, styles);
4370 return element;
4371};
4372ASPx.RestoreElementOriginalWidth = function(element) {
4373 if(!ASPx.IsExistsElement(element)) 
4374  return;
4375 element.style.width = element.dxOrigWidth = ASPx.GetElementOriginalWidth(element);
4376};
4377ASPx.GetElementOriginalWidth = function(element) {
4378 if(!ASPx.IsExistsElement(element)) 
4379  return null;
4380 var width;
4381 if(!ASPx.IsExists(element.dxOrigWidth)) {
4382  width = String(element.style.width).length > 0
4383   ? element.style.width
4384   : ASPx.GetElementOffsetWidth(element) + "px";
4385 } else {
4386  width = element.dxOrigWidth;
4387 }
4388 return width;
4389};
4390ASPx.DropElementOriginalWidth = function(element) {
4391 if(ASPx.IsExists(element.dxOrigWidth))
4392  element.dxOrigWidth = null;
4393};
4394ASPx.GetObjectKeys = function(obj) {
4395 if(!obj) return [ ];
4396 if(Object.keys)
4397  return Object.keys(obj);
4398 var keys = [ ];
4399 for(var key in obj) {
4400  if(obj.hasOwnProperty(key))
4401   keys.push(key);
4402 }
4403 return keys;
4404};
4405ASPx.ShowErrorAlert = function(message) {
4406 message = ASPx.Str.DecodeHtmlViaTextArea(message);
4407 if(ASPx.IsExists(message) && message !== "")
4408  alert(message);
4409};
4410ASPx.ShowKBErrorMessage = function(text, kbid) {
4411 ASPx.ShowErrorMessage(text + "https://www.devexpress.com/kbid=" + kbid + ".");
4412};
4413ASPx.ShowErrorMessage = function(errorMessage) {
4414 var console = window.console;
4415 if(!console || !ASPx.IsFunction(console.error))
4416  return;
4417 console.error(errorMessage);
4418};
4419ASPx.IsInteractiveControl = function(element, extremeParent) { 
4420 return Data.ArrayIndexOf(["A", "INPUT", "SELECT", "OPTION", "TEXTAREA", "BUTTON", "IFRAME"], element.tagName) > -1;
4421};

4422ASPx.IsUrlContainsClientScript = function(url) {
4423 return url.toLowerCase().indexOf("javascript:") !== -1;
4424};
4425ASPx.GetMSAjaxRequestManager = function() {
4426 if(window.Sys && Sys.WebForms && Sys.WebForms.PageRequestManager && Sys.WebForms.PageRequestManager.getInstance)
4427  return Sys.WebForms.PageRequestManager.getInstance();
4428 return null;
4429};
4430Function.prototype.aspxBind = function(scope) {
4431 var func = this;
4432 return function() {
4433  return func.apply(scope, arguments);
4434 };
4435};
4436var FilteringUtils = { };
4437FilteringUtils.EventKeyCodeChangesTheInput = function(evt) {
4438 if(ASPx.IsPasteShortcut(evt))
4439  return true;
4440 else if(evt.ctrlKey && !evt.altKey)
4441  return false;
4442 if(ASPx.Browser.AndroidMobilePlatform || ASPx.Browser.MacOSMobilePlatform) return true; 
4443 var keyCode = ASPx.Evt.GetKeyCode(evt);
4444 var isSystemKey = ASPx.Key.Windows <= keyCode && keyCode <= ASPx.Key.ContextMenu;
4445 var isFKey = ASPx.Key.F1 <= keyCode && keyCode <= 127; 
4446 return ASPx.Key.Delete <= keyCode && !isSystemKey && !isFKey || keyCode == ASPx.Key.Backspace || keyCode == ASPx.Key.Space;
4447};
4448FilteringUtils.FormatCallbackArg = function(prefix, arg) {
4449 return (ASPx.IsExists(arg) ? prefix + "|" + arg.length + ';' + arg + ';' : "");
4450};
4451ASPx.FilteringUtils = FilteringUtils;
4452var FormatStringHelper = { };
4453FormatStringHelper.PlaceHolderTemplateStruct = function(startIndex, length, index, placeHolderString){
4454 this.startIndex = startIndex;
4455 this.realStartIndex = 0;
4456 this.length = length;
4457 this.realLength = 0;
4458 this.index = index;
4459 this.placeHolderString = placeHolderString;
4460};
4461FormatStringHelper.GetPlaceHolderTemplates = function(formatString){
4462 formatString = this.CollapseDoubleBrackets(formatString);
4463 var templates = this.CreatePlaceHolderTemplates(formatString);
4464 return templates;
4465};
4466FormatStringHelper.CreatePlaceHolderTemplates = function(formatString){
4467 var templates = [];
4468 var templateStrings = formatString.match(/{[^}]+}/g);
4469 if(templateStrings != null){
4470  var pos = 0;
4471  for(var i = 0; i < templateStrings.length; i++){
4472   var tempString = templateStrings[i];
4473   var startIndex = formatString.indexOf(tempString, pos);
4474   var length = tempString.length;
4475   var indexString = tempString.slice(1).match(/^[0-9]+/);
4476   var index = parseInt(indexString);
4477   templates.push(new this.PlaceHolderTemplateStruct(startIndex, length, index, tempString));
4478   pos = startIndex + length;
4479  }
4480 }
4481 return templates;
4482};
4483FormatStringHelper.CollapseDoubleBrackets = function(formatString){
4484 formatString = this.CollapseOpenDoubleBrackets(formatString);
4485 formatString = this.CollapseCloseDoubleBrackets(formatString);
4486 return formatString;
4487};
4488FormatStringHelper.CollapseOpenDoubleBrackets = function(formatString){
4489 return formatString.replace(/{{/g, "_");
4490};

4491FormatStringHelper.CollapseCloseDoubleBrackets = function(formatString){
4492 while(true){
4493  var index = formatString.lastIndexOf("}}");
4494  if(index == -1) 
4495   break;
4496  else
4497   formatString = formatString.substr(0, index) + "_" + formatString.substr(index + 2);
4498 }
4499 return formatString;
4500};
4501ASPx.FormatStringHelper = FormatStringHelper;
4502var StartWithFilteringUtils = { };
4503StartWithFilteringUtils.HighlightSuggestedText = function(input, suggestedText, control, onChangeInput){
4504 if(this.NeedToLockAndoidKeyEvents(control))
4505  control.LockAndroidKeyEvents();
4506 var selInfo = ASPx.Selection.GetInfo(input);
4507 var currentTextLenght = ASPx.Str.GetCoincideCharCount(suggestedText, input.value, 
4508  function(text, filter) { 
4509   return text.indexOf(filter) == 0;
4510  });
4511 var suggestedTextLenght = suggestedText.length;
4512 var isSelected = selInfo.startPos == 0 && selInfo.endPos == currentTextLenght && 
4513  selInfo.endPos == suggestedTextLenght && input.value == suggestedText;
4514 if(!isSelected) { 
4515  input.value = suggestedText;
4516  if(onChangeInput)
4517   onChangeInput();
4518  if(this.NeedToLockAndoidKeyEvents(control)) {
4519   window.setTimeout(function() {
4520    this.SelectText(input, currentTextLenght, suggestedTextLenght);
4521    control.UnlockAndroidKeyEvents();
4522   }.aspxBind(this), control.adroidSamsungBugTimeout);
4523  } else
4524   this.SelectText(input, currentTextLenght, suggestedTextLenght);
4525 }
4526};
4527StartWithFilteringUtils.SelectText = function(input, startPos, stopPos) {
4528 if(startPos < stopPos)
4529  ASPx.Selection.Set(input, startPos, stopPos);
4530};
4531StartWithFilteringUtils.RollbackOneSuggestedChar = function(input){
4532 var currentText = input.value;
4533 var cutText = currentText.slice(0, -1);
4534 if(cutText != currentText)
4535  input.value = cutText;
4536};
4537StartWithFilteringUtils.NeedToLockAndoidKeyEvents = function(control) {
4538 return ASPx.Browser.AndroidMobilePlatform && control && control.LockAndroidKeyEvents;
4539};
4540ASPx.StartWithFilteringUtils = StartWithFilteringUtils;
4541var ContainsFilteringUtils = { };
4542ContainsFilteringUtils.ColumnSelectionStruct = function(index, startIndex, length){
4543 this.index = index;
4544 this.length = length;
4545 this.startIndex = startIndex;
4546};
4547ContainsFilteringUtils.IsFilterCrossPlaseHolder = function(filterStartIndex, filterEndIndex, template) {
4548 var left = Math.max(filterStartIndex, template.realStartIndex);
4549 var right = Math.min(filterEndIndex,  template.realStartIndex + template.realLength);
4550 return left < right;
4551};
4552ContainsFilteringUtils.GetColumnSelectionsForItem = function(itemValues, formatString, filterString) {
4553 if(formatString == "") 
4554  return this.GetSelectionForSingleColumnItem(itemValues, filterString); 
4555 var result = [];
4556 var formatedString = ASPx.Formatter.Format(formatString, itemValues);
4557 var filterStartIndex = ASPx.Str.PrepareStringForFilter(formatedString).indexOf(ASPx.Str.PrepareStringForFilter(filterString));
4558 if(filterStartIndex == -1) return result;
4559 var filterEndIndex = filterStartIndex + filterString.length;
4560 var templates = FormatStringHelper.GetPlaceHolderTemplates(formatString);
4561 this.SupplyTemplatesWithRealValues(itemValues, templates);
4562 for(var i = 0; i < templates.length ; i++) {
4563  if(this.IsFilterCrossPlaseHolder(filterStartIndex, filterEndIndex, templates[i])) 
4564   result.push(this.GetColumnSelectionsForItemValue(templates[i], filterStartIndex, filterEndIndex));
4565 }
4566 return result;
4567};
4568ContainsFilteringUtils.GetColumnSelectionsForItemValue = function(template, filterStartIndex, filterEndIndex) {
4569 var selectedTextStartIndex = filterStartIndex < template.realStartIndex ? 0 :
4570  filterStartIndex - template.realStartIndex;
4571 var selectedTextEndIndex = filterEndIndex >  template.realStartIndex + template.realLength ? template.realLength :
4572  filterEndIndex - template.realStartIndex;
4573 var selectedTextLength = selectedTextEndIndex - selectedTextStartIndex;
4574 return new this.ColumnSelectionStruct(template.index, selectedTextStartIndex, selectedTextLength);
4575};
4576ContainsFilteringUtils.GetSelectionForSingleColumnItem = function(itemValues, filterString) {
4577 var selectedTextStartIndex = ASPx.Str.PrepareStringForFilter(itemValues[0]).indexOf(ASPx.Str.PrepareStringForFilter(filterString));
4578 var selectedTextLength = filterString.length;
4579 return [new this.ColumnSelectionStruct(0, selectedTextStartIndex, selectedTextLength)];

4580};
4581ContainsFilteringUtils.ResetFormatStringIndex = function(formatString, index) {
4582 if(index != 0)
4583  return formatString.replace(index.toString(), "0");
4584 return formatString;
4585};
4586ContainsFilteringUtils.SupplyTemplatesWithRealValues = function(itemValues, templates) {
4587 var shift = 0;
4588 for(var i = 0; i < templates.length; i++) {
4589  var formatString = this.ResetFormatStringIndex(templates[i].placeHolderString, templates[i].index);
4590  var currentItemValue = itemValues[templates[i].index];
4591  templates[i].realLength = ASPx.Formatter.Format(formatString, currentItemValue).length;
4592  templates[i].realStartIndex  += templates[i].startIndex + shift; 
4593  shift += templates[i].realLength - templates[i].placeHolderString.length; 
4594 }
4595};
4596ContainsFilteringUtils.PrepareElementText = function(itemText) {
4597 return itemText ? itemText.replace(/\&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;") : '';
4598};
4599ContainsFilteringUtils.UnselectContainsTextInElement = function(element, selection, highlightTagName) {
4600 var currentText =  ASPx.Attr.GetAttribute (element, "DXText");
4601 if(ASPx.IsExists(currentText)) {
4602  currentText = ContainsFilteringUtils.PrepareElementText(currentText);
4603  ASPx.Security.setInnerHtml(element, currentText === "" ? "&nbsp;" : currentText, ASPx.Security.DataType.Trusted);
4604 }
4605};
4606ContainsFilteringUtils.ReselectContainsTextInElement = function(element, selection, highlightTagName) {
4607 var currentText = ASPx.GetInnerText(element);
4608 if(!highlightTagName)
4609  highlightTagName = "em";
4610 highlightTagName = highlightTagName.toLowerCase();
4611 if(currentText.indexOf("</" + highlightTagName + ">") != -1)
4612  ContainsFilteringUtils.UnselectContainsTextInElement(element, selection, highlightTagName);
4613 return ContainsFilteringUtils.SelectContainsTextInElement(element, selection, highlightTagName);
4614};
4615ContainsFilteringUtils.SelectContainsTextInElement = function(element, selection, highlightTagName) {
4616 if(selection.startIndex == -1)
4617  return;
4618 var currentText =  ASPx.Attr.GetAttribute (element, "DXText");
4619 if(!ASPx.IsExists(currentText)) ASPx.Attr.SetAttribute (element, "DXText", ASPx.GetInnerText(element));
4620 if(!highlightTagName)
4621  highlightTagName = "em";
4622 highlightTagName = highlightTagName.toLowerCase();
4623 var oldInnerText = ASPx.GetInnerText(element);
4624 var newInnerText = ContainsFilteringUtils.PrepareElementText(oldInnerText.substr(0, selection.startIndex)) + "<" + highlightTagName + ">" +
4625      ContainsFilteringUtils.PrepareElementText(oldInnerText.substr(selection.startIndex, selection.length)) + "</" + highlightTagName + ">" +
4626      ContainsFilteringUtils.PrepareElementText(oldInnerText.substr(selection.startIndex + selection.length));
4627 ASPx.Security.setInnerHtml(element, newInnerText, ASPx.Security.DataType.Trusted);
4628};
4629ASPx.ContainsFilteringUtils = ContainsFilteringUtils;
4630ASPx.MakeEqualControlsWidth = function(name1, name2){
4631 var control1 = ASPx.GetControlCollection().Get(name1);
4632 var control2 = ASPx.GetControlCollection().Get(name2);
4633 if(control1 && control2){
4634  var width = Math.max(control1.GetWidth(), control2.GetWidth());
4635  control1.SetWidth(width);
4636  control2.SetWidth(width);
4637 }
4638};
4639ASPx.HighContrastForeColorHighlightColorMap = {
4640 "#ffff00" : "#008000",
4641 "#00ff00" : "#0000ff",
4642 "#ffffff" : "#00838f",
4643 "#000000" : "#a347ff"
4644};
4645var BadgeManagerBase = ASPx.CreateClass(null, {
4646 createBadge: function(text, iconCssClass) {
4647  var badge = document.createElement("SPAN");
4648  ASPx.SetClassName(badge, this.getBadgeClassName());
4649  if(iconCssClass && iconCssClass.length)
4650   this.setBadgeIconCssClass(badge, iconCssClass);
4651  if(text && text.length)
4652   this.setBadgeText(badge, text);
4653  return badge;
4654 },
4655 findBadge: function(element) {
4656  if(!element)
4657   return null;
4658  return element.querySelector("." + this.getBadgeClassName());
4659 },
4660 setBadgeIconCssClass: function(badge, iconCssClass) {
4661  if(!badge || iconCssClass === undefined)
4662   return;
4663  var iconElement = this.getBadgeIconElement(badge);
4664  if(!iconCssClass) {
4665   if(iconElement)
4666    badge.removeChild(iconElement);
4667  }
4668  else {
4669   if(!iconElement) {
4670    iconElement = document.createElement("SPAN");
4671    badge.insertBefore(iconElement, badge.childNodes[0]);
4672   }
4673   ASPx.SetClassName(iconElement, iconCssClass + " " + this.getBadgeIconDefaultClassName());
4674  }
4675 },
4676 getBadgeIconCssClass: function(element) {
4677  var badge = this.findBadge(element);
4678  if(badge) {
4679   var iconElement = this.getBadgeIconElement(badge);
4680   var regEx = new RegExp("(?:^|\\s)" + this.getBadgeIconDefaultClassName() + "(?!\\S)");
4681   return iconElement ? ASPx.Str.Trim(ASPx.GetClassName(iconElement).replace(regEx, "")) : "";
4682  }
4683  return "";
4684 },
4685 setBadgeText: function(badge, text) {
4686  if(!badge || text === undefined)
4687   return;
4688  var textElement = this.getBadgeTextElement(badge);
4689  if(!text) {
4690   if(textElement)
4691    badge.removeChild(textElement);
4692  }
4693  else {
4694   if(!textElement) {
4695    textElement = document.createElement("SPAN");
4696    badge.appendChild(textElement);
4697   }
4698   ASPx.Security.setInnerHtml(textElement, text, ASPx.Security.DataType.Trusted);
4699  }
4700 },
4701 getBadgeText: function(element) {
4702  var badge = this.findBadge(element);
4703  if(badge) {
4704   var textElement = this.getBadgeTextElement(badge);
4705   return textElement ? ASPx.GetInnerText(textElement) : "";
4706  }
4707  return "";
4708 },
4709 getBadgeClassName: function() {
4710  return "";
4711 },
4712 getBadgeIconDefaultClassName: function() {
4713  return "";
4714 },
4715 getBadgeIconElement: function(badge) {
4716  return badge.childNodes.length ? badge.querySelector("." + this.getBadgeIconDefaultClassName()) : null;
4717 },
4718 getBadgeTextElement: function(badge) {
4719  return badge.childNodes.length ? badge.querySelector("span:not(." + this.getBadgeIconDefaultClassName() + ")") : null;
4720 }
4721});
4722ASPx.BadgeManagerBase = BadgeManagerBase;
4723var BadgeManager = ASPx.CreateClass(BadgeManagerBase, {
4724 getBadgeClassName: function() {
4725  return "dxBadge";
4726 },
4727 getBadgeIconDefaultClassName: function() {
4728  return "dxBadgeImage";
4729 },
4730 createBadgeForButton: function(button) {
4731  var badge = ASPx.BadgeManager.createBadge();
4732  var buttonImage = button.GetButtonImage();
4733  var textContainer = button.GetTextContainer();
4734  var badgeRightSibling = !!buttonImage ? buttonImage : textContainer;
4735  badgeRightSibling.parentNode.insertBefore(badge, badgeRightSibling);
4736  if(button.IsLink() && buttonImage)
4737   ASPx.SetStyles(badge, { verticalAlign: "middle" });
4738  return badge;
4739 },
4740 createBadgeForToolbar: function(toolbarItem) {
4741  var badge = ASPx.BadgeManager.createBadge();
4742  var itemImage = toolbarItem.GetImage();
4743  var badgeRightSibling = itemImage;
4744  if(!itemImage) {
4745   var itemContentElement = toolbarItem.menu.GetItemContentElement(toolbarItem.indexPath);
4746   badgeRightSibling = toolbarItem.menu.GetContentTextElement(itemContentElement);
4747  }
4748  badgeRightSibling.parentNode.insertBefore(badge, badgeRightSibling);
4749  return badge;
4750 }
4751});
4752ASPx.BadgeManager = new BadgeManager();
4753var AccessibilityUtils = {
4754 isInitialized: false,
4755 highContrastCssClassMarker: "dxHighContrast",

4756 highContrastBackgroundCssClassMarker: "dxHCB",
4757 highContrastDefaultBackgroundColor: "#a347ff",
4758 highContrastThemeActive: false,
4759 accessibleBackgroundCssMarker: ".dx-runtime-background",
4760 createAccessibleBackgrounds: function(control) {
4761  if(!this.highContrastThemeActive || control.accessibleBackgroundsCreated || !control.accessibilityCompliant)
4762   return;
4763  var className = this.accessibleBackgroundCssMarker;
4764  var styleSheetRuleNames = [];
4765  iterateStyleSheetRules(null, function(rule) {
4766   var selectorTxt = rule.selectorText;
4767   if(selectorTxt && selectorTxt.indexOf(className) > -1)
4768    styleSheetRuleNames.push(ASPx.Str.CompleteReplace(selectorTxt, className, "")); 
4769  });
4770  for(var i = 0; i < styleSheetRuleNames.length; i++) {
4771   var name = styleSheetRuleNames[i];
4772   var rule = ASPx.GetStyleSheetRules(name.substring(1));
4773   if(rule && rule.style && rule.style.backgroundImage)
4774    this.createAccessibleBackground(control.GetMainElement(), rule.style, name);
4775  }
4776  control.accessibleBackgroundsCreated = true;
4777 },
4778 createAccessibleBackground: function(container, style, selector) {
4779  if(!container)
4780   return;
4781  var backgroundUrl = style.backgroundImage.substring(5, style.backgroundImage.length - 2);
4782  var elements = container.querySelectorAll(selector);
4783  var accessibleBackgroundClassName = "dx-acc-bi";
4784  for(var i = 0; i < elements.length; i++) {
4785   var element = elements[i];
4786   if(ASPx.ElementHasCssClass(element, accessibleBackgroundClassName))
4787    continue;
4788   var image = null;
4789   if(element.tagName !== "IMG") {
4790    ASPx.AddClassNameToElement(element, accessibleBackgroundClassName);
4791    image = element.ownerDocument.createElement("IMG");
4792    ASPx.SetStyles(image, { width: "100%", height: "100%" });
4793    if(element.firstChild)
4794     element.insertBefore(image, element.firstChild);
4795    else
4796     element.appendChild(image);
4797   } else
4798    image = element;
4799   image.src = backgroundUrl;
4800  }
4801 },

4802 createHighContrastBackgroundStyle: function() {
4803  var style = document.createElement('style');
4804  ASPx.Attr.AppendStyleType(style);
4805  var styleContent = [
4806   "." + this.highContrastCssClassMarker + " ." + this.highContrastBackgroundCssClassMarker + ":after {",
4807   "border-image: url(" + this.getHighContrastBackgroundUrl() + ") 0 1 0 0 round;",
4808   "}",
4809  ];
4810  setInnerHtmlInternal(style, styleContent.join('\n'));
4811  document.getElementsByTagName('head')[0].appendChild(style);
4812 },
4813 getHighContrastBackgroundUrl: function() {
4814  var canvas = document.createElement("canvas"),
4815  ctx = canvas.getContext('2d');
4816  canvas.width = 1;
4817  canvas.height = 1;
4818  ctx.fillStyle = this.getHighContrastBackgroundColor();
4819  ctx.fillRect(0, 0, canvas.width, canvas.height);
4820  return canvas.toDataURL();
4821 },
4822 getHighContrastBackgroundColor: function() {
4823  var foreColor = ASPx.GetCurrentStyle(document.body).color;
4824  var hexColor = ASPx.Color.ColorToHexadecimal(foreColor);
4825  return ASPx.HighContrastForeColorHighlightColorMap[hexColor] || this.highContrastDefaultBackgroundColor;
4826 },
4827 initialize: function() {
4828  if(this.isInitialized)
4829   return;
4830  this.isInitialized = true;
4831  this.detectHighContrastTheme();
4832  if(this.highContrastThemeActive)

4833   this.createHighContrastBackgroundStyle();
4834 },
4835 detectHighContrastTheme: function() {
4836  var testElement = document.createElement("DIV");
4837  ASPx.SetStyles(testElement, {
4838   backgroundColor: "rgb(255, 255, 255)",
4839   display: "none"
4840  }, true);
4841  var docElement = document.documentElement;
4842  docElement.appendChild(testElement);
4843  var actualBackgroundColor = ASPx.GetCurrentStyle(testElement).backgroundColor;
4844  docElement.removeChild(testElement);
4845  if(actualBackgroundColor === "rgb(0, 0, 0)") {
4846   this.highContrastThemeActive = true;
4847   ASPx.AddClassNameToElement(docElement, this.highContrastCssClassMarker);
4848  }
4849 }
4850};
4851ASPx.AccessibilityUtils = AccessibilityUtils;
4852ASPx.AccessibilityUtils.SendMessageToAssistiveTechnology = function(message) {
4853 var messageParts = ASPx.Ident.IsArray(message) ? message : [message];
4854 var args = new ASPxClientControlBeforePronounceEventArgs(messageParts, null);
4855 ASPx.AccessibilityPronouncer.EnsureInitialize();
4856 ASPx.AccessibilityPronouncer.Pronounce(args, ASPx.AccessibilityPronouncerType.live);
4857};
4858ASPx.AccessibilityUtils.SetFocusAccessible = function(focusableElement) {
4859 if(!focusableElement)
4860  return;
4861 var elementId = focusableElement.id;
4862 if(!elementId) {
4863  var namedParent = ASPx.GetParent(focusableElement, function(element) {
4864   return !!element.id;
4865  });
4866  if(ASPx.IsExists(namedParent))
4867   elementId = namedParent.id;
4868 }
4869 var focusableControl = ASPx.GetClientControlByElementID(elementId);
4870 if(focusableControl && focusableControl.OnAssociatedLabelClick)
4871  focusableControl.OnAssociatedLabelClick(focusableElement);
4872 else
4873  window.setTimeout(function() {
4874   ASPx.AccessibilityUtils.SetFocusAccessibleCore(focusableElement);
4875  }, 0);
4876};
4877ASPx.AccessibilityUtils.SetFocusAccessibleCore = function(focusableElement) {
4878 if(!ASPx.IsExists(focusableElement))
4879  return;
4880 var isTabIndexChanged = ASPx.ControlTabIndexManager.getInstance().isElementWithChangedIndex(focusableElement);
4881 if(isTabIndexChanged)
4882  return;
4883 if(!ASPx.IsValidElement(focusableElement) && focusableElement.id)
4884  focusableElement = ASPx.GetElementById(focusableElement.id);
4885 if(!ASPx.IsActionElement(focusableElement))
4886  focusableElement = ASPx.RestoreFocusHelper.findNeighbourFocusElement(focusableElement, document.body);
4887 if(ASPx.IsExistsElement(focusableElement))
4888  focusableElement.focus();
4889};
4890var Security = {
4891 setInnerHtml: function(el, html, dataType) {
4892  if(!html) {
4893   while(el.firstChild)
4894    ASPx.RemoveElement(el.firstChild);
4895  } else
4896   Security.setData(html, function(d) { ASPx.SetInnerHtml.call(window, el, d); }, dataType);
4897 },
4898 setText: function(control, text, dataType) { Security.setData(text, control.SetText.aspxBind(control), dataType); },
4899 safeEncodeHtml: function(html) { return ASPx.Str.EncodeHtml(ASPx.Str.DecodeHtml(html)); },
4900 setData: function(data, dataSetter, dataType) {
4901  if(dataType === undefined)
4902   throw new Error("Specify the dataType");
4903  if(dataType == Security.DataType.Untrusted)
4904   data = Security.safeEncodeHtml(data);
4905  dataSetter(data);
4906 }
4907};
4908Security.DataType = {
4909 Trusted: 0,
4910 Untrusted: 1
4911};
4912ASPx.EnableCssAnimation = true;
4913var AnimationTransitionBase = ASPx.CreateClass(null, {
4914 constructor: function(element, options) {
4915  if(element) {
4916   AnimationTransitionBase.Cancel(element);
4917   this.element = element;
4918   this.element.aspxTransition = this;
4919  }
4920  this.duration = options.duration || AnimationConstants.Durations.DEFAULT;
4921  this.transition = options.transition || AnimationConstants.Transitions.SINE;
4922  this.property = options.property;
4923  this.unit = options.unit || "";
4924  this.onComplete = options.onComplete;
4925  this.to = null;
4926  this.from = null;
4927 },
4928 Start: function(from, to) {
4929  if(to != undefined) {
4930   this.to = to;
4931   this.from = from;
4932   this.SetValue(this.from);
4933  }
4934  else
4935   this.to = from;
4936 },
4937 Cancel: function() {
4938  if(!this.element)
4939   return;
4940  try {
4941   delete this.element.aspxTransition;
4942  } catch(e) {
4943   this.element.aspxTransition = undefined;
4944  }
4945 },
4946 GetValue: function() {
4947  return this.getValueInternal(this.element, this.property);
4948 },
4949 SetValue: function(value) {
4950  this.setValueInternal(this.element, this.property, this.unit, value);
4951 },
4952 setValueInternal: function(element, property, unit, value) {
4953  if(property == "opacity")
4954   AnimationUtils.setOpacity(element, value);
4955  else
4956   element.style[property] = value + unit;
4957 },
4958 getValueInternal: function(element, property) {
4959  if(property == "opacity")
4960   return ASPx.GetElementOpacity(element);
4961  var value = parseFloat(element.style[property]);
4962  return isNaN(value) ? 0 : value;
4963 },
4964 performOnComplete: function() {
4965  if(this.onComplete)
4966   this.onComplete(this.element);
4967 },
4968 getTransition: function() {
4969  return this.transition;
4970 }
4971});
4972AnimationTransitionBase.Cancel = function(element) {
4973 if(element.aspxTransition)
4974  element.aspxTransition.Cancel();
4975};
4976var AnimationConstants = {};
4977AnimationConstants.Durations = {
4978 SHORT: 200,
4979 DEFAULT: 400,
4980 LONG: 600
4981};
4982AnimationConstants.Transitions = {
4983 LINER: {
4984  Css: "cubic-bezier(0.250, 0.250, 0.750, 0.750)",
4985  Js: function(progress) { return progress; }
4986 },
4987 SINE: {
4988  Css: "cubic-bezier(0.470, 0.000, 0.745, 0.715)",
4989  Js: function(progress) { return Math.sin(progress * 1.57); }
4990 },
4991 POW: {
4992  Css: "cubic-bezier(0.755, 0.050, 0.855, 0.060)",
4993  Js: function(progress) { return Math.pow(progress, 4); }
4994 },
4995 POW_EASE_OUT: {
4996  Css: "cubic-bezier(0.165, 0.840, 0.440, 1.000)",
4997  Js: function(progress) { return 1 - AnimationConstants.Transitions.POW.Js(1 - progress); }
4998 },
4999 RIPPLE: {
5000  Css: "cubic-bezier(0.47, 0.06, 0.23, 0.99)",
5001  Js: function(progress) {
5002   return Math.pow((progress), 3) * 0.47 + 3 * progress * Math.pow((1 - progress), 2) * 0.06 + 3 * Math.pow(progress, 2) *
5003    (1 - progress) * 0.23 + 0.99 * Math.pow(progress, 3);
5004  }
5005 }
5006};
5007var JsAnimationTransition = ASPx.CreateClass(AnimationTransitionBase, {
5008 constructor: function(element, options) {
5009  this.constructor.prototype.constructor.call(this, element, options);
5010  this.onStep = options.onStep;
5011  this.fps = 60;
5012  this.startTime = null;
5013 },
5014 Start: function(from, to) {
5015  if(from == to) {
5016   this.from = this.to = from;
5017   setTimeout(this.complete.aspxBind(this), 0);
5018  }
5019  else {
5020   AnimationTransitionBase.prototype.Start.call(this, from, to);
5021   if(to == undefined)
5022    this.from = this.GetValue();
5023   this.initTimer();
5024  }
5025 },
5026 Cancel: function() {
5027  AnimationTransitionBase.prototype.Cancel.call(this);
5028  if(this.timerId)
5029   clearInterval(this.timerId);
5030 },
5031 initTimer: function() {
5032  this.startTime = new Date();
5033  this.timerId = window.setInterval(function() { this.onTick(); }.aspxBind(this), 1000 / this.fps);

5034 },
5035 onTick: function() {
5036  var progress = (new Date() - this.startTime) / this.duration;
5037  if(progress >= 1)
5038   this.complete();
5039  else {
5040   this.update(progress);
5041   if(this.onStep)
5042    this.onStep();
5043  }
5044 },
5045 update: function(progress) {
5046  this.SetValue(this.gatCalculatedValue(this.from, this.to, progress));
5047 },
5048 complete: function() {
5049  this.Cancel();
5050  this.update(1);
5051  this.performOnComplete();
5052 },
5053 gatCalculatedValue: function(from, to, progress) {
5054  if(progress == 1)
5055   return to;
5056  return from + (to - from) * this.getTransition()(progress);
5057 },
5058 getTransition: function() {
5059  return this.transition.Js;
5060 }
5061});
5062var SimpleAnimationTransition = ASPx.CreateClass(JsAnimationTransition, {
5063 constructor: function(options) {
5064  this.constructor.prototype.constructor.call(this, null, options);
5065  this.transition = options.transition || AnimationConstants.Transitions.POW_EASE_OUT;
5066  this.onUpdate = options.onUpdate;
5067  this.lastValue = 0;
5068 },
5069 SetValue: function(value) {
5070  this.onUpdate(value - this.lastValue);
5071  this.lastValue = value;
5072 },
5073 GetValue: function() {
5074  return this.lastValue;
5075 },
5076 performOnComplete: function() {
5077  if(this.onComplete)
5078   this.onComplete();
5079 }
5080});
5081var MultipleJsAnimationTransition = ASPx.CreateClass(JsAnimationTransition, {
5082 constructor: function(element, options) {
5083  this.constructor.prototype.constructor.call(this, element, options);
5084  this.properties = {};
5085 },
5086 Start: function(properties) {
5087  this.initProperties(properties);
5088  this.initTimer();
5089 },
5090 initProperties: function(properties) {
5091  this.properties = properties;
5092  for(var propName in this.properties)
5093   if(properties[propName].from == undefined)
5094    properties[propName].from = this.getValueInternal(this.element, propName);
5095 },
5096 update: function(progress) {
5097  for(var propName in this.properties) {
5098   if(this.properties.hasOwnProperty(propName)) {
5099    var property = this.properties[propName];
5100    if(property.from != property.to)
5101     this.setValueInternal(this.element, propName, property.unit, this.gatCalculatedValue(property.from, property.to, progress));
5102   }
5103  }
5104 }
5105});
5106var CssAnimationTransition = ASPx.CreateClass(AnimationTransitionBase, {
5107 constructor: function(element, options) {
5108  this.constructor.prototype.constructor.call(this, element, options);
5109  this.transitionPropertyName = AnimationUtils.CurrentTransition.property;
5110  this.eventName = AnimationUtils.CurrentTransition.event;
5111  this.forceTransitionEndByTimer = true;
5112  this.needForceTransitionEndByTimerFlag = options.needForceTransitionEndByTimerFlag;
5113 },
5114 Start: function(from, to) {
5115  this.forceTransitionEndByTimer = true;
5116  AnimationTransitionBase.prototype.Start.call(this, from, to);
5117  this.startTimerId = window.setTimeout(function() {
5118   if(this.from == this.to)
5119    this.onTransitionEnd();
5120   else {
5121    var isHidden = ASPx.GetElementOffsetHeight(this.element) == 0 && ASPx.GetElementOffsetWidth(this.element) == 0; 
5122    if(!isHidden)
5123     this.prepareElementBeforeAnimation();
5124    this.SetValue(this.to);
5125    if(isHidden)
5126     this.onTransitionEnd();
5127   }
5128  }.aspxBind(this), 0);
5129 },
5130 Cancel: function() {
5131  this.forceTransitionEndByTimer = false;
5132  window.clearTimeout(this.startTimerId);
5133  AnimationTransitionBase.prototype.Cancel.call(this);
5134  ASPx.Evt.DetachEventFromElement(this.element, this.eventName, CssAnimationTransition.transitionEnd);
5135  this.setValueInternal(this.element, this.transitionPropertyName, "", "");
5136  this.stopAnimation();
5137 },
5138 prepareElementBeforeAnimation: function() {
5139  ASPx.Evt.AttachEventToElement(this.element, this.eventName, CssAnimationTransition.transitionEnd);
5140  var dummy = this.element.offsetHeight;
5141  this.element.style[this.transitionPropertyName] = this.getTransitionCssString();
5142  if(this.needForceTransitionEndByTimer()) {
5143   setTimeout(function() {
5144    if(this.forceTransitionEndByTimer && this.element && this.element.aspxTransition) {
5145     this.element.style[this.transitionPropertyName] = "";
5146     this.element.aspxTransition.onTransitionEnd();
5147    }
5148   }.aspxBind(this), this.duration + 100);
5149  }
5150 },
5151 needForceTransitionEndByTimer: function() {
5152  if(this.needForceTransitionEndByTimerFlag)
5153   return true;
5154  if(ASPx.Browser.Safari && ASPx.Browser.MacOSMobilePlatform && ASPx.Browser.MajorVersion >= 8) 
5155   return true;
5156  return ASPx.Browser.AndroidMobilePlatform; 
5157 },
5158 stopAnimation: function() {
5159  this.SetValue(ASPx.GetCurrentStyle(this.element)[this.property]);
5160 },
5161 onTransitionEnd: function() {
5162  this.Cancel();
5163  this.performOnComplete();
5164 },
5165 getTransition: function() {
5166  return this.transition.Css;
5167 },
5168 getTransitionCssString: function() {
5169  return this.getTransitionCssStringInternal(this.getCssName(this.property));
5170 },
5171 getTransitionCssStringInternal: function(cssProperty) {
5172  return cssProperty + " " + this.duration + "ms " + this.getTransition();
5173 },
5174 getCssName: function(property) {
5175  switch(property) {
5176   case "marginLeft":
5177    return "margin-left";
5178   case "marginTop":
5179    return "margin-top";
5180  }
5181  return property;
5182 }
5183});
5184var MultipleCssAnimationTransition = ASPx.CreateClass(CssAnimationTransition, {
5185 constructor: function(element, options) {
5186  this.constructor.prototype.constructor.call(this, element, options);
5187  this.properties = null;
5188 },
5189 Start: function(properties) {
5190  this.properties = properties;
5191  this.forEachProperties(function(property, propName) {
5192   if(property.from !== undefined)
5193    this.setValueInternal(this.element, propName, property.unit, property.from);
5194  }.aspxBind(this));
5195  this.prepareElementBeforeAnimation();
5196  window.setTimeout(function() {
5197   this.forEachProperties(function(property, propName) {
5198    this.setValueInternal(this.element, propName, property.unit, property.to);

5199   }.aspxBind(this));
5200  }.aspxBind(this), 0);
5201 },
5202 stopAnimation: function() {
5203  var style = ASPx.GetCurrentStyle(this.element);
5204  this.forEachProperties(function(property, propName) {
5205   this.setValueInternal(this.element, propName, "", style[propName]);
5206  }.aspxBind(this));
5207 },
5208 getTransitionCssString: function() {
5209  var str = "";
5210  this.forEachProperties(function(property, propName) {
5211   str += this.getTransitionCssStringInternal(this.getCssName(propName)) + ",";
5212  }.aspxBind(this));
5213  str = str.substring(0, str.length - 1);
5214  return str;
5215 },
5216 forEachProperties: function(func) {
5217  for(var propName in this.properties) {
5218   if(this.properties.hasOwnProperty(propName)) {
5219    var property = this.properties[propName];
5220    if(property.from == undefined)
5221     property.from = this.getValueInternal(this.element, propName);
5222    if(property.from != property.to)
5223     func(property, propName);
5224   }
5225  }
5226 }
5227});
5228CssAnimationTransition.transitionEnd = function(evt) {
5229 var element = evt.target;
5230 if(element && element.aspxTransition)
5231  element.aspxTransition.onTransitionEnd();
5232};
5233var AnimationUtils = {
5234 CanUseCssTransition: function() { return ASPx.EnableCssAnimation && this.CurrentTransition; },
5235 CanUseCssTransform: function() { return this.CanUseCssTransition() && this.CurrentTransform; },
5236 CurrentTransition: (function() {
5237  var transitions = [
5238   { property: "webkitTransition", event: "webkitTransitionEnd" },
5239   { property: "MozTransition", event: "transitionend" },
5240   { property: "OTransition", event: "oTransitionEnd" },
5241   { property: "transition", event: "transitionend" }
5242  ];
5243  var fakeElement = document.createElement("DIV");
5244  for(var i = 0; i < transitions.length; i++)
5245   if(transitions[i].property in fakeElement.style)
5246    return transitions[i];
5247 })(),
5248 CurrentTransform: (function() {
5249  var transforms = ["transform", "MozTransform", "-webkit-transform", "msTransform", "OTransform"];
5250  var fakeElement = document.createElement("DIV");
5251  for(var i = 0; i < transforms.length; i++)
5252   if(transforms[i] in fakeElement.style)
5253    return transforms[i];
5254 })(),
5255 SetTransformValue: function(element, position, isTop) {
5256  if(this.CanUseCssTransform())
5257   element.style[this.CurrentTransform] = this.GetTransformCssText(position, isTop);
5258  else
5259   element.style[!isTop ? "left" : "top"] = position + "px";
5260 },
5261 GetTransformValue: function(element, isTop) {
5262  if(this.CanUseCssTransform()) {
5263   var cssValue = element.style[this.CurrentTransform];
5264   return cssValue && cssValue != "none" ? Number(cssValue.replace('matrix(1, 0, 0, 1,', '').replace(')', '').split(',')[!isTop ? 0 : 1]) : 0;
5265  }
5266  else
5267   return !isTop ? element.offsetLeft : element.offsetTop;
5268 },
5269 GetTransformCssText: function(position, isTop) {
5270  if(!position)
5271   return "none";
5272  return "matrix(1, 0, 0, 1," + (!isTop ? position : 0) + ", " + (!isTop ? 0 : position) + ")";
5273 },
5274 createMultipleAnimationTransition: function (element, options) {
5275  return this.CanUseCssTransition() && !options.onStep ? new MultipleCssAnimationTransition(element, options) : new MultipleJsAnimationTransition(element, options);
5276 },
5277 createSimpleAnimationTransition: function(options) {
5278  return new SimpleAnimationTransition(options);
5279 },
5280 createJsAnimationTransition: function(element, options) {
5281  return new JsAnimationTransition(element, options);
5282 },
5283 createCssAnimationTransition: function(element, options) {
5284  return new CssAnimationTransition(element, options);
5285 },
5286 setOpacity: function(element, value) {
5287  ASPx.SetElementOpacity(element, value);
5288 }
5289};
5290var AsyncTracker = function() {
5291 var currentToken,
5292  lockedTokens,
5293  onDoneDelegates,
5294  lockedDelegates;
5295 function clearState() {
5296  currentToken = 1;
5297  lockedTokens = [];
5298  onDoneDelegates = [];
5299  lockedDelegates = {};
5300 }
5301 clearState();
5302 var log = function(msg) { };
5303 function setLog(delegate){
5304  log = delegate;
5305 }
5306 function getLockToken() {
5307  if(onDoneDelegates.length === 0)
5308   return -1;
5309  var token = currentToken++;
5310  lockedTokens.push(token);
5311  lockedDelegates[token] = [];
5312  for (var i = 0; i < onDoneDelegates.length; i++) {
5313   lockedDelegates[token].push(onDoneDelegates[i]);
5314  }
5315  log("module locks token " + token);
5316  return token;
5317 }
5318 function releaseToken(token) {
5319  if(token < 0) return;
5320  log("module releasing token " + token);
5321  ASPx.Data.ArrayRemove(lockedTokens, token);
5322  delete lockedDelegates[token];
5323  invokeUnlockedDelegates();
5324  if(lockedTokens.length === 0)
5325   clearState();
5326  log("module released token " + token);
5327 }
5328 function invokeUnlockedDelegates() {
5329  var onDoneDelegate;
5330  for (var i = onDoneDelegates.length - 1; i >= 0; i--) {
5331   if(onDoneDelegates[i] && !isDelegateLocked(onDoneDelegates[i])) {
5332    onDoneDelegate = onDoneDelegates[i];
5333    delete onDoneDelegates[i];
5334    onDoneDelegate();
5335   }
5336  }
5337 }
5338 function isDelegateLocked(delegate) {
5339  for (var i = lockedTokens.length - 1; i >= 0; i--) {
5340   var token = lockedTokens[i];
5341   var delegates = lockedDelegates[token];
5342   if(delegates) {
5343    for (var j = delegates.length - 1; j >= 0; j--) {
5344     if(delegates[j] && delegates[j] === delegate)
5345      return true;
5346    }
5347   }
5348  }
5349  return false;
5350 }
5351 function track(doDelegate, onDoneDelegate) {
5352  if(onDoneDelegate)
5353   onDoneDelegates.push(onDoneDelegate);
5354  doDelegate();
5355  if(onDoneDelegate)
5356   invokeUnlockedDelegates();
5357 }
5358 return {
5359  getLockToken: getLockToken,
5360  releaseToken: releaseToken,
5361  track: track,
5362  setLog:setLog,
5363 };
5364};
5365var GetEditorValuesInContainer = function(containerOrId, processInvisibleEditors, needSerialize) {
5366 var container = typeof(containerOrId) === "string" ? ASPx.GetElementById(containerOrId) : containerOrId;

5367 var result = {};
5368 if(!ASPx.ProcessEditorsInContainer) 
5369  return result;
5370 ASPx.ProcessEditorsInContainer(container, function(editor){
5371  result[editor.name] = GetCorrectedByTypeValue(ASPx.GetEditorValueByControl(editor), needSerialize);
5372  return true;
5373 }, null, null, processInvisibleEditors, false);
5374 return result;
5375};
5376var SetEditorValues = function(values) {
5377 for(var controlName in values) {
5378  if(values.hasOwnProperty(controlName)) {
5379   var trackedControl = ASPxClientControl.GetControlCollection().Get(controlName);
5380   if(!trackedControl)
5381    continue;
5382   var setValueMethod = trackedControl.SetTokenCollection || trackedControl.SelectValues || trackedControl.SetValue;
5383   if(setValueMethod === trackedControl.SelectValues)
5384    trackedControl.UnselectAll();
5385   setValueMethod.call(trackedControl, values[controlName]);
5386  }
5387 }
5388};
5389var GetCorrectedByTypeValue = function(value, needSerialize){
5390 if(ASPx.Ident.IsArray(value))
5391  for(var i = 0; i < value.length; i++)
5392   value[i] = GetCorrectedByTypeValue(value[i]);
5393 if(needSerialize && ASPx.Ident.IsDate(value))
5394  return ASPx.DateUtils.GetInvariantDateTimeString(value);
5395 return value;
5396};
5397var ListBoxTemporaryCache = ASPx.CreateClass(null, {
5398 constructor: function() { 
5399  this.cache = { };
5400  this.invalidateTimerID = -1;
5401 },
5402 Get: function(key, getObjectFunc, context, args) {
5403  if(this.invalidateTimerID < 0) {
5404   this.invalidateTimerID = window.setTimeout(function() {
5405    this.Invalidate();
5406   }.aspxBind(this), 0);
5407  }
5408  if(!ASPx.IsExists(this.cache[key])) {
5409   if(!ASPx.IsExists(args))
5410    args = [ ];
5411   this.cache[key] = getObjectFunc.apply(context, args);
5412  }
5413  return this.cache[key];
5414 },
5415 Invalidate: function() {
5416  this.cache = { };
5417  this.invalidateTimerID = ASPx.Timer.ClearTimer(this.invalidateTimerID);
5418 }
5419});
5420ASPx.GetEditorValueByControl = function(control, needSerialize) {
5421 var result;
5422 if(ASPx.IsMultipleValueOwner(control))
5423  result = control.GetSelectedValues();
5424 if(ASPx.IsTokenBox(control)) {
5425  if(needSerialize)
5426   result = control.GetTokenValuesCollection();
5427  else
5428   result = control.GetTokenCollection();
5429 }
5430 if(ASPx.IsDropDownEdit(control))
5431  result = control.GetKeyValue();
5432 if(ASPx.IsHtmlEditor(control))
5433  result = control.GetHtml();
5434 return result || control.GetValue();
5435};
5436ASPx.IsMultipleValueOwner = function(control) {
5437 return ASPx.IsListBox(control) || ASPx.IsCheckBoxList(control);
5438};
5439ASPx.IsCheckBoxList = function(control) {
5440 return control && typeof(ASPxClientCheckBoxList) != "undefined" && control instanceof ASPxClientCheckBoxList;
5441 };
5442ASPx.IsCheckBox = function(control) {
5443 return control && typeof (ASPxClientCheckBox) != "undefined" && control instanceof ASPxClientCheckBox;
5444};
5445ASPx.IsListBox = function(control) {
5446 return control && typeof(ASPxClientListBox) != "undefined" && control instanceof ASPxClientListBox;
5447};
5448ASPx.IsComboBox = function(control) {
5449 return control && typeof(ASPxClientComboBox) != "undefined" && control instanceof ASPxClientComboBox;
5450};
5451ASPx.IsTokenBox = function(control) {
5452 return control && typeof(ASPxClientTokenBox) != "undefined" && control instanceof ASPxClientTokenBox;
5453};
5454ASPx.IsDropDownEdit = function(control) {
5455 return control && typeof (ASPxClientDropDownEdit) != "undefined" && control instanceof ASPxClientDropDownEdit;
5456};
5457ASPx.IsGridLookup = function(control) {
5458 return control && typeof(MVCxClientGridLookup) != "undefined" && control instanceof MVCxClientGridLookup;
5459};
5460ASPx.IsSpinEdit = function(control) {
5461 return control && typeof(ASPxClientSpinEdit) != "undefined" && control instanceof ASPxClientSpinEdit;
5462};
5463ASPx.IsHtmlEditor = function(control) {
5464 return control && typeof (ASPxClientHtmlEditor) != "undefined" && control instanceof ASPxClientHtmlEditor;
5465};
5466ASPx.DatePickerType = {
5467 Days: 0,
5468 Months: 1,
5469 Years: 2,
5470 Decades: 3
5471};
5472ASPx.FullScreenUtils = {
5473 subscribeChange: function(handler) {
5474  Evt.AttachEventToElement(document, "fullscreenchange", handler);
5475  Evt.AttachEventToElement(document, "msfullscreenchange", handler); 
5476  Evt.AttachEventToElement(document, "MSFullscreenChange", handler); 
5477  Evt.AttachEventToElement(document, "webkitfullscreenchange", handler);
5478  Evt.AttachEventToElement(document, "mozfullscreenchange", handler);
5479 },
5480 unsubscribeChange: function(handler) {
5481  Evt.DetachEventFromElement(document, "fullscreenchange", handler);
5482  Evt.DetachEventFromElement(document, "msfullscreenchange", handler);
5483  Evt.DetachEventFromElement(document, "MSFullscreenChange", handler);
5484  Evt.DetachEventFromElement(document, "webkitfullscreenchange", handler);
5485  Evt.DetachEventFromElement(document, "mozfullscreenchange", handler);
5486 },
5487 setFullscreen: function(on) {
5488  var element = window.self.document.body;
5489  if(on) {
5490   if(element.requestFullscreen) {
5491    element.requestFullscreen();
5492   } else if(element.mozRequestFullScreen) {
5493    element.mozRequestFullScreen();
5494   } else if(element.webkitRequestFullscreen) {
5495    element.webkitRequestFullscreen();
5496   } else if(element.msRequestFullscreen) {
5497    element.msRequestFullscreen();
5498   }
5499  } else {
5500   if(document.exitFullscreen) {
5501    document.exitFullscreen();
5502   } else if(document.mozCancelFullScreen) {
5503    document.mozCancelFullScreen();
5504   } else if(document.webkitCancelFullScreen) {
5505    document.webkitCancelFullScreen();
5506   } else if(document.msExitFullscreen) {
5507    document.msExitFullscreen();
5508   }
5509  }
5510 },
5511 inFullscreen: function() {
5512  var fullscreenElement = document.fullscreenElement || document.msFullscreenElement || document.webkitFullscreenElement;
5513  var isInFullscreen = fullscreenElement === document.body || document.webkitIsFullScreen;

5514  return !!isInFullscreen;
5515 }
5516 };
5517ASPx.InitializeSVGSprite = function () {
5518 if (ASPx.SVGSprites && ASPx.SVGSprites.length > 0) {
5519  var svgContainer = document.getElementById('svgContainer');
5520  var hasSvgContainer = !!svgContainer;
5521  if (!hasSvgContainer) {
5522   svgContainer = document.createElement('div');
5523   svgContainer.id = 'svgContainer';
5524   svgContainer.style.display = "none";
5525   document.body.appendChild(svgContainer);
5526  }
5527  for (var i = 0; i < ASPx.SVGSprites.length; i++) {
5528   svgContainer.innerHTML += ASPx.SVGSprites[i];
5529  }
5530  ASPx.SVGSprites = null;
5531 }
5532};
5533var GridDynamicStyleSheetHelper = ASPx.CreateClass(null, {
5534 constructor: function() {
5535  this.styleSheet = {};
5536  this.rules = {};
5537  this.updateLock = 0;
5538 },
5539 Update: function(control, styleName, rules) {
5540  var key = control.name + "_" + styleName;
5541  this.BeginUpdate(key);
5542  this.ChangeRules(key, rules);
5543  this.EndUpdate(key);
5544 },
5545 ChangeRules: function(key, rules) {
5546  if(key && rules)
5547   this.rules[key] = rules;
5548 },
5549 BeginUpdate: function(key) {
5550  this.updateLock++;
5551  this.RemoveStyleSheetElement(key);
5552 },
5553 EndUpdate: function(key) {
5554  this.updateLock--;
5555  if(this.updateLock !== 0)
5556   return;
5557  var styleArgs = [];
5558  var controlRules = this.rules[key];
5559  for(var i = 0; i < controlRules.length; i++) {
5560   var rule = controlRules[i];
5561   styleArgs.push(rule.selector + " { " + rule.cssText + " } ");
5562  }
5563  this.styleSheet[key] = this.CreateStyleSheet(key, styleArgs.join(""));
5564 },
5565 CreateStyleSheet: function(key, cssText) {
5566  var container = document.createElement("DIV");
5567  ASPx.Security.setInnerHtml(container, "<style type='text/css' id='" + key + "'>" + cssText + "</style>", ASPx.Security.DataType.Trusted);
5568  styleSheet = ASPx.GetNodeByTagName(container, "style", 0);
5569  if(styleSheet)
5570   ASPx.GetNodeByTagName(document, "HEAD", 0).appendChild(styleSheet);
5571  return styleSheet;
5572 },
5573 ClearStyleSheet: function(control, styleName) {
5574  var key = control.name + "_" + styleName;
5575  this.RemoveStyleSheetElement(key);
5576 },
5577 RemoveStyleSheetElement: function(key) {
5578  if(this.styleSheet[key]) {
5579   ASPx.RemoveElement(this.styleSheet[key]);
5580   delete this.styleSheet[key];
5581  }
5582 }
5583});
5584GridDynamicStyleSheetHelper.Instance = new GridDynamicStyleSheetHelper();
5585ASPx.GridDynamicStyleSheetHelper = GridDynamicStyleSheetHelper;
5586ASPxClientUtils = {};
5587ASPxClientUtils.agent = Browser.UserAgent;
5588ASPxClientUtils.opera = Browser.Opera;
5589ASPxClientUtils.opera9 = Browser.Opera && Browser.MajorVersion == 9;
5590ASPxClientUtils.safari = Browser.Safari;
5591ASPxClientUtils.safari3 = Browser.Safari && Browser.MajorVersion == 3;
5592ASPxClientUtils.safariMacOS = Browser.Safari && Browser.MacOSPlatform;
5593ASPxClientUtils.chrome = Browser.Chrome;
5594ASPxClientUtils.ie = Browser.IE;
5595ASPxClientUtils.ie7 = Browser.IE && Browser.MajorVersion == 7;
5596ASPxClientUtils.firefox = Browser.Firefox;
5597ASPxClientUtils.firefox3 = Browser.Firefox && Browser.MajorVersion == 3;
5598ASPxClientUtils.mozilla = Browser.Mozilla;
5599ASPxClientUtils.netscape = Browser.Netscape;
5600ASPxClientUtils.browserVersion = Browser.Version;
5601ASPxClientUtils.browserMajorVersion = Browser.MajorVersion;
5602ASPxClientUtils.macOSPlatform = Browser.MacOSPlatform;
5603ASPxClientUtils.windowsPlatform = Browser.WindowsPlatform;
5604ASPxClientUtils.webKitFamily = Browser.WebKitFamily;
5605ASPxClientUtils.netscapeFamily = Browser.NetscapeFamily;
5606ASPxClientUtils.touchUI = Browser.TouchUI;
5607ASPxClientUtils.webKitTouchUI = Browser.WebKitTouchUI;
5608ASPxClientUtils.msTouchUI = Browser.MSTouchUI;
5609ASPxClientUtils.iOSPlatform = Browser.MacOSMobilePlatform;
5610ASPxClientUtils.androidPlatform = Browser.AndroidMobilePlatform;
5611ASPxClientUtils.ArrayInsert = Data.ArrayInsert;
5612ASPxClientUtils.ArrayRemove = Data.ArrayRemove;
5613ASPxClientUtils.ArrayRemoveAt = Data.ArrayRemoveAt;
5614ASPxClientUtils.ArrayClear = Data.ArrayClear;
5615ASPxClientUtils.ArrayIndexOf = Data.ArrayIndexOf;
5616ASPxClientUtils.AttachEventToElement = Evt.AttachEventToElement;
5617ASPxClientUtils.DetachEventFromElement = Evt.DetachEventFromElement;
5618ASPxClientUtils.GetEventSource = Evt.GetEventSource;
5619ASPxClientUtils.GetEventX = Evt.GetEventX;
5620ASPxClientUtils.GetEventY = Evt.GetEventY;
5621ASPxClientUtils.GetKeyCode = Evt.GetKeyCode;
5622ASPxClientUtils.PreventEvent = Evt.PreventEvent;
5623ASPxClientUtils.PreventEventAndBubble = Evt.PreventEventAndBubble;
5624ASPxClientUtils.PreventDragStart = Evt.PreventDragStart;
5625ASPxClientUtils.ClearSelection = Selection.Clear;
5626ASPxClientUtils.IsExists = ASPx.IsExists;
5627ASPxClientUtils.IsFunction = ASPx.IsFunction;
5628ASPxClientUtils.GetAbsoluteX = ASPx.GetAbsoluteX;
5629ASPxClientUtils.GetAbsoluteY = ASPx.GetAbsoluteY;
5630ASPxClientUtils.SetAbsoluteX = ASPx.SetAbsoluteX;
5631ASPxClientUtils.SetAbsoluteY = ASPx.SetAbsoluteY;
5632ASPxClientUtils.GetDocumentScrollTop = ASPx.GetDocumentScrollTop;
5633ASPxClientUtils.GetDocumentScrollLeft = ASPx.GetDocumentScrollLeft;
5634ASPxClientUtils.GetDocumentClientWidth = ASPx.GetDocumentClientWidth;
5635ASPxClientUtils.GetDocumentClientHeight = ASPx.GetDocumentClientHeight;
5636ASPxClientUtils.AddClassNameToElement = ASPx.AddClassNameToElement;
5637ASPxClientUtils.RemoveClassNameFromElement = ASPx.RemoveClassNameFromElement;
5638ASPxClientUtils.ToggleClassName = ASPx.ToggleClassNameToElement;
5639ASPxClientUtils.GetIsParent = ASPx.GetIsParent;
5640ASPxClientUtils.GetParentById = ASPx.GetParentById;
5641ASPxClientUtils.GetParentByTagName = ASPx.GetParentByTagName;
5642ASPxClientUtils.GetParentByClassName = ASPx.GetParentByPartialClassName;
5643ASPxClientUtils.GetChildById = ASPx.GetChildById;
5644ASPxClientUtils.GetChildByTagName = ASPx.GetChildByTagName;
5645ASPxClientUtils.SetCookie = Cookie.SetCookie;

5646ASPxClientUtils.GetCookie = Cookie.GetCookie;
5647ASPxClientUtils.DeleteCookie = Cookie.DelCookie;
5648ASPxClientUtils.GetShortcutCode = ASPx.GetShortcutCode; 
5649ASPxClientUtils.GetShortcutCodeByEvent = ASPx.GetShortcutCodeByEvent;
5650ASPxClientUtils.StringToShortcutCode = ASPx.ParseShortcutString;
5651ASPxClientUtils.Trim = Str.Trim; 
5652ASPxClientUtils.TrimStart = Str.TrimStart;
5653ASPxClientUtils.TrimEnd = Str.TrimEnd;
5654ASPxClientUtils.GetEditorValuesInContainer = GetEditorValuesInContainer;
5655ASPxClientUtils.SetEditorValues = SetEditorValues;
5656ASPxClientUtils.SendMessageToAssistiveTechnology = ASPx.AccessibilityUtils.SendMessageToAssistiveTechnology;
5657window.ASPxClientUtils = ASPxClientUtils;
5658window.ListBoxTemporaryCache = ListBoxTemporaryCache;
5659ASPx.AnimationUtils = AnimationUtils;
5660ASPx.AnimationTransitionBase = AnimationTransitionBase;
5661ASPx.AnimationConstants = AnimationConstants;
5662ASPx.AsyncTracker = AsyncTracker;
5663ASPx.Security = Security;
5664})(ASPx, dx);
5665
5666(function module(ASPx, options) {
5667ASPx.modules.Classes = module;
5668ASPx.classesScriptParsed = false;
5669ASPx.documentLoaded = false; 
5670ASPx.CallbackType = {
5671 Data: "d",
5672 Common: "c"
5673};
5674ASPx.callbackState = {
5675 aborted: "aborted",
5676 inTurn: "inTurn",
5677 sent: "sent"
5678};
5679var ASPxClientEvent = ASPx.CreateClass(null, {
5680 constructor: function() {
5681  this.handlerInfoList = [];
5682  this.firingIndex = -1;
5683 },
5684 AddHandler: function(handler, executionContext) {
5685  if(typeof(executionContext) == "undefined")
5686   executionContext = null;
5687  this.RemoveHandler(handler, executionContext);
5688  var handlerInfo = ASPxClientEvent.CreateHandlerInfo(handler, executionContext);
5689  this.handlerInfoList.push(handlerInfo);
5690 },
5691 RemoveHandler: function(handler, executionContext) {
5692  this.removeHandlerByCondition(function(handlerInfo) {
5693   return handlerInfo.handler == handler && 
5694    (!executionContext || handlerInfo.executionContext == executionContext);
5695  });
5696 },
5697 removeHandlerByCondition: function(predicate) {
5698   for(var i = this.handlerInfoList.length - 1; i >= 0; i--) {
5699   var handlerInfo = this.handlerInfoList[i];
5700   if(predicate(handlerInfo)) {
5701    ASPx.Data.ArrayRemoveAt(this.handlerInfoList, i);
5702    if(i <= this.firingIndex)
5703     this.firingIndex--;
5704   }
5705  }
5706 },
5707 removeHandlerByControlName: function(controlName) {
5708  this.removeHandlerByCondition(function(handlerInfo) {
5709   return handlerInfo.executionContext &&  
5710    handlerInfo.executionContext.name === controlName;
5711  });
5712 },
5713 ClearHandlers: function() {
5714  this.handlerInfoList.length = 0;
5715 },
5716 FireEvent: function(obj, args) {
5717  for(this.firingIndex = 0; this.firingIndex < this.handlerInfoList.length; this.firingIndex++) {
5718   var handlerInfo = this.handlerInfoList[this.firingIndex];
5719   handlerInfo.handler.call(handlerInfo.executionContext, obj, args);
5720  }
5721 },
5722 InsertFirstHandler: function(handler, executionContext){
5723  if(typeof(executionContext) == "undefined")
5724   executionContext = null;
5725  var handlerInfo = ASPxClientEvent.CreateHandlerInfo(handler, executionContext);
5726  ASPx.Data.ArrayInsert(this.handlerInfoList, handlerInfo, 0);
5727 },
5728 IsEmpty: function() {
5729  return this.handlerInfoList.length == 0;
5730 }
5731});
5732ASPxClientEvent.CreateHandlerInfo = function(handler, executionContext) {
5733 return {
5734  handler: handler,
5735  executionContext: executionContext
5736 };
5737};
5738var ASPxClientEventArgs = ASPx.CreateClass(null, {
5739 constructor: function() {
5740 }
5741});
5742ASPxClientEventArgs.Empty = new ASPxClientEventArgs();
5743var ASPxClientCancelEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
5744 constructor: function(){
5745  this.constructor.prototype.constructor.call(this);
5746  this.cancel = false;
5747 }
5748});
5749var ASPxClientProcessingModeEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
5750 constructor: function(processOnServer){
5751  this.constructor.prototype.constructor.call(this);
5752  this.processOnServer = !!processOnServer;
5753 }
5754});
5755var ASPxClientProcessingModeCancelEventArgs = ASPx.CreateClass(ASPxClientProcessingModeEventArgs, {
5756 constructor: function(processOnServer){
5757  this.constructor.prototype.constructor.call(this, processOnServer);
5758  this.cancel = false;
5759 }
5760});
5761var OrderedMap = ASPx.CreateClass(null, {
5762 constructor: function(){
5763  this.entries = {};
5764  this.firstEntry = null;
5765  this.lastEntry = null;
5766 },
5767 add: function(key, element) {
5768  var entry = this.addEntry(key, element);
5769  this.entries[key] = entry;
5770 },
5771 remove: function(key) {
5772  var entry = this.entries[key];
5773  if(entry === undefined)
5774   return;
5775  this.removeEntry(entry);
5776  delete this.entries[key];
5777 },
5778 clear: function() {
5779  this.markAllEntriesAsRemoved();
5780  this.entries = {};
5781  this.firstEntry = null;
5782  this.lastEntry = null;
5783 },
5784 get: function(key) {
5785  var entry = this.entries[key];
5786  return entry ? entry.value : undefined;
5787 },
5788 forEachEntry: function(processFunc, context) {
5789  context = context || this;
5790  for(var entry = this.firstEntry; entry; entry = entry.next) {
5791   if(entry.removed)
5792    continue;
5793   if(processFunc.call(context, entry.key, entry.value))
5794    return;
5795  }
5796 },
5797 addEntry: function(key, element) {
5798  var entry = { key: key, value: element, next: null, prev: null };
5799  if(!this.firstEntry)
5800   this.firstEntry = entry;
5801  else {
5802   entry.prev = this.lastEntry;
5803   this.lastEntry.next = entry;
5804  }
5805  this.lastEntry = entry;
5806  return entry;
5807 },
5808 removeEntry: function(entry) {
5809  if(this.firstEntry == entry)
5810   this.firstEntry = entry.next;
5811  if(this.lastEntry == entry)
5812   this.lastEntry = entry.prev;
5813  if(entry.prev)
5814   entry.prev.next = entry.next;
5815  if(entry.next)
5816   entry.next.prev = entry.prev;
5817  entry.removed = true;
5818 },
5819 markAllEntriesAsRemoved: function() {
5820  for(var entry = this.firstEntry; entry; entry = entry.next)
5821   entry.removed = true;
5822 }
5823});
5824var CollectionBase = ASPx.CreateClass(null, {
5825 constructor: function(){
5826  this.elementsMap = new OrderedMap();
5827  this.isASPxClientCollection = true;
5828 },
5829 Add: function(key, element) {
5830  this.elementsMap.add(key, element);
5831 },
5832 Remove: function(key) {
5833  this.elementsMap.remove(key);
5834 },
5835 Clear: function(){
5836  this.elementsMap.clear();
5837 },
5838 Get: function(key){
5839  return this.elementsMap.get(key);
5840 }
5841});
5842(function garbageCollector(ASPx, options) {
5843 ASPx.modules.garbageCollector = garbageCollector;
5844 var interval = options.GCCheckInterval;
5845 window.setInterval(collectObjects, interval);
5846 function canCollectObjects() {
5847  if (!ASPx.GetControlCollection) return false;
5848  var collection = ASPx.GetControlCollection();
5849  return collection && !collection.InCallback();
5850 }
5851 function collectObjects() {
5852  if (!canCollectObjects()) return;
5853  ASPx.GetControlCollectionCollection().RemoveDisposedControls();
5854  if(typeof(ASPx.GetStateController) != "undefined")
5855   ASPx.GetStateController().RemoveDisposedItems();

5856  if(ASPx.TableScrollHelperCollection)
5857   ASPx.TableScrollHelperCollection.RemoveDisposedObjects();
5858  if(ASPx.Ident.scripts.ASPxClientRatingControl)
5859   ASPxClientRatingControl.RemoveDisposedElementUnderCursor();
5860  var postHandler = ASPx.GetPostHandler();
5861  if(postHandler)
5862   postHandler.RemoveDisposedFormsFromCache();
5863 }
5864})(ASPx, options);
5865var ControlTree = ASPx.CreateClass(null, {
5866 constructor: function(controlCollection, container, controlFilter) {
5867  this.container = container;
5868  this.domMap = { };
5869  this.rootNode = this.createNode(null, null);
5870  this.createControlTree(controlCollection, container, controlFilter);
5871 },
5872 createControlTree: function(controlCollection, container, controlFilter) {
5873  controlCollection.ProcessControlsInContainer(container, function(control) {
5874   control.RegisterInControlTree(this);
5875  }.aspxBind(this), controlFilter);
5876  var fixedNodes = [];
5877  var fixedNodesChildren = [];
5878  for(var domElementID in this.domMap) {
5879   if(!this.domMap.hasOwnProperty(domElementID)) continue;
5880   var node = this.domMap[domElementID];
5881   var controlOwner = node.control ? node.control.controlOwner : null;
5882   if(controlOwner && this.domMap[controlOwner.name])
5883    continue;
5884   if(this.isFixedNode(node))
5885    fixedNodes.push(node);
5886   else {
5887    var parentNode = this.findParentNode(domElementID);
5888    parentNode = parentNode || this.rootNode;
5889    if(this.isFixedNode(parentNode))
5890     fixedNodesChildren.push(node);
5891    else {
5892     var childNode = node.mainNode || node;
5893     this.addChildNode(parentNode, childNode);
5894    }
5895   }
5896  }
5897  for(var i = fixedNodes.length - 1; i >= 0; i--)
5898   this.insertChildNode(this.rootNode, fixedNodes[i], 0);
5899  for(var i = fixedNodesChildren.length - 1; i >= 0; i--)
5900   this.insertChildNode(this.rootNode, fixedNodesChildren[i], 0);
5901 },
5902 findParentNode: function(id) {
5903  var element = document.getElementById(id).parentNode;
5904  while(element && element.tagName !== "BODY") {
5905   if(element.id) {
5906    var parentNode = this.domMap[element.id];
5907    if(parentNode)
5908     return parentNode;
5909   }
5910   element = element.parentNode;
5911  }
5912  return null;
5913 },
5914 addChildNode: function(node, childNode) {
5915  if(!childNode.parentNode) {
5916   node.children.push(childNode);
5917   childNode.parentNode = node;
5918  }
5919 },
5920 insertChildNode: function(node, childNode, index) {
5921  if(!childNode.parentNode) {
5922   ASPx.Data.ArrayInsert(node.children, childNode, index);
5923   childNode.parentNode = node;
5924  }
5925 },
5926 addRelatedNode: function(node, relatedNode) {
5927  this.addChildNode(node, relatedNode);
5928  relatedNode.mainNode = node;
5929 },
5930 isFixedNode: function(node) {
5931  var control = node.mainNode ? node.mainNode.control : node.control;
5932  return control && control.HasFixedPosition();
5933 },
5934 createNode: function(domElementID, control) {
5935  var node = {
5936   control: control,
5937   children: [],
5938   parentNode: null,
5939   mainNode: null
5940  };
5941  if(domElementID)
5942   this.domMap[domElementID] = node;
5943  return node;
5944 }
5945});
5946var ControlAdjuster = ASPx.CreateClass(null, {
5947 constructor: function() {
5948 },
5949 adjustControlsInHierarchy: function(controlCollection, adjustFunc, container, collapseControls, controlFilter) {
5950  var controlTree = new ASPx.ControlTree(controlCollection, container, controlFilter);
5951  this.adjustControlsInTree(controlTree.rootNode, adjustFunc, container, collapseControls);
5952 },
5953 adjustControlsInTree: function(treeNode, adjustFunc, container, collapseControls) {
5954  var observer = _aspxGetDomObserver();
5955  observer.pause(container, true);
5956  var documentScrollInfo;
5957  if(collapseControls) {
5958   documentScrollInfo = ASPx.GetOuterScrollPosition(document.body);
5959   this.collapseControls(treeNode);
5960  }
5961  var adjustNodes = [], 
5962   autoHeightNodes = [];
5963  var requireReAdjust = this.forEachControlCore(treeNode, collapseControls, adjustFunc, adjustNodes, autoHeightNodes);
5964  if(requireReAdjust)
5965   this.forEachControlsBackward(adjustNodes, collapseControls, adjustFunc);
5966  else {
5967   for(var i = 0, node; node = autoHeightNodes[i]; i++)
5968    node.control.AdjustAutoHeight();
5969  }
5970  if(collapseControls)
5971   ASPx.RestoreOuterScrollPosition(documentScrollInfo);
5972  observer.resume(container, true);
5973 },
5974 forEachControlCore: function(node, collapseControls, processFunc, adju

5974stNodes, autoHeightNodes) {
5975  var requireReAdjust = false,
5976   size, newSize;
5977  if(node.control) {
5978   var checkReadjustment = collapseControls && node.control.IsControlCollapsed() && node.control.CanCauseReadjustment();
5979   if(checkReadjustment)
5980    size = node.control.GetControlPercentMarkerSize(false, true);
5981   if(node.control.IsControlCollapsed() && !node.control.IsExpandableByAdjustment())
5982    node.control.ExpandControl();
5983   node.control.isInsideHierarchyAdjustment = true;
5984   processFunc(node.control);
5985   node.control.isInsideHierarchyAdjustment = false;
5986   if(checkReadjustment) {
5987    newSize = node.control.GetControlPercentMarkerSize(false, true);
5988    requireReAdjust = size.width !== newSize.width;
5989   }
5990   if(node.control.sizingConfig.supportAutoHeight)
5991    autoHeightNodes.push(node);
5992   node.control.ResetControlPercentMarkerSize();
5993  }
5994  for(var childNode, i = 0; childNode = node.children[i]; i++)
5995   requireReAdjust = this.forEachControlCore(childNode, collapseControls, processFunc, adjustNodes, autoHeightNodes) || requireReAdjust;
5996  adjustNodes.push(node);
5997  return requireReAdjust;
5998 },
5999 forEachControlsBackward: function(adjustNodes, collapseControls, processFunc) {
6000  for(var i = 0, node; node = adjustNodes[i]; i++)
6001   this.forEachControlsBackwardCore(node, collapseControls, processFunc);
6002 },
6003 forEachControlsBackwardCore: function(node, collapseControls, processFunc) {
6004  if(node.control)
6005   processFunc(node.control);
6006  if(node.children.length > 1) {
6007   for(var i = 0, childNode; childNode = node.children[i]; i++) {
6008    if(childNode.control)
6009     processFunc(childNode.control);
6010   }
6011  }
6012 },
6013 collapseControls: function(node) {
6014  for(var childNode, i = 0; childNode = node.children[i]; i++)
6015   this.collapseControls(childNode);
6016  if(node.control && node.control.NeedCollapseControl())
6017   node.control.CollapseControl();
6018 }
6019});
6020var controlAdjuster = null;
6021function GetControlAdjuster() {
6022 if(!controlAdjuster)
6023  controlAdjuster = new ControlAdjuster();
6024 return controlAdjuster;
6025}
6026function _aspxFunctionIsInCallstack(currentCallee, targetFunction, depthLimit) {
6027 var candidate = currentCallee;
6028 var depth = 0;
6029 while(candidate && depth <= depthLimit) {
6030  candidate = candidate.caller;
6031  if(candidate == targetFunction)
6032   return true;
6033  depth++;
6034 }
6035 return false;
6036}
6037ASPx.attachToReady(aspxClassesWindowOnLoad);
6038function aspxClassesWindowOnLoad(){
6039 ASPx.documentLoaded = true;
6040 _aspxMoveLinkElements();
6041 _aspxSweepDuplicatedLinks();
6042 ResourceManager.SynchronizeResources();
6043 var externalScriptProcessor = GetExternalScriptProcessor();
6044 if(externalScriptProcessor)
6045  externalScriptProcessor.ShowErrorMessages();
6046 ASPx.AccessibilityUtils.initialize();
6047 ASPx.GetControlCollection().Initialize();
6048 _aspxInitializeScripts();
6049 _aspxInitializeLinks();
6050 _aspxInitializeFocus();
6051 ASPx.GetControlCollection().FinalizeInitialization();
6052}
6053Ident = { };
6054Ident.IsDate = function(obj) {
6055 return obj && (obj.constructor == Date || obj.constructor.name == "Date");
6056};
6057Ident.IsRegExp = function(obj) {
6058 return obj && obj.constructor === RegExp;
6059};
6060Ident.IsArray = function(obj) {
6061 return obj && obj.constructor == Array;
6062};
6063Ident.IsASPxClientCollection = function(obj) {
6064 return obj && obj.isASPxClientCollection;
6065};
6066Ident.IsASPxClientControl = function(obj) {
6067 return obj && obj instanceof ASPxClientControlBase;
6068};
6069Ident.IsASPxClientEdit = function(obj) {
6070 return obj && obj.isASPxClientEdit;
6071};
6072Ident.IsFocusableElementRegardlessTabIndex = function (element) {
6073 var tagName = element.tagName;
6074 return tagName == "TEXTAREA" || tagName == "INPUT" || tagName == "A" ||
6075  tagName == "SELECT" || tagName == "IFRAME" || tagName == "OBJECT" || tagName == "BUTTON";
6076};
6077Ident.isDialogInvisibleControl = function(control) {
6078 return !!ASPx.Dialog && ASPx.Dialog.isDialogInvisibleControl(control);
6079};
6080Ident.isBatchEditUnusedEditor = function(control) {
6081 return !!ASPx.BatchEditHelper && ASPx.BatchEditHelper.isBatchEditUnusedEditor(control);
6082};
6083Ident.scripts = {};
6084if(ASPx.IsFunction(window.WebForm_InitCallbackAddField)) {
6085 (function() {
6086  var original = window.WebForm_InitCallbackAddField;
6087  window.WebForm_InitCallbackAddField = function(name, value) {
6088   if(typeof(name) == "string" && name)
6089    original.apply(null, arguments);
6090  };
6091 })();
6092}
6093ASPx.FireDefaultButton = function(evt, buttonID) {
6094 if(_aspxIsDefaultButtonEvent(evt, buttonID)) {
6095  var defaultButton = ASPx.GetElementById(buttonID);

6096  if(defaultButton && defaultButton.click) {
6097   if(ASPx.IsFocusable(defaultButton))
6098    defaultButton.focus();
6099   ASPx.Evt.DoElementClick(defaultButton);
6100   ASPx.Evt.PreventEventAndBubble(evt);
6101   return false;
6102  }
6103 }
6104 return true;
6105};
6106function _aspxIsDefaultButtonEvent(evt, defaultButtonID) {
6107 if(evt.keyCode != ASPx.Key.Enter)
6108  return false;
6109 var srcElement = ASPx.Evt.GetEventSource(evt);
6110 if(!srcElement || srcElement.id === defaultButtonID)
6111  return true;
6112 var tagName = srcElement.tagName;
6113 var type = srcElement.type;
6114 return tagName != "TEXTAREA" && tagName != "BUTTON" && tagName != "A" &&
6115  (tagName != "INPUT" || type != "checkbox" && type != "radio" && type != "button" && type != "submit" && type != "reset");
6116}
6117var PostHandler = ASPx.CreateClass(null, {
6118 constructor: function() {
6119  this.Post = new ASPxClientEvent();
6120  this.PostFinalization = new ASPxClientEvent();
6121  this.observableForms = [];
6122  this.dxCallbackTriggers = {};
6123  this.lastSubmitElementName = null;
6124  this.beforeOnSubmit = function() { };
6125  this.ReplaceGlobalPostFunctions();
6126  this.HandleDxCallbackBeginning();
6127  this.HandleMSAjaxRequestBeginning();
6128 },
6129 Update: function() {
6130  this.ReplaceFormsSubmit(true);
6131 },
6132 ProcessPostRequest: function(ownerID, isCallback, isMSAjaxRequest, isDXCallback) {
6133  this.cancelPostProcessing = false;
6134  this.isMSAjaxRequest = isMSAjaxRequest;
6135  if(this.SkipRaiseOnPost(ownerID, isCallback, isDXCallback))
6136   return;
6137  var args = new PostHandlerOnPostEventArgs(ownerID, isCallback, isMSAjaxRequest, isDXCallback);
6138  this.Post.FireEvent(this, args);
6139  this.cancelPostProcessing = args.cancel;
6140  if(!args.cancel)
6141   this.PostFinalization.FireEvent(this, args);
6142 },
6143 SkipRaiseOnPost: function(ownerID, isCallback, isDXCallback) { 
6144  if(!isCallback)
6145   return false;
6146  var dxOwner = isDXCallback && ASPx.GetControlCollection().GetByName(ownerID);
6147  if(dxOwner) {
6148   this.dxCallbackTriggers[dxOwner.uniqueID] = true;
6149   return false;
6150  }
6151  if(this.dxCallbackTriggers[ownerID]) {
6152   this.dxCallbackTriggers[ownerID] = false;
6153   return true;
6154  }
6155  return false;
6156 },
6157 ReplaceGlobalPostFunctions: function() {
6158  if(ASPx.IsFunction(window.__doPostBack))
6159   this.ReplaceDoPostBack();
6160  if(ASPx.IsFunction(window.WebForm_DoCallback))
6161   this.ReplaceDoCallback();
6162  if(ASPx.IsFunction(window.WebForm_ExecuteCallback))
6163   this.ReplaceExecuteCallback();
6164  this.ReplaceFormsSubmit();
6165 },
6166 HandleDxCallbackBeginning: function() {
6167  ASPx.GetControlCollection().BeforeInitCallback.AddHandler(function(s, e) {
6168   aspxRaisePostHandlerOnPost(e.callbackOwnerID, true, false, true); 
6169  });
6170 },
6171 HandleMSAjaxRequestBeginning: function() {
6172  var pageRequestManager = ASPx.GetMSAjaxRequestManager();
6173  if(pageRequestManager != null && Ident.IsArray(pageRequestManager._onSubmitStatements)) {
6174   pageRequestManager._onSubmitStatements.unshift(function() {
6175    var postbackSettings = Sys.WebForms.PageRequestManager.getInstance()._postBackSettings;
6176    var postHandler = aspxGetPostHandler();
6177    aspxRaisePostHandlerOnPost(postbackSettings.asyncTarget, true, true);
6178    return !postHandler.cancelPostProcessing;
6179   });
6180  }
6181 },
6182 ReplaceDoPostBack: function() {
6183  var original = __doPostBack;
6184  __doPostBack = function(eventTarget, eventArgument) {
6185   var postHandler = aspxGetPostHandler();
6186   aspxRaisePostHandlerOnPost(eventTarget);
6187   if(postHandler.cancelPostProcessing)
6188    return;
6189   ASPxClientControl.postHandlingLocked = true;
6190   original(eventTarget, eventArgument);
6191   delete ASPxClientControl.postHandlingLocked;
6192  };
6193 },
6194 ReplaceDoCallback: function() {
6195  var original = WebForm_DoCallback;
6196  WebForm_DoCallback = function(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync) {
6197   var postHandler = aspxGetPostHandler();
6198   aspxRaisePostHandlerOnPost(eventTarget, true);
6199   if(postHandler.cancelPostProcessing)
6200    return;
6201   return original(eventTarget, eventArgument, eventCallback, context, errorCallback, useAsync);
6202  };
6203 },
6204 ReplaceExecuteCallback: function() {
6205  var original = WebForm_ExecuteCallback;
6206  var handler = this;
6207  WebForm_ExecuteCallback = function(callbackObject) {
6208   var isDxCallback = callbackObject && callbackObject.context && ASPx.GetControlCollection().Get(callbackObject.context) !== null;
6209   ASPx.callbackProcessed = false;
6210   original(callbackObject);
6211   if(ASPx.Browser.Firefox && document.getElementById("__EVENTVALIDATION")) {
6212    var viewStateField = document.getElementById("__VIEWSTATE");
6213    if(viewStateField) {
6214     var response = callbackObject.xmlRequest.responseText;
6215     var separatorIndex = response.indexOf("|");

6216     var validationFieldLength = separatorIndex > 0 ? response.substring(0, separatorIndex) : null;
6217     if(ASPx.IsNumber(validationFieldLength))
6218      viewStateField.value = viewStateField.value; 
6219    }
6220   }
6221   if(isDxCallback && !ASPx.callbackProcessed) {
6222    var request = callbackObject.xmlRequest;
6223    if(ASPxClientUtils.IsExists(callbackObject.eventCallback)) {
6224     if (handler.HasAppErrorOnCallback(request))
6225      callbackObject.eventCallback(handler.GetServerErrorText(), callbackObject.context);
6226     else if (handler.HasNetworkErrorOnCallback(request))
6227      callbackObject.eventCallback(handler.GetNetworkError(), callbackObject.context);
6228    }
6229   }
6230  };
6231 },
6232 HasAppErrorOnCallback: function(request) {
6233  if(!request) return false;
6234  var isServerError = request.status && request.status == 500;
6235  var pattern = /<html[^>]*>([\w|\W]*)<\/html>/im;
6236  var text = request.responseText;
6237  return isServerError && !!text && pattern.test(text);
6238 },
6239 GetServerErrorText: function() {
6240  return "Internal Server Error";
6241 },
6242 HasNetworkErrorOnCallback: function(request) {
6243  if (!request) return false;
6244  return request.readyState == 4 && request.status == 0;
6245 },
6246 GetNetworkError: function() {
6247  return new NetworkError();
6248 },
6249 ReplaceFormsSubmit: function(checkObservableCollection) {
6250  for(var i = 0; i < document.forms.length; i++) { 
6251   var form = document.forms[i];
6252   if(checkObservableCollection && ASPx.Data.ArrayIndexOf(this.observableForms, form) >= 0)
6253    continue;
6254   if(form.submit)
6255    this.ReplaceFormSubmit(form);
6256   this.ReplaceFormOnSumbit(form);
6257   this.observableForms.push(form);
6258  }
6259 },
6260 ReplaceFormSubmit: function(form) {
6261  var originalSubmit = form.submit;
6262  form.submit = function() {
6263   var postHandler = aspxGetPostHandler();
6264   aspxRaisePostHandlerOnPost();
6265   if(postHandler.cancelPostProcessing)
6266    return false;
6267   var callee = arguments.callee;
6268   this.submit = originalSubmit;
6269   var submitResult = this.submit();
6270   this.submit = callee;
6271   return submitResult;
6272  };
6273  form = null;
6274 },
6275 ReplaceFormOnSumbit: function(form) {
6276  var originalSubmit = form.onsubmit;
6277  form.onsubmit = function() {
6278   var postHandler = aspxGetPostHandler();
6279   postHandler.beforeOnSubmit();
6280   if(postHandler.isMSAjaxRequest)
6281    postHandler.isMsAjaxRequest = false;
6282   else
6283    aspxRaisePostHandlerOnPost(postHandler.GetLastSubmitElementName());
6284   if(postHandler.cancelPostProcessing)
6285    return false;
6286   return ASPx.IsFunction(originalSubmit)
6287    ? originalSubmit.apply(this, arguments)
6288    : true;
6289  };
6290  form = null;
6291 },
6292 SetBeforeOnSubmit: function(action) {
6293  this.beforeOnSubmit = action;
6294 },
6295 SetLastSubmitElementName: function(elementName) {
6296  this.lastSubmitElementName = elementName;
6297 },
6298 GetLastSubmitElementName: function() {
6299  return this.lastSubmitElementName;
6300 },
6301 RemoveDisposedFormsFromCache: function(){
6302  for(var i = 0; this.observableForms && i < this.observableForms.length; i++){
6303   var form = this.observableForms[i];
6304   if(!ASPx.IsExistsElement(form)){
6305    ASPx.Data.ArrayRemove(this.observableForms, form);
6306    i--;
6307   }
6308  }
6309 }
6310});
6311var NetworkError = ASPx.CreateClass(null, {
6312 constructor: function () {
6313  this.message = "Network Error";
6314 }
6315});
6316function aspxRaisePostHandlerOnPost(ownerID, isCallback, isMSAjaxRequest, isDXCallback) {
6317 if(ASPxClientControl.postHandlingLocked) return;
6318 var postHandler = aspxGetPostHandler();
6319 if(postHandler)
6320  postHandler.ProcessPostRequest(ownerID, isCallback, isMSAjaxRequest, isDXCallback);
6321}
6322var aspxPostHandler;
6323function aspxGetPostHandler() {
6324 if(!aspxPostHandler)
6325  aspxPostHandler = new PostHandler();
6326 return aspxPostHandler;
6327}
6328var PostHandlerOnPostEventArgs = ASPx.CreateClass(ASPxClientCancelEventArgs, {
6329 constructor: function(ownerID, isCallback, isMSAjaxCallback, isDXCallback){
6330  this.constructor.prototype.constructor.call(this);
6331  this.ownerID = ownerID;
6332  this.isCallback = !!isCallback;
6333  this.isDXCallback = !!isDXCallback;
6334  this.isMSAjaxCallback = !!isMSAjaxCallback;
6335 }
6336});
6337var ResourceManager = {
6338 HandlerStr: "DXR.axd?r=",
6339 ResourceHashes: {},
6340 SynchronizeResources: function(method){

6341  if(!method){
6342   method = function(name, resource) { 
6343    this.UpdateInputElements(name, resource); 
6344   }.aspxBind(this);
6345  }
6346  var resources = this.GetResourcesData();
6347  for(var name in resources)
6348   if(resources.hasOwnProperty(name))
6349    method(name, resources[name]);
6350 },
6351 GetResourcesData: function(){
6352  return {
6353   DXScript: this.GetResourcesElementsString(_aspxGetIncludeScripts(), "src", "DXScript"),
6354   DXCss: this.GetResourcesElementsString(_aspxGetLinks(), "href", "DXCss")
6355  };
6356 },
6357 ParseBundleSrc: function(elements, urlAttr){
6358  var timeStamp = "";
6359  var resourceUrlArray = [];
6360  for(var i = 0; i < elements.length; i++) {
6361   var resourceUrl = ASPx.Attr.GetAttribute(elements[i], urlAttr);
6362   if(resourceUrl) {
6363    var pos = resourceUrl.indexOf(this.HandlerStr);
6364    if(pos > -1){
6365     var list = resourceUrl.substr(pos + this.HandlerStr.length);
6366     var ampPos = list.lastIndexOf("-");
6367     if(ampPos > -1) {
6368      timeStamp = list.substr(ampPos);
6369      list = list.substr(0, ampPos);
6370     }
6371     var indexes = list.split(",");
6372     for(var j = 0; j < indexes.length; j++) {
6373      resourceUrlArray.push(indexes[j]);
6374     }
6375    }
6376    else
6377     resourceUrlArray.push(resourceUrl);
6378   }
6379  }
6380  return {
6381   'resourceUrlArray': resourceUrlArray,
6382   'timeStamp': timeStamp
6383  };
6384 },
6385 GetResourceHashes: function (id) {
6386  if (!this.ResourceHashes[id])
6387   this.ResourceHashes[id] = {};
6388  return this.ResourceHashes[id];
6389 },
6390 GetResourcesElementsString: function (elements, urlAttr, id) {
6391  var hash = this.GetResourceHashes(id);
6392  var resourceUrlArray = this.ParseBundleSrc(elements, urlAttr).resourceUrlArray;
6393  for(var i = 0; i < resourceUrlArray.length; i++) {
6394   hash[resourceUrlArray[i]] = resourceUrlArray[i];
6395  }
6396  var array = [];
6397  for(var key in hash)
6398   if(hash.hasOwnProperty(key))
6399    array.push(key);
6400  return array.join(",");
6401 },
6402 GetNewResourcesElementString: function (element, urlAttr, id) {
6403  var originalUrl = ASPx.Attr.GetAttribute(element, urlAttr);
6404  var handlerStrIndex = originalUrl.indexOf(this.HandlerStr);
6405  var dxResources = handlerStrIndex > -1;
6406  if(!dxResources) return element[urlAttr];
6407  var hash = this.GetResourceHashes(id);
6408  var srcInfo = this.ParseBundleSrc([element], urlAttr);
6409  var resourceUrlArray = srcInfo.resourceUrlArray;
6410  var timeStamp = srcInfo.timeStamp;
6411  var newResourceArray = [];
6412  for(var i = 0; i < resourceUrlArray.length; i++) {
6413    if(!hash[resourceUrlArray[i]])
6414    newResourceArray.push(resourceUrlArray[i]);
6415  }
6416  var newResources = "";
6417  if(newResourceArray.length > 0) {
6418   var baseUrl = originalUrl.substr(0, handlerStrIndex);
6419   newResources = baseUrl + this.HandlerStr + newResourceArray.join(",") + timeStamp;
6420  }
6421  return newResources;
6422 },
6423 UpdateInputElements: function(typeName, list){
6424  for(var i = 0; i < document.forms.length; i++){
6425   var inputElement = document.forms[i][typeName];
6426   if(!inputElement)
6427    inputElement = this.CreateInputElement(document.forms[i], typeName);
6428   inputElement.value = list;
6429  }
6430 },
6431 CreateInputElement: function(form, typeName){
6432  var inputElement = ASPx.CreateHiddenField(typeName);
6433  form.appendChild(inputElement);
6434  return inputElement;
6435 }
6436};
6437ASPx.includeScriptPrefix = "dxis_";
6438ASPx.startupScriptPrefix = "dxss_";
6439var includeScriptsCache = {};
6440var createdIncludeScripts = [];
6441var appendedScriptsCount = 0;
6442var callbackOwnerNames = [];
6443var scriptsRestartHandlers = { };
6444function _aspxIsKnownIncludeScript(script) {
6445 return !!includeScriptsCache[script.src];
6446}
6447function _aspxCacheIncludeScript(script) {
6448 includeScriptsCache[script.src] = 1;
6449}
6450function _aspxProcessScriptsAndLinks(ownerName, isCallback) {
6451 if(!ASPx.documentLoaded) return; 
6452 _aspxProcessScripts(ownerName, isCallback);
6453 getLinkProcessor().process();
6454 ASPx.ClearCachedCssRules();
6455}
6456function _aspxGetStartupScripts(container) {
6457 return _aspxGetScriptsCore(ASPx.startupScriptPrefix, container);
6458}
6459function _aspxGetIncludeScripts() {
6460 return _aspxGetScriptsCore(ASPx.includeScriptPrefix);
6461}
6462function _aspxGetScriptsCore(prefix, container) {
6463 var result = [];
6464 var scripts;
6465 if(ASPx.IsExists(container))
6466  scripts = ASPx.GetNodesByTagName(container, "SCRIPT");
6467 else

6468  scripts = document.getElementsByTagName("SCRIPT");
6469 for(var i = 0; i < scripts.length; i++) {
6470  if(scripts[i].id.indexOf(prefix) == 0)
6471   result.push(scripts[i]);
6472 }
6473 return result;
6474}
6475function _aspxIsResourceLink(link) {
6476 if(typeof link !== "string")
6477  link = link.href;
6478 return link.toLowerCase().indexOf(ResourceManager.HandlerStr.toLowerCase()) >= 0;
6479}
6480function _aspxGetLinks(allLinks) {
6481 var result = [];
6482 var links = document.getElementsByTagName("LINK");
6483 for(var i = 0; i < links.length; i++) {
6484  if(allLinks || _aspxIsResourceLink(links[i]))
6485   result.push(links[i]);
6486 }
6487 return result;
6488}
6489function _aspxIsLinksLoaded() {
6490 var links = _aspxGetLinks(true);
6491 for(var i = 0, link; link = links[i]; i++)
6492  if(link.readyState && link.readyState.toLowerCase() == "loading")
6493    return false;
6494 return true;
6495}
6496function _aspxInitializeLinks() {
6497 var links = _aspxGetLinks(true);
6498 for(var i = 0; i < links.length; i++)
6499  links[i].loaded = true; 
6500}
6501var scriptExecutedAttrName = "data-executed";
6502var scriptDelayedExecutionAttrName = "data-dx-delayedeval";
6503ASPx.MarkInnerScriptBlocksAsDelayedExecution = function(scriptsContainer) {
6504 var scripts = scriptsContainer.querySelectorAll("script[id^=" + ASPx.startupScriptPrefix + "]");
6505 for(var i = 0; i < scripts.length; i++)
6506  ASPx.Attr.SetAttribute(scripts[i], scriptDelayedExecutionAttrName, true);
6507};
6508function isScriptExecuted(script) {
6509 return ASPx.Attr.GetAttribute(script, scriptExecutedAttrName);
6510}
6511function markScriptAsExecuted(script) {
6512 if(ASPx.Attr.GetAttribute(script, scriptDelayedExecutionAttrName))
6513  ASPx.Attr.RemoveAttribute(script, scriptDelayedExecutionAttrName);
6514 else
6515  ASPx.Attr.SetAttribute(script, scriptExecutedAttrName, true);
6516}
6517function _aspxInitializeScripts() {
6518 var scripts = _aspxGetIncludeScripts();
6519 for(var i = 0; i < scripts.length; i++)
6520  _aspxCacheIncludeScript(scripts[i]);   
6521 var startupScripts = _aspxGetStartupScripts();
6522 for(var i = 0; i < startupScripts.length; i++)
6523  markScriptAsExecuted(startupScripts[i]);
6524}
6525function _aspxSweepDuplicatedLinks() {
6526 var hash = { };
6527 var links = _aspxGetLinks();
6528 for(var i = 0; i < links.length; i++) {
6529  var href = links[i].href;
6530  if(!href)
6531   continue;
6532  if(hash[href]){
6533   if(!hash[href].loaded && links[i].loaded) {
6534    ASPx.RemoveElement(hash[href]);
6535    hash[href] = links[i];
6536   }
6537   else
6538    ASPx.RemoveElement(links[i]);
6539  }
6540  else
6541   hash[href] = links[i];
6542 }
6543}
6544function _aspxSweepDuplicatedScripts() {
6545 var hash = { };
6546 var scripts = _aspxGetIncludeScripts();
6547 for(var i = 0; i < scripts.length; i++) {
6548  var src = scripts[i].src;
6549  if(!src) continue;
6550  if(hash[src])
6551   ASPx.RemoveElement(scripts[i]);
6552  else
6553   hash[src] = scripts[i];
6554 }
6555}
6556function _aspxAreScriptsEqual(script1, script2) {
6557 return script1.src == script2.src;
6558}
6559function _aspxProcessScripts(ownerName, isCallback) {
6560 var scripts = _aspxGetIncludeScripts();
6561 var previousCreatedScript = null;
6562 var firstCreatedScript = null;
6563 for(var i = 0; i < scripts.length; i++) {
6564  var script = scripts[i];
6565  if(script.src == "") continue; 
6566  if(_aspxIsKnownIncludeScript(script))
6567   continue;
6568  var getOnlyNewResources = true;
6569  var onlyNewScripts = ResourceManager.GetNewResourcesElementString(script, "src", "DXScript", getOnlyNewResources);
6570  if (onlyNewScripts == "")
6571   continue;
6572  var createdScript = document.createElement("script");
6573  ASPx.Attr.AppendScriptType(createdScript);
6574  createdScript.src = onlyNewScripts;
6575  createdScript.id = script.id;
6576  if(ASPx.Data.ArrayIndexOf(createdIncludeScripts, createdScript, _aspxAreScriptsEqual) >= 0)
6577   continue;
6578  createdIncludeScripts.push(createdScript);
6579  ASPx.RemoveElement(script);
6580  if(ASPx.Browser.Edge || ASPx.Browser.WebKitFamily || (ASPx.Browser.Firefox && ASPx.Browser.Version >= 4) || ASPx.Browser.IE) {
6581   createdScript.onload = new Function("ASPx.OnScriptLoadCallback(this, " + isCallback + ");");
6582   if(firstCreatedScript == null)
6583    firstCreatedScript = createdScript;
6584   createdScript.nextCreatedScript = null;
6585   if(previousCreatedScript != null)
6586    previousCreatedScript.nextCreatedScript = createdScript;
6587   previousCreatedScript = createdScript;
6588  } else {
6589   createdScript.onload = new Function("ASPx.OnScriptLoadCallback(this);");
6590   ASPx.AppendScript(createdScript);
6591   _aspxCacheIncludeScript(createdScript);
6592  }
6593 }
6594 if(firstCreatedScript != null) {
6595  ASPx.AppendScript(firstCreatedScript);
6596  _aspxCacheIncludeScript(firstCreatedScript);
6597 }
6598 if(isCallback)

6599  callbackOwnerNames.push(ownerName);
6600 if(createdIncludeScripts.length == 0) {
6601  var newLinks = ASPx.GetNodesByTagName(document.body, "link");
6602  var needProcessLinks = isCallback && newLinks.length > 0;
6603  if(needProcessLinks)
6604   needProcessLinks = getLinkProcessor().addLinks(newLinks);
6605  if(!needProcessLinks)
6606   ASPx.FinalizeScriptProcessing(isCallback);
6607 }
6608}
6609ASPx.FinalizeScriptProcessing = function(isCallback) {
6610 createdIncludeScripts = [];
6611 appendedScriptsCount = 0;
6612 var linkProcessor = getLinkProcessor();
6613 if(linkProcessor.hasLinks())
6614  _aspxSweepDuplicatedLinks();
6615 linkProcessor.reset();
6616 _aspxSweepDuplicatedScripts();
6617 ResourceManager.SynchronizeResources();
6618 _aspxRunStartupScripts(isCallback);
6619};
6620var startupScriptsRunning = false;
6621function _aspxRunStartupScripts(isCallback, container) {
6622 startupScriptsRunning = true;
6623 try {
6624  _aspxRunStartupScriptsCore(container);
6625 }
6626 finally {
6627  startupScriptsRunning = false;
6628 }
6629 if(ASPx.documentLoaded) {
6630  ASPx.GetControlCollection().ProcessActionByPredicate(
6631   function(collection) { collection.InitializeElements(isCallback); },
6632   function(control) { return !ASPx.IsExists(container) || ASPx.GetIsParent(container, control.GetMainElement()); }
6633  );
6634  for(var key in scriptsRestartHandlers)
6635   if(scriptsRestartHandlers.hasOwnProperty(key))
6636    scriptsRestartHandlers[key]();
6637  if(isCallback)
6638   _aspxRunEndCallbackScript();
6639 }
6640}
6641function _aspxIsStartupScriptsRunning(isCallback) {
6642 return startupScriptsRunning;
6643}
6644function _aspxRunStartupScriptsCore(container) {
6645 var scripts = _aspxGetStartupScripts(container);
6646 var code;
6647 for(var i = 0; i < scripts.length; i++){
6648  var script = scripts[i];
6649  if(!isScriptExecuted(script)) {
6650   _aspxEnsureStartupScriptIsUnique(script.id); 
6651   code = ASPx.GetScriptCode(script);
6652   eval(code);
6653   markScriptAsExecuted(script);
6654  }
6655 }
6656}
6657function _aspxEnsureStartupScriptIsUnique(scriptId) {
6658 if(!scriptId)
6659  return;
6660 var scriptExecutedSelector = "script[" + scriptExecutedAttrName + "='true']#" + scriptId;
6661 ASPx.RemoveElement(document.querySelector(scriptExecutedSelector));
6662}
6663function _aspxRunEndCallbackScript() {
6664 while(callbackOwnerNames.length > 0) {
6665  var callbackOwnerName = callbackOwnerNames.pop();
6666  var callbackOwner = ASPx.GetControlCollection().Get(callbackOwnerName);
6667  if(callbackOwner)
6668   callbackOwner.DoEndCallback();
6669 }
6670}
6671ASPx.RunStartupScriptsCreatedOnClient = function(container) {
6672 _aspxRunStartupScriptsCore(container);
6673};
6674ASPx.OnScriptReadyStateChangedCallback = function(scriptElement, isCallback) {
6675 if(scriptElement.readyState == "loaded") {
6676  _aspxCacheIncludeScript(scriptElement);
6677  for(var i = 0; i < createdIncludeScripts.length; i++) {
6678   var script = createdIncludeScripts[i];
6679   if(_aspxIsKnownIncludeScript(script)) {
6680    if(!isScriptExecuted(script)) {
6681     markScriptAsExecuted(script);
6682     ASPx.AppendScript(script);
6683     appendedScriptsCount++;
6684    }
6685   } else
6686    break;
6687  }
6688  if(createdIncludeScripts.length == appendedScriptsCount)
6689   ASPx.FinalizeScriptProcessing(isCallback);
6690 }
6691};
6692ASPx.OnScriptLoadCallback = function(scriptElement, isCallback) {
6693 appendedScriptsCount++;
6694 if(scriptElement.nextCreatedScript) {
6695  ASPx.AppendScript(scriptElement.nextCreatedScript);
6696  _aspxCacheIncludeScript(scriptElement.nextCreatedScript);
6697 }
6698 if(createdIncludeScripts.length == appendedScriptsCount)
6699  ASPx.FinalizeScriptProcessing(isCallback);
6700};
6701function _aspxAddScriptsRestartHandler(objectName, handler) {
6702 scriptsRestartHandlers[objectName] = handler;
6703}
6704function _aspxMoveLinkElements() {
6705 var head = ASPx.GetNodesByTagName(document, "head")[0];
6706 var bodyLinks = ASPx.GetNodesByTagName(document.body, "link");
6707 if(head && bodyLinks.length > 0){
6708  var headLinks = ASPx.GetNodesByTagName(head, "link");
6709  var dxLinkAnchor = head.firstChild;
6710  for(var i = 0; i < headLinks.length; i++){
6711   if(_aspxIsResourceLink(headLinks[i]))
6712    dxLinkAnchor = headLinks[i].nextSibling;
6713  }
6714  while(bodyLinks.length > 0) 
6715   head.insertBefore(bodyLinks[0], dxLinkAnchor);
6716 }
6717}
6718var LinkProcessor = ASPx.CreateClass(null, {
6719 constructor: function() {
6720  this.linkInfos = [];
6721  this.loadingObservationTimerID = -1;
6722 },
6723 process: function() {
6724  if(this.hasLinks()) {
6725   if(this.isLinkLoadEventSupported())
6726    this.processViaLoadEvent();
6727   else
6728    this.processViaTimer();
6729  }
6730  else
6731   _aspxSweepDuplicatedLinks();

6732  _aspxMoveLinkElements();
6733 },
6734 addLinks: function(links) {
6735  var prevLinkCount = this.linkInfos.length;
6736  for(var i = 0; i < links.length; i++) {
6737   var link = links[i];
6738   if(link.loaded || link.rel != "stylesheet" || !_aspxIsResourceLink(link))
6739    continue;
6740   var linkInfo = {
6741    link: link,
6742    href: link.href
6743   };
6744   this.linkInfos.push(linkInfo);
6745  }
6746  return prevLinkCount != this.linkInfos.length;
6747 },
6748 hasLinks: function() {
6749  return this.linkInfos.length > 0;
6750 },
6751 reset: function() {
6752  this.linkInfos = [];
6753 },
6754 processViaLoadEvent: function() {
6755  for(var i = 0, linkInfo; linkInfo = this.linkInfos[i]; i++)
6756   linkInfo.link.onload = this.onLinkLoad.bind(this);
6757 },
6758 isLinkLoadEventSupported: function() {
6759  return !(ASPx.Browser.Chrome && ASPx.Browser.MajorVersion < 19 || ASPx.Browser.Firefox && ASPx.Browser.MajorVersion < 9 ||
6760   ASPx.Browser.Safari && ASPx.Browser.MajorVersion < 6 || ASPx.Browser.AndroidDefaultBrowser && ASPx.Browser.MajorVersion < 4.4);
6761 },
6762 processViaTimer: function() {
6763  if(this.loadingObservationTimerID == -1)
6764   this.onLinksLoadingObserve();
6765 },
6766 onLinksLoadingObserve: function() {
6767  if(this.getIsAllLinksLoaded()) {
6768   this.loadingObservationTimerID = -1;
6769   this.onAllLinksLoad();
6770  }
6771  else
6772   this.loadingObservationTimerID = window.setTimeout(this.onLinksLoadingObserve.aspxBind(this), 100);
6773 },
6774 getIsAllLinksLoaded: function() {
6775  var styleSheets = document.styleSheets;
6776  var loadedLinkHrefs = { };
6777  for(var i = 0; i < styleSheets.length; i++) {
6778   var styleSheet = styleSheets[i];
6779   try {
6780    if(styleSheet.cssRules)
6781     loadedLinkHrefs[styleSheet.href] = 1;
6782   }
6783   catch(ex) { }
6784  }
6785  var loadedLinksCount = 0;
6786  for(var i = 0, linkInfo; linkInfo = this.linkInfos[i]; i++) {
6787   if(loadedLinkHrefs[linkInfo.href])
6788    loadedLinksCount++;
6789  }
6790  return loadedLinksCount == this.linkInfos.length;
6791 },
6792 onAllLinksLoad: function() {
6793  this.reset();
6794  _aspxSweepDuplicatedLinks();
6795  if(createdIncludeScripts.length == 0)
6796   ASPx.FinalizeScriptProcessing(true);
6797 },
6798 onLinkReadyStateChanged: function(linkElement) {
6799  if(linkElement.readyState == "complete")
6800   this.onLinkLoadCore(linkElement);
6801 },
6802 onLinkLoad: function(evt) {
6803  var linkElement = ASPx.Evt.GetEventSource(evt);
6804  this.onLinkLoadCore(linkElement);
6805 },
6806 onLinkLoadCore: function(linkElement) {
6807  var linkInfo = this.getLinkInfo(linkElement);
6808  if(!linkInfo) return;
6809  linkInfo.loaded = true;
6810  var notLoadedLinks = this.linkInfos.filter(function(info) { return !info.loaded; });
6811  if(notLoadedLinks.length == 0)
6812   this.onAllLinksLoad();
6813 },
6814 getLinkInfo: function(linkElement) {
6815  for(var i = 0, linkInfo; linkInfo = this.linkInfos[i]; i++) {
6816   if(linkInfo.link == linkElement)
6817    return linkInfo;
6818  }
6819 }
6820});
6821var linkProcessor = null;
6822function getLinkProcessor() {
6823 if(linkProcessor == null)
6824  linkProcessor = new LinkProcessor();
6825 return linkProcessor;
6826}
6827ASPx.LinkProcessor = LinkProcessor;
6828var IFrameHelper = ASPx.CreateClass(null, {
6829 constructor: function(params) {
6830  this.params = params || {};
6831  this.params.src = this.params.src || "";
6832  this.CreateElements();
6833 },
6834 CreateElements: function() {
6835  var elements = IFrameHelper.Create(this.params);
6836  this.containerElement = elements.container;
6837  this.iframeElement = elements.iframe;
6838  this.AttachOnLoadHandler(this, this.iframeElement);
6839  this.SetLoading(true);
6840  if(this.params.onCreate)
6841   this.params.onCreate(this.containerElement, this.iframeElement);
6842 },
6843 AttachOnLoadHandler: function(instance, element) {
6844  ASPx.Evt.AttachEventToElement(element, "load", function() {
6845   instance.OnLoad(element);
6846  });
6847 },
6848 OnLoad: function(element) {
6849  this.SetLoading(false, element);
6850  if(!element.preventCustomOnLoad && this.params.onLoad)
6851   this.params.onLoad();
6852 },
6853 IsLoading: function(element) {
6854  element = element || this.iframeElement;
6855  if(element)
6856   return element.loading;
6857  return false;
6858 },
6859 SetLoading: function(value, element) {
6860  element = element || this.iframeElement;
6861  if(element)
6862   element.loading = value;
6863 },
6864 GetContentUrl: function() {
6865  return this.params.src;
6866 },
6867 SetContentUrl: function(url, preventBrowserCaching) {
6868  if(url) {
6869   this.params.src = url;
6870   if(preventBrowserCaching)
6871    url = IFrameHelper.AddRandomParamToUrl(url);

6872   this.SetLoading(true);
6873   this.iframeElement.src = url;
6874  }
6875 },
6876 RefreshContentUrl: function() {
6877  if(this.IsLoading())
6878   return;
6879  this.SetLoading(true);
6880  var oldContainerElement = this.containerElement;
6881  var oldIframeElement = this.iframeElement;
6882  var postfix = "_del" + Math.floor(Math.random()*100000).toString();
6883  if(this.params.id)
6884   oldIframeElement.id = this.params.id + postfix;
6885  if(this.params.name)
6886   oldIframeElement.name = this.params.name + postfix;
6887  ASPx.SetStyles(oldContainerElement, { height: 0 });
6888  this.CreateElements();
6889  oldIframeElement.preventCustomOnLoad = true;
6890  oldIframeElement.src = ASPx.BlankUrl;
6891  window.setTimeout(function() {
6892   oldContainerElement.parentNode.removeChild(oldContainerElement);
6893  }, 10000); 
6894 }
6895});
6896IFrameHelper.Create = function(params) {
6897 var iframeHtmlStringParts = [ "<iframe frameborder='0'" ];
6898 if(params) {
6899  if(params.id)
6900   iframeHtmlStringParts.push(" id='", params.id, "'");
6901  if(params.name)
6902   iframeHtmlStringParts.push(" name='", params.name, "'");
6903  if(params.title)
6904   iframeHtmlStringParts.push(" title='", params.title, "'");
6905  if(params.scrolling)
6906   iframeHtmlStringParts.push(" scrolling='", params.scrolling, "'");
6907  if(params.src)
6908   iframeHtmlStringParts.push(" src='", params.src, "'");
6909 }
6910 iframeHtmlStringParts.push("></iframe>");
6911 var containerElement = ASPx.CreateHtmlElementFromString("<div style='border-width: 0px; padding: 0px; margin: 0px'></div>");
6912 var iframeElement = ASPx.CreateHtmlElementFromString(iframeHtmlStringParts.join(""));
6913 containerElement.appendChild(iframeElement);
6914 return {
6915  container: containerElement,
6916  iframe: iframeElement
6917 };
6918};
6919IFrameHelper.AddRandomParamToUrl = function(url) {
6920 var prefix = url.indexOf("?") > -1
6921  ? "&"
6922  : "?";
6923 var param = prefix + Math.floor(Math.random()*100000).toString();
6924 var anchorIndex = url.indexOf("#");
6925 return anchorIndex == -1
6926  ? url + param
6927  : url.substr(0, anchorIndex) + param + url.substr(anchorIndex);
6928};
6929IFrameHelper.GetWindow = function(name) {
6930 var frameElement = document.getElementById(name);
6931 return (frameElement != null) ? frameElement.contentWindow : null;
6932};
6933IFrameHelper.GetDocument = function(name) {
6934 var frameElement = document.getElementById(name);
6935 return (frameElement != null) ? frameElement.contentDocument : null;
6936};
6937IFrameHelper.GetDocumentBody = function(name) {
6938 var doc = IFrameHelper.GetDocument(name);
6939 return (doc != null) ? doc.body : null;
6940};
6941IFrameHelper.GetDocumentHead = function (name) {
6942 var doc = IFrameHelper.GetDocument(name);
6943 return (doc != null) ? doc.head || doc.getElementsByTagName('head')[0] : null;
6944};
6945IFrameHelper.GetElement = function(name) {
6946 return document.getElementById(name);
6947};
6948var KbdHelper = ASPx.CreateClass(null, {
6949 constructor: function(control) {
6950  this.control = control;
6951  this.ready = false;
6952  this.clickHandler = this.HandleClick.bind(this);
6953  this.focusHandler = this.onElementFocus.bind(this);
6954  this.blurHandler = this.onBlur.bind(this);
6955 },
6956 Init: function() {
6957  if(!this.ready){
6958   KbdHelper.GlobalInit();
6959   var elements = this.getFocusableElements();
6960   for(var i = 0; i < elements.length; i++) {
6961    var element = elements[i];
6962    element.tabIndex = Math.max(element.tabIndex, 0);
6963    ASPx.Evt.AttachEventToElement(element, "click", this.clickHandler);
6964    ASPx.Evt.AttachEventToElement(element, "focus", this.focusHandler);
6965    ASPx.Evt.AttachEventToElement(element, "blur", this.blurHandler);
6966   }
6967   this.ready = true;
6968  }
6969 },
6970 Dispose: function() {
6971  if(this.ready) {
6972   var elements = this.getFocusableElements();
6973   for(var i = 0; i < elements.length; i++) {
6974    var element = elements[i];
6975    element.tabIndex = -1;
6976    ASPx.Evt.DetachEventFromElement(element, "click", this.clickHandler);
6977    ASPx.Evt.DetachEventFromElement(element, "focus", this.focusHandler);
6978    ASPx.Evt.DetachEventFromElement(element, "blur", this.blurHandler);
6979   }
6980   this.ready = false;
6981  }
6982 },
6983 onElementFocus: function(e) {
6984  if(!this.CanFocus(e))
6985   return true;
6986  KbdHelper.active = this;
6987 },
6988 getFocusableElements: function() {
6989  return [this.GetFocusableElement()]; 
6990 },
6991 GetFocusableElement: function() { return this.control.GetMainElement(); },
6992 canHandleNoFocusAction: function() { 
6993  var focusableElements = this.getFocusableElements();
6994  for(var i = 0; i < focusableElements.length; i++) {
6995   if(focusableElements[i] === _aspxGetFocusedElement())
6996    return false;
6997  }
6998  return true;
6999 },
7000 RequirePreventScrollOnFocus: function() { return false; },
7001 CanFocus: function(e) {
7002  var tag = ASPx.Evt.GetEventSource(e).tagName;
7003  return !(tag === "A" || tag === "TEXTAREA" || tag === "INPUT" || tag === "SELECT" || tag === "IFRAME" || tag === "OBJECT");
7004 },
7005 HandleClick: function(e) {
7006  if(!this.CanFocus(e))
7007   return;
7008  this.Focus();
7009 },
7010 Focus: function() {
7011  var preventScroll = this.RequirePreventScrollOnFocus();
7012  var savedDocumentScrollTop = preventScroll ? ASPx.GetDocumentScrollTop() : -1;
7013  try {
7014   this.GetFocusableElement().focus({ preventScroll: preventScroll });
7015  } catch(e) { }
7016  if(preventScroll && !this.IsNativePreventScrollOnFocusSupported() && savedDocumentScrollTop !== ASPx.GetDocumentScrollTop())
7017   ASPx.SetDocumentScrollTop(savedDocumentScrollTop);
7018 },
7019 IsNativePreventScrollOnFocusSupported: function() {
7020  if(this.isNativePreventScrollOnFocusSupported === undefined)
7021   this.isNativePreventScrollOnFocusSupported = this.CalcIsNativePreventScrollOnFocusSupported();
7022  return this.isNativePreventScrollOnFocusSupported;
7023 },
7024 CalcIsNativePreventScrollOnFocusSupported: function() {
7025  var result = false;
7026  try {
7027   ASPx.GetActiveElement().focus(Object.defineProperty({}, "preventScroll", { get: function() { result = true; } }));
7028  } catch(e) { result = false; }
7029  return result;
7030 },
7031 onBlur: function(){
7032  delete KbdHelper.active;
7033 },
7034 HandleKeyDown: function(e) { }, 
7035 HandleKeyPress: function(e) { }, 
7036 HandleKeyUp: function (e) { },
7037 HandleNoFocusAction: function(e) { },
7038 FocusByAccessKey: function () { }
7039});
7040KbdHelper.GlobalInit = function() {
7041 if(KbdHelper.ready)
7042  return;
7043 ASPx.Evt.AttachEventToDocument("keydown", KbdHelper.OnKeyDown);
7044 ASPx.Evt.AttachEventToDocument("keypress", KbdHelper.OnKeyPress);
7045 ASPx.Evt.AttachEventToDocument("keyup", KbdHelper.OnKeyUp);
7046 KbdHelper.ready = true; 
7047};
7048KbdHelper.swallowKey = false;
7049KbdHelper.accessKeys = { };
7050KbdHelper.ProcessKey = function(e, actionName) {
7051 if(!KbdHelper.active) 
7052  return;
7053 if (KbdHelper.active.canHandleNoFocusAction()) {
7054  KbdHelper.active["HandleNoFocusAction"](e, actionName);
7055  return;
7056 }
7057 var ctl = KbdHelper.active.control;
7058 if(ctl !== ASPx.GetControlCollection().Get(ctl.name)) {
7059  delete KbdHelper.active;
7060  return;
7061 }
7062 if(!KbdHelper.swallowKey) 
7063  KbdHelper.swallowKey = KbdHelper.active[actionName](e);
7064 if(KbdHelper.swallowKey)
7065  ASPx.Evt.PreventEvent(e);
7066};

7067KbdHelper.OnKeyDown = function(e) {
7068 KbdHelper.swallowKey = false;
7069 if(KbdHelper.TryAccessKey(KbdHelper.getKeyName(e)))
7070  ASPx.Evt.PreventEvent(e);
7071 else 
7072  KbdHelper.ProcessKey(e, "HandleKeyDown"); 
7073};
7074KbdHelper.OnKeyPress = function(e) { KbdHelper.ProcessKey(e, "HandleKeyPress"); };
7075KbdHelper.OnKeyUp = function(e) { KbdHelper.ProcessKey(e, "HandleKeyUp"); };
7076KbdHelper.RegisterAccessKey = function(obj) {
7077 var key;
7078 if(obj.accessKey)
7079  key = "CtrlShift" + obj.accessKey;
7080 else if(obj.keyTipModeShortcut)
7081  key = obj.keyTipModeShortcut;
7082 if(!key) return;
7083 KbdHelper.accessKeys[key.toLowerCase()] = obj.name;
7084};
7085KbdHelper.TryAccessKey = function(code) {
7086 var key = code.toLowerCase ? code.toLowerCase() : String.fromCharCode(code).toLowerCase();
7087 var name = KbdHelper.accessKeys[key];
7088 if(!name) return false;
7089 var obj = ASPx.GetControlCollection().Get(name);
7090 return KbdHelper.ClickAccessKey(obj);
7091};
7092KbdHelper.ClickAccessKey = function (control) {
7093 if (!control) return false;
7094 var el = control.GetMainElement();
7095 if (!el) return false;
7096 el.focus();
7097 setTimeout(function () {
7098  if (KbdHelper.active && KbdHelper.active.FocusByAccessKey)
7099   KbdHelper.active.FocusByAccessKey();
7100 }.aspxBind(this), ASPx.FOCUS_TIMEOUT);
7101 return true;
7102};
7103KbdHelper.getKeyName = function(e) {
7104 var name = "";
7105 if(e.altKey)
7106  name += "Alt";
7107 if(e.ctrlKey)
7108  name += "Ctrl";
7109 if(e.shiftKey)
7110  name += "Shift";
7111 var keyCode = e.key || e.code || String.fromCharCode(ASPx.Evt.GetKeyCode(e));
7112 if(keyCode.match(/key/i))
7113  name += keyCode.replace(/key/i, "");
7114 else if(keyCode.match(/digit/i))
7115  name += keyCode.replace(/digit/i, "");
7116 else if(keyCode.match(/arrow/i))
7117  name += keyCode.replace(/arrow/i, "");
7118 else if(keyCode.match(/ins/i))
7119  name += "Ins";
7120 else if(keyCode.match(/del/i))
7121  name += "Del";
7122 else if(keyCode.match(/back/i))
7123  name += "Back";
7124 else if(!keyCode.match(/alt/i) && !keyCode.match(/control/i) && !keyCode.match(/shift/i))
7125  name += keyCode;
7126 return name.replace(/^a-zA-Z0-9/, "");
7127};
7128AccessKeysHelper = ASPx.CreateClass(KbdHelper, {
7129 constructor: function (control) {
7130  this.constructor.prototype.constructor.call(this, control);
7131  this.accessKeysVisible = false;
7132  this.activeKey = null;
7133  this.accessKey = control.createAccessKey ? control.createAccessKey(control.accessKey) : new AccessKey(control.accessKey);
7134  this.accessKeys = this.accessKey.accessKeys;
7135  this.charIndex = 0;
7136  this.onFocusByAccessKey = null;
7137  this.onClose = null;
7138  this.manualStopProcessing = false;
7139  this.isActive = false;
7140  this.areAccessKeysShown = false;
7141 },
7142 Init: function (control) {
7143  KbdHelper.prototype.Init.call(this);
7144  KbdHelper.RegisterAccessKey(control);   
7145 },
7146 Add: function (accessKey) {
7147  this.accessKey.Add(accessKey);
7148 },
7149 HandleKeyDown: function (e) {
7150  var keyCode = ASPx.Evt.GetKeyCode(e);
7151  var stopProcessing = this.processKeyDown(keyCode);
7152  if (stopProcessing.value) {
7153   this.stopProcessing();
7154   if(this.onClosedOnEscape && (keyCode == ASPx.Key.Esc || stopProcessing.fireEvent))
7155    this.onClosedOnEscape();
7156  }
7157  return stopProcessing;
7158 },
7159 HandleNoFocusAction: function (e, actionName) {
7160  var keyCode = ASPx.Evt.GetKeyCode(e);
7161  if (this.onClosedOnEscape && keyCode == ASPx.Key.Esc && actionName == "HandleKeyDown")
7162   this.onClosedOnEscape();
7163 },
7164 Activate: function () {
7165  KbdHelper.ClickAccessKey(this.control);
7166  this.areAccessKeysShown = true;
7167 },
7168 Stop: function() {
7169  this.stopProcessing();
7170 },
7171 stopProcessing: function () {
7172  this.HideAccessKeys();
7173  if (KbdHelper.active && this.isActive) {
7174   this.isActive = false;
7175   KbdHelper.active.control.GetMainElement().blur();
7176   delete KbdHelper.active;
7177  }
7178 },
7179 onBlur: function() {
7180  if (this.manualStopProcessing) {
7181   this.manualStopProcessing = false;
7182   return;
7183  }
7184  this.HideAccessKeys();
7185  KbdHelper.prototype.onBlur.call(this);
7186 },
7187 processKeyDown: function (keyCode) {
7188  switch (keyCode) {
7189   case ASPx.Key.Left:
7190    this.TryMoveFocusLeft();
7191    return { value: false };
7192   case ASPx.Key.Right:
7193    this.TryMoveFocusRight();
7194    return { value: false };
7195   case ASPx.Key.Esc:
7196    if(this.control.hideAllPopups)
7197     this.control.hideAllPopups(true, true);
7198    if(this.activeKey)
7199     this.activeKey = this.activeKey.Return();
7200    this.charIndex = 0;
7201    if (!this.activeKey)
7202     return { value: true };
7203    break;
7204   case ASPx.Key.Enter:
7205    return { value: true };
7206   default:
7207    if (!ASPx.IsPrintableKey(keyCode))
7208     return { value: false };
7209    var char = String.fromCharCode(keyCode).toUpperCase();
7210    var needToContinue = { value: false };
7211    var keyResult;
7212    if(this.activeKey)

7213     keyResult = this.activeKey.TryAccessKey(char, this.charIndex, needToContinue);
7214    if (needToContinue.value) {
7215     this.charIndex++;
7216     return { value: false };
7217    }
7218    this.charIndex = 0;
7219    if(keyResult !== undefined)
7220     this.activeKey = keyResult;
7221    else
7222     return { value: true, fireEvent: true };
7223    if (!this.activeKey || !this.activeKey.accessKeys || this.activeKey.accessKeys.length == 0) {
7224     if (this.activeKey && this.activeKey.manualStopProcessing) {
7225      this.manualStopProcessing = true;
7226      break;
7227     }
7228     return { value: true, fireEvent: true };
7229    }
7230  }
7231  return { value: false };
7232 },
7233 TryMoveFocusLeft: function (modifier) {},
7234 TryMoveFocusRight: function (modifier) {},
7235 TryMoveFocusUp: function (modifier) {},
7236 TryMoveFocusDown: function (modifier) {},
7237 FocusByAccessKey: function() {
7238  if (this.onFocusByAccessKey)
7239   this.onFocusByAccessKey();
7240  this.HideAccessKeys();
7241  KbdHelper.prototype.FocusByAccessKey.call(this);
7242  this.activeKey = this.accessKey;
7243  this.activeKey.execute();
7244  this.isActive = true;
7245  this.areAccessKeysShown = true;
7246 },
7247 HideAccessKeys: function() {
7248  this.areAccessKeysShown = false;
7249  this.hideAccessKeys(this.accessKey);
7250 },
7251 Update: function() {
7252  this.throttleMethod(this.refresh, 100);
7253 },
7254 refresh: function() {
7255  if(this.activeKey && this.areAccessKeysShown) {
7256   this.activeKey.execute();
7257  }
7258 },
7259 throttleMethod: function(method, delay) {
7260  clearTimeout(method.timerId);
7261  method.timerId = setTimeout(function() {
7262   method.call(this);
7263  }.aspxBind(this), delay);
7264 },
7265 AreAccessKeysShown: function() {
7266  return this.areAccessKeysShown;
7267 },
7268 hideAccessKeys: function (accessKey) {
7269  for (var i = 0, ak; ak = accessKey.accessKeys[i]; i++) {
7270   this.hideAccessKeys(ak);
7271  }
7272  if (accessKey)
7273   accessKey.hide();
7274 },
7275 HandleClick: function(e) {
7276  KbdHelper.prototype.HandleClick.call(this, e);
7277  this.stopProcessing();
7278 }
7279});
7280AccessKey = ASPx.CreateClass(null, {
7281 constructor: function (popupItem, getPopupElement, keyTipElement, key, onlyClick, manualStopProcessing) {
7282  this.key = key ? key : keyTipElement ? ASPxClientUtils.Trim(ASPx.GetInnerText(keyTipElement)) : null;
7283  this.popupItem = popupItem;
7284  this.getPopupElement = getPopupElement;
7285  this.keyTipElement = keyTipElement;
7286  this.accessKeys = [];
7287  this.needShowChilds = true;
7288  this.parent = null;
7289  this.onlyClick = onlyClick;
7290  this.manualStopProcessing = manualStopProcessing;
7291 },
7292 Add: function (accessKey) {
7293  this.accessKeys.push(accessKey);
7294  accessKey.parent = this;
7295 },
7296 TryAccessKey: function (char, index, needToContinue) {
7297  if (!this.accessKeys || this.accessKeys.length == 0)
7298   return;
7299  for (var i = 0, accessKey; accessKey = this.accessKeys[i]; i++) {
7300   if (accessKey.key[index] == char && accessKey.isVisible()) {
7301    if (accessKey.key[index + 1]) {
7302     needToContinue.value = true;
7303    }
7304    else {
7305     accessKey.execute();
7306     return accessKey;
7307    }
7308   } else {
7309    accessKey.hide();
7310   }
7311  }
7312  for (var i = 0, accessKey; accessKey = this.accessKeys[i]; i++) {
7313   var key = accessKey.TryAccessKey(char, index, needToContinue);
7314   if (key)
7315    return key;
7316  }
7317  return;
7318 },
7319 isVisible: function(){
7320  return ASPx.GetElementVisibility(this.keyTipElement);
7321 },
7322 Return: function () {
7323  this.hideChildAccessKeys();
7324  if (this.parent) {
7325   this.parent.showAccessKeys(true);
7326  }  
7327  return this.parent;
7328 },
7329 execute: function () {
7330  this.hideAll();
7331  if (this.popupItem && this.popupItem.accessKeyClick && !this.onlyClick)
7332   this.popupItem.accessKeyClick();
7333  if (this.getPopupElement && this.onlyClick)
7334   ASPx.Evt.EmulateMouseClick(this.getPopupElement(this.popupItem));
7335  if (this.accessKeys)
7336   setTimeout(function () {
7337    this.showAccessKeys(true);
7338   }.aspxBind(this), 100);
7339 },
7340 showAccessKeys: function(directShow) {
7341  if (!directShow && !this.needShowChilds)
7342   return;
7343  for (var i = 0; i < this.accessKeys.length; i++) {
7344   var accessKey = this.accessKeys[i];
7345   if (accessKey) {
7346    var popupElement = accessKey.getPopupElement ? accessKey.getPopupElement(accessKey.popupItem) : null;
7347    if (popupElement && this.isElementVisible(popupElement)) {
7348     this.show(accessKey);
7349    }
7350    accessKey.showAccessKeys();
7351   }
7352  }
7353 },
7354 isElementVisible: function (el) { return ASPx.IsElementVisible(el, true); },
7355 show: function(accessKey) {
7356  var keyTipElement = accessKey.keyTipElement;
7357  var popupElement = accessKey.getPopupElement(accessKey.popupItem);
7358  this.showKeyTipElement(keyTipElement, this.calculateCoordinates(accessKey, keyTipElement, popupElement));
7359 },
7360 showKeyTipElement: function (keyTipElement, coordinates) {
7361  ASPx.SetAbsoluteY(keyTipElement, coordinates.top);
7362  ASPx.SetAbsoluteX(keyTipElement, coordinates.left);
7363  ASPx.SetElementVisibility(keyTipElement, true); 
7364 },
7365 calculateCoordinates: function (accessKey, keyTipElement, popupElement) {
7366  var top = ASPx.GetAbsolutePositionY(popupElement);
7367  var left = ASPx.GetAbsolutePositionX(popupElement);
7368  if (accessKey.popupItem.getAccessKeyPosition)
7369   switch (accessKey.popupItem.getAccessKeyPosition()) {
7370    case "AboveRight":
7371     left = left + popupElement.offsetWidth - keyTipElement.offsetWidth / 3;
7372     top = top - keyTipElement.offsetHeight / 2;
7373     break;
7374    case "Right":
7375     left = left + popupElement.offsetWidth - keyTipElement.offsetWidth / 3;

7376     top = top + popupElement.offsetHeight / 2 - keyTipElement.offsetHeight / 2;
7377     break;
7378    case "BelowRight":
7379     left = left + popupElement.offsetWidth - keyTipElement.offsetWidth / 3;
7380     top = top + keyTipElement.offsetHeight / 2;
7381     break;
7382    default:
7383     top = top + popupElement.offsetHeight;
7384     left = left + popupElement.offsetWidth / 2 - keyTipElement.offsetWidth / 2;
7385     break;
7386   }
7387  else {
7388   top = top + popupElement.offsetHeight;
7389   left = left + popupElement.offsetWidth / 2 - keyTipElement.offsetWidth / 2;
7390  }
7391  return { top: top, left: left };
7392 },
7393 hide: function() {
7394  if (this.keyTipElement)
7395   ASPx.SetElementVisibility(this.keyTipElement, false);
7396 },
7397 hideChildAccessKeys: function () {
7398  this.hideAccessKeys(this.accessKeys);
7399 },
7400 hideAccessKeys: function (accessKeys) {
7401  if (accessKeys) {
7402   for (var i = 0, accessKey; accessKey = accessKeys[i]; i++) {
7403    if (accessKey.keyTipElement)
7404     accessKey.hide();
7405    accessKey.hideChildAccessKeys();
7406   }
7407  }
7408 },
7409 hideAll: function () {
7410  this.getRoot(this).hideChildAccessKeys();
7411 },
7412 getRoot: function (accessKey) {
7413  if (!accessKey.parent)
7414   return accessKey;
7415  return this.getRoot(accessKey.parent);
7416 }
7417});
7418var focusedElement = null;
7419function aspxOnElementFocused(evt) {
7420 evt = ASPx.Evt.GetEvent(evt);
7421 if(evt && evt.target)
7422  focusedElement = evt.target;
7423}
7424function _aspxInitializeFocus() {
7425 if(!ASPx.GetActiveElement())
7426  ASPx.Evt.AttachEventToDocument("focus", aspxOnElementFocused);
7427}
7428function _aspxGetFocusedElement() {
7429 var activeElement = ASPx.GetActiveElement();
7430 return activeElement ? activeElement : focusedElement;
7431}
7432CheckBoxCheckState = {
7433 Checked : "Checked",
7434 Unchecked : "Unchecked",
7435 Indeterminate : "Indeterminate"
7436};
7437CheckBoxInputKey = { 
7438 Checked : "C",
7439 Unchecked : "U",
7440 Indeterminate : "I"
7441};
7442var CheckableElementStateController = ASPx.CreateClass(null, {
7443 constructor: function(imageProperties) {
7444  this.checkBoxStates = [];
7445  this.imageProperties = imageProperties;
7446  this.customImageMarkerClassName = "dxcbCI";
7447 },
7448 GetValueByInputKey: function(inputKey) {
7449  return this.GetFirstValueBySecondValue("Value", "StateInputKey", inputKey);
7450 },
7451 GetInputKeyByValue: function(value) {
7452  return this.GetFirstValueBySecondValue("StateInputKey", "Value", value);
7453 },
7454 GetImagePropertiesNumByInputKey: function(value) {
7455  return this.GetFirstValueBySecondValue("ImagePropertiesNumber", "StateInputKey", value);
7456 },
7457 GetNextCheckBoxValue: function(currentValue, allowGrayed) {
7458  var currentInputKey = this.GetInputKeyByValue(currentValue);
7459  var nextInputKey = '';
7460  switch(currentInputKey) {
7461   case CheckBoxInputKey.Checked:
7462    nextInputKey = CheckBoxInputKey.Unchecked; break;
7463   case CheckBoxInputKey.Unchecked:
7464    nextInputKey = allowGrayed ? CheckBoxInputKey.Indeterminate : CheckBoxInputKey.Checked; break;
7465   case CheckBoxInputKey.Indeterminate:
7466    nextInputKey = CheckBoxInputKey.Checked; break;
7467  }
7468  return this.GetValueByInputKey(nextInputKey);
7469 },
7470 GetCheckStateByInputKey: function(inputKey) {
7471  switch(inputKey) {
7472   case CheckBoxInputKey.Checked: 
7473    return CheckBoxCheckState.Checked;
7474   case CheckBoxInputKey.Unchecked: 
7475    return CheckBoxCheckState.Unchecked;
7476   case CheckBoxInputKey.Indeterminate: 
7477    return CheckBoxCheckState.Indeterminate;
7478  }
7479 },
7480 GetValueByCheckState: function(checkState) {
7481  switch(checkState) {
7482   case CheckBoxCheckState.Checked: 
7483    return this.GetValueByInputKey(CheckBoxInputKey.Checked);
7484   case CheckBoxCheckState.Unchecked: 
7485    return this.GetValueByInputKey(CheckBoxInputKey.Unchecked);
7486   case CheckBoxCheckState.Indeterminate: 
7487    return this.GetValueByInputKey(CheckBoxInputKey.Indeterminate);
7488  }
7489 },
7490 GetFirstValueBySecondValue: function(firstValueName, secondValueName, secondValue) {
7491  return this.GetValueByFunc(firstValueName, 
7492   function(checkBoxState) { return checkBoxState[secondValueName] === secondValue; });
7493 },
7494 GetValueByFunc: function(valueName, func) {
7495  for(var i = 0; i < this.checkBoxStates.length; i++) {
7496   if(func(this.checkBoxStates[i]))
7497    return this.checkBoxStates[i][valueName];
7498  }  
7499 },
7500 AssignElementClassName: function(element, cssClassPropertyKey, disabledCssClassPropertyKey, assignedClassName) {
7501  var classNames = [ ];
7502  for(var i = 0; i < this.imageProperties[cssClassPropertyKey].length; i++) {
7503   classNames.push(this.imageProperties[disabledCssClassPropertyKey][i]);
7504   classNames.push(this.imageProperties[cssClassPropertyKey][i]);
7505  }
7506  var elementClassName = element.className;
7507  for(var i = 0; i < classNames.length; i++) {
7508   var className = classNames[i];
7509   var index = elementClassName.indexOf(className);
7510   if(index > -1)
7511    elementClassName = elementClassName.replace((index == 0 ? '' : ' ') + className, "");
7512  }
7513  elementClassName += " " + assignedClassName;
7514  element.className = elementClassName;
7515 },
7516 UpdateInternalCheckBoxDecoration: function(mainElement, inputKey, enabled) {
7517  var imagePropertiesNumber = this.GetImagePropertiesNumByInputKey(inputKey);
7518  for(var imagePropertyKey in this.imageProperties) {
7519   if(this.imageProperties.hasOwnProperty(imagePropertyKey)) {
7520    var propertyValue = this.imageProperties[imagePropertyKey][imagePropertiesNumber];
7521    propertyValue = propertyValue || !isNaN(propertyValue) ? propertyValue : "";
7522    switch(imagePropertyKey) {

7523     case "0" : mainElement.title = propertyValue; break;
7524     case "1" : mainElement.style.width = propertyValue + (propertyValue != "" ? "px" : ""); break;
7525     case "2" : mainElement.style.height = propertyValue + (propertyValue != "" ? "px" : ""); break;
7526    }
7527    if(enabled) {
7528     switch(imagePropertyKey) {
7529      case "3" : this.SetImageSrc(mainElement, propertyValue); break;
7530      case "4" : 
7531       this.AssignElementClassName(mainElement, "4", "8", propertyValue);
7532       break;
7533      case "5" : this.SetBackgroundPosition(mainElement, propertyValue, true); break;
7534      case "6" : this.SetBackgroundPosition(mainElement, propertyValue, false); break;
7535     }
7536    } else {
7537     switch(imagePropertyKey) {
7538      case "7" : this.SetImageSrc(mainElement, propertyValue); break;
7539      case "8" : 
7540       this.AssignElementClassName(mainElement, "4", "8", propertyValue);
7541       break;
7542      case "9" : this.SetBackgroundPosition(mainElement, propertyValue, true); break;
7543      case "10" : this.SetBackgroundPosition(mainElement, propertyValue, false); break;
7544     }
7545    }
7546   }
7547  }
7548 },
7549 SetImageSrc: function(mainElement, src) {
7550  if(src === ""){
7551   mainElement.style.backgroundImage = "";
7552   mainElement.style.backgroundPosition = "";
7553   ASPx.RemoveClassNameFromElement(mainElement, this.customImageMarkerClassName);
7554  }
7555  else{
7556   mainElement.style.backgroundImage = "url('" + src + "')";
7557   this.SetBackgroundPosition(mainElement, 0, true);
7558   this.SetBackgroundPosition(mainElement, 0, false);
7559   ASPx.AddClassNameToElement(mainElement, this.customImageMarkerClassName);
7560  }
7561 },
7562 SetBackgroundPosition: function(element, value, isX) {
7563  if(value === "") {
7564   element.style.backgroundPosition = value;
7565   return;
7566  }
7567  if(element.style.backgroundPosition === "")
7568   element.style.backgroundPosition = isX ? "-" + value.toString() + "px 0px" : "0px -" + value.toString() + "px";
7569  else {
7570   var position = element.style.backgroundPosition.split(' ');
7571   element.style.backgroundPosition = isX ? '-' + value.toString() + "px " + position[1] :  position[0] + " -" + value.toString() + "px";
7572  }
7573 },
7574 AddState: function(value, stateInputKey, imagePropertiesNumber) {
7575  this.checkBoxStates.push({
7576   "Value" : value, 
7577   "StateInputKey" : stateInputKey, 
7578   "ImagePropertiesNumber" : imagePropertiesNumber
7579  });
7580 },
7581 GetAriaCheckedValue: function(state) {
7582  switch(state) {
7583   case ASPx.CheckBoxCheckState.Checked: return "true";
7584   case ASPx.CheckBoxCheckState.Unchecked: return "false";
7585   case ASPx.CheckBoxCheckState.Indeterminate: return "mixed";
7586   default: return "";
7587  }
7588 },
7589 GetAriaSelectedValue: function(state) {
7590  switch(state) {
7591   case ASPx.CheckBoxCheckState.Checked: return "true";
7592   case ASPx.CheckBoxCheckState.Unchecked: return "false";
7593   case ASPx.CheckBoxCheckState.Indeterminate: return "undefined";
7594   default: return "";
7595  }
7596 },
7597 SetAriaCheckedSelectedAttributes: function(mainElement, state) {
7598  if(mainElement.attributes["aria-checked"] !== undefined) {
7599   var ariaCheckedValue = this.GetAriaCheckedValue(state);
7600   mainElement.setAttribute("aria-checked", ariaCheckedValue);
7601  }
7602  if(mainElement.attributes["aria-selected"] !== undefined) {
7603   var ariaSelectedValue = this.GetAriaSelectedValue(state);
7604   mainElement.setAttribute("aria-selected", ariaSelectedValue);
7605  }
7606 }
7607});
7608CheckableElementStateController.Create = function(imageProperties, valueChecked, valueUnchecked, valueGrayed, allowGrayed) {
7609 var stateController = new CheckableElementStateController(imageProperties);
7610 stateController.AddState(valueChecked, CheckBoxInputKey.Checked, 0);
7611 stateController.AddState(valueUnchecked, CheckBoxInputKey.Unchecked, 1);
7612 if(typeof(valueGrayed) != "undefined")
7613  stateController.AddState(valueGrayed, CheckBoxInputKey.Indeterminate, allowGrayed ? 2 : 1);
7614 stateController.allowGrayed = allowGrayed;
7615 return stateController;
7616};
7617var CheckableElementHelper = ASPx.CreateClass(null, {
7618 InternalCheckBoxInitialize: function(internalCheckBox) {
7619  this.AttachToMainElement(internalCheckBox);
7620  this.AttachToInputElement(internalCheckBox);
7621 },
7622 AttachToMainElement: function(internalCheckBox) {
7623  var instance = this;
7624  if(internalCheckBox.mainElement) {
7625    var toggleEvent = internalCheckBox.displaySwitch ? ASPx.TouchUIHelper.touchMouseDownEventName : "click";
7626    ASPx.Evt.AttachEventToElement(internalCheckBox.mainElement, toggleEvent,
7627    function (evt) {
7628     if(ASPx.Evt.IsRightButtonPressed(evt))
7629      return;
7630     instance.InvokeClick(internalCheckBox, evt);
7631     if(!internalCheckBox.disableCancelBubble)
7632      return ASPx.Evt.PreventEventAndBubble(evt);
7633    }
7634   );
7635   ASPx.Evt.AttachEventToElement(internalCheckBox.mainElement, "mousedown",
7636    function (evt) {
7637     internalCheckBox.Refocus();
7638    }
7639   );
7640   ASPx.Evt.PreventElementDragAndSelect(internalCheckBox.mainElement, true);
7641  }
7642 },
7643 AttachToInputElement: function(internalCheckBox) {
7644  var instance = this;
7645  if(internalCheckBox.inputElement && internalCheckBox.mainElement) {
7646   var checkableElement = internalCheckBox.accessibilityCompliant ? internalCheckBox.mainElement : internalCheckBox.inputElement;
7647   ASPx.Evt.AttachEventToElement(checkableElement, "focus",
7648    function (evt) { 
7649     if(!internalCheckBox.enabled)
7650      checkableElement.blur();
7651     else
7652      internalCheckBox.OnFocus();
7653    }
7654   );
7655   ASPx.Evt.AttachEventToElement(checkableElement, "blur", 
7656    function (evt) { 
7657     internalCheckBox.OnLostFocus();
7658    }
7659   );
7660   ASPx.Evt.AttachEventToElement(checkableElement, "keyup",
7661    function (evt) { 
7662     if(ASPx.Evt.GetKeyCode(evt) == ASPx.Key.Space)
7663      instance.InvokeClick(internalCheckBox, evt);
7664    }
7665   );
7666   ASPx.Evt.AttachEventToElement(checkableElement, "keydown",
7667    function (evt) { 
7668     if(ASPx.Evt.GetKeyCode(evt) == ASPx.Key.Space)
7669      return ASPx.Evt.PreventEvent(evt);
7670    }
7671   );
7672  }
7673 },
7674 IsKBSInputWrapperExist: function() {
7675  return ASPx.Browser.Opera || ASPx.Browser.WebKitFamily;
7676 },
7677 GetICBMainElementByInput: function(icbInputElement) {
7678  return this.IsKBSInputWrapperExist() ? icbInputElement.parentNode.parentNode : icbInputElement.parentNode;
7679 },
7680 RequirePreventFocus: function() { return false; },
7681 InvokeClick: function(internalCheckBox, evt) {
7682  if(internalCheckBox.enabled && !internalCheckBox.GetReadOnly()) {
7683   var inputElementValue = internalCheckBox.inputElement.value;
7684   var focusableElement = internalCheckBox.accessibilityCompliant ? internalCheckBox.mainElement : internalCheckBox.inputElement; 
7685   if(!this.RequirePreventFocus())
7686    focusableElement.focus();
7687   internalCheckBox.inputElement.value = inputElementValue; 
7688   this.InvokeClickCore(internalCheckBox, evt);
7689   }
7690 },
7691 InvokeClickCore: function(internalCheckBox, evt) {
7692  internalCheckBox.OnClick(evt);
7693 }
7694});
7695CheckableElementHelper.Instance = new CheckableElementHelper();
7696var CheckBoxInternal = ASPx.CreateClass(null, {
7697 constructor: function(inputElement, stateController, allowGrayed, allowGrayedByClick, helper, container, storeValueInInput, key, disableCancelBubble,
7698  accessibilityCompliant, displaySwitch) {
7699  this.inputElement = inputElement;
7700  this.mainElement = helper.GetICBMainElementByInput(this.inputElement);
7701  this.name = (key ? key : this.inputElement.id) + CheckBoxInternal.GetICBMainElementPostfix();
7702  this.mainElement.id = this.name;
7703  this.stateController = stateController;
7704  this.container = container;
7705  this.allowGrayed = allowGrayed;
7706  this.allowGrayedByClick = allowGrayedByClick;
7707  this.autoSwitchEnabled = true;
7708  this.displaySwitch = displaySwitch;
7709  this.storeValueInInput = !!storeValueInInput;
7710  this.storedInputKey = !this.storeValueInInput ? this.inputElement.value : null;
7711  this.disableCancelBubble = !!disableCancelBubble;
7712  this.accessibilityCompliant = accessibilityCompliant;
7713  this.focusDecoration = null;
7714  this.focused = false;
7715  this.focusLocked = false;
7716  this.enabled = !this.mainElement.className.match(/dxWeb_\w+Disabled(\b|_)/);
7717  this.readOnly = false;
7718  this.preventFocus = helper.RequirePreventFocus();
7719  this.CheckedChanged = new ASPxClientEvent();
7720  this.Focus = new ASPxClientEvent();
7721  this.LostFocus = new ASPxClientEvent();
7722  helper.InternalCheckBoxInitialize(this);
7723 },
7724 GetReadOnly: function() {
7725  return this.readOnly;
7726 },
7727 ChangeInputElementTabIndex: function() {  
7728  var changeMethod = this.enabled ? ASPx.Attr.RestoreTabIndexAttribute : ASPx.Attr.SaveTabIndexAttributeAndReset;
7729  changeMethod(this.inputElement);
7730 },
7731 CreateFocusDecoration: function(focusedStyle) {
7732   this.focusDecoration = new FocusedStyleDecoration(this);
7733   this.focusDecoration.AddStyle('F', focusedStyle[0], focusedStyle[1]);
7734   this.focusDecoration.AddPostfix("");
7735 },
7736 UpdateFocusDecoration: function() {
7737  this.focusDecoration.Update();
7738 },  
7739 StoreInputKey: function(inputKey) {
7740  if(this.storeValueInInput)
7741   this.inputElement.value = inputKey;
7742  else
7743   this.storedInputKey = inputKey;
7744 },
7745 GetStoredInputKey: function() {
7746  if(this.storeValueInInput)
7747   return this.inputElement.value;
7748  else
7749   return this.storedInputKey;
7750 },
7751 OnClick: function(e) {
7752  if(this.autoSwitchEnabled) {
7753   var currentValue = this.GetValue();
7754   var value = this.stateController.GetNextCheckBoxValue(currentValue, this.allowGrayedByClick && this.allowGrayed);
7755   this.SetValue(value);
7756  }
7757  this.CheckedChanged.FireEvent(this, e);
7758 },
7759 OnFocus: function() {
7760  if(!this.IsFocusLocked()) {
7761   this.focused = true;
7762   this.UpdateFocusDecoration();
7763   this.Focus.FireEvent(this, null);
7764  } else
7765   this.UnlockFocus();
7766 },
7767 OnLostFocus: function() {
7768  if(!this.IsFocusLocked()) {
7769   this.focused = false;
7770   this.UpdateFocusDecoration();
7771   this.LostFocus.FireEvent(this, null);
7772  }
7773 },
7774 Refocus: function() {
7775  if(this.preventFocus) return;
7776  if(this.focused) {

7777   this.LockFocus();
7778   this.inputElement.blur();
7779   if(ASPx.Browser.MacOSMobilePlatform) {
7780    window.setTimeout(function() {
7781     ASPx.SetFocus(this.inputElement);
7782    }, ASPx.FOCUS_TIMEOUT);
7783   } else {
7784    ASPx.SetFocus(this.inputElement);
7785   }
7786  }
7787 },
7788 LockFocus: function() {
7789  this.focusLocked = true;
7790 },
7791 UnlockFocus: function() {
7792  this.focusLocked = false;
7793 },
7794 IsFocusLocked: function() {
7795  if(!!ASPx.Attr.GetAttribute(this.mainElement, ASPx.Attr.GetTabIndexAttributeName()))
7796   return false;
7797  return this.focusLocked;
7798 },
7799 SetValue: function(value, force) {
7800  var currentValue = this.GetValue();
7801  if(currentValue !== value || force) {
7802   var newInputKey = this.stateController.GetInputKeyByValue(value);
7803   if(newInputKey) {
7804    this.StoreInputKey(newInputKey);   
7805    this.stateController.UpdateInternalCheckBoxDecoration(this.mainElement, newInputKey, this.enabled);
7806   }
7807  }
7808  if(this.accessibilityCompliant) {
7809   var state = this.GetCurrentCheckState();
7810   this.stateController.SetAriaCheckedSelectedAttributes(this.mainElement, state);
7811  }
7812 },
7813 GetValue: function() {
7814  return this.stateController.GetValueByInputKey(this.GetCurrentInputKey());
7815 },
7816 GetCurrentCheckState: function() {
7817  return this.stateController.GetCheckStateByInputKey(this.GetCurrentInputKey());
7818 },
7819 GetCurrentInputKey: function() {
7820  return this.GetStoredInputKey();
7821 },
7822 GetChecked: function() {
7823  return this.GetCurrentInputKey() === CheckBoxInputKey.Checked;
7824 },
7825 SetChecked: function(checked) {
7826  var newValue = this.stateController.GetValueByCheckState(checked ? CheckBoxCheckState.Checked : CheckBoxCheckState.Unchecked);
7827  this.SetValue(newValue);
7828 },
7829 SetEnabled: function(enabled) {
7830  if(this.enabled != enabled) {
7831   this.enabled = enabled;
7832   this.stateController.UpdateInternalCheckBoxDecoration(this.mainElement, this.GetCurrentInputKey(), this.enabled);
7833   this.ChangeInputElementTabIndex();
7834  }
7835 },
7836 GetEnabled: function() {
7837  return this.enabled;
7838 }
7839});
7840CheckBoxInternal.GetICBMainElementPostfix = function() {
7841 return "_D";
7842};
7843var CheckBoxInternalCollection = ASPx.CreateClass(CollectionBase, {
7844 constructor: function(imageProperties, allowGrayed, storeValueInInput, helper, disableCancelBubble, accessibilityCompliant) {
7845  this.constructor.prototype.constructor.call(this);
7846  this.stateController = allowGrayed 
7847   ? CheckableElementStateController.Create(imageProperties, CheckBoxInputKey.Checked, CheckBoxInputKey.Unchecked, CheckBoxInputKey.Indeterminate, true)
7848   : CheckableElementStateController.Create(imageProperties, CheckBoxInputKey.Checked, CheckBoxInputKey.Unchecked);
7849  this.helper = helper || CheckableElementHelper.Instance;
7850  this.storeValueInInput = !!storeValueInInput;
7851  this.disableCancelBubble = !!disableCancelBubble;
7852  this.accessibilityCompliant = accessibilityCompliant;
7853 },
7854 Add: function(key, inputElement, container) {
7855  this.Remove(key);
7856  var checkBox = this.CreateInternalCheckBox(key, inputElement, container);
7857  CollectionBase.prototype.Add.call(this, key, checkBox);
7858  return checkBox;
7859 },
7860 SetImageProperties: function(imageProperties) {
7861  this.stateController.imageProperties = imageProperties;
7862 },
7863 CreateInternalCheckBox: function(key, inputElement, container) {
7864  return new CheckBoxInternal(inputElement, this.stateController, this.stateController.allowGrayed, false, this.helper, container, 
7865   this.storeValueInInput, key, this.disableCancelBubble, this.accessibilityCompliant);
7866 }
7867});
7868var FocusedStyleDecoration = ASPx.CreateClass(null, {
7869 constructor: function(editor) {
7870  this.editor = editor;
7871  this.postfixList = [];
7872  this.styles = {};
7873  this.innerStyles = {};
7874 },
7875 AddPostfix: function(value) {
7876  this.postfixList.push(value);
7877 },
7878 AddStyle: function(key, className, cssText) {
7879  this.styles[key] = this.CreateRule(className, cssText);
7880  this.innerStyles[key] = this.CreateRule("", this.FilterInnerCss(cssText));
7881 },
7882 CreateRule: function(className, cssText) {
7883  return ASPx.Str.Trim(className + " " + ASPx.CreateImportantStyleRule(this.GetStyleSheet(), cssText));
7884 },
7885 GetStyleSheet: function() {
7886  return ASPx.GetCurrentStyleSheet();
7887 },
7888 FilterInnerCss: function(css) {
7889  return css.replace(/(border|background-image)[^:]*:[^;]+/gi, "");
7890 },
7891 Update: function() {
7892  for(var i = 0; i < this.postfixList.length; i++) {
7893   var postfix = this.postfixList[i];
7894   var inner = postfix.length > 0;

7895   var element = this.GetElementByPostfix(postfix);
7896   if(element)
7897    this.ApplyStyles(element, inner);
7898  }
7899 },
7900 GetElementByPostfix: function(postfix) {
7901  return ASPx.GetElementById(this.editor.name + postfix);
7902 },
7903 ApplyStyles: function(element, inner) {
7904  this.ApplyFocusedStyle(element, inner);
7905 },
7906 ApplyFocusedStyle: function(element, inner) {
7907  if(this.HasDecoration("F"))
7908   this.ApplyDecoration("F", element, inner, this.editor.focused);
7909 },
7910 HasDecoration: function(key) {
7911  return !!this.styles[key];
7912 },
7913 ApplyDecoration: function(key, element, inner, active) {
7914  var value = inner ? this.innerStyles[key] : this.styles[key];
7915  this.RemoveDecoration(element, value);
7916  if(active)
7917   ASPx.AddClassNameToElement(element, value);
7918 },
7919 RemoveDecoration: function(element, value) {
7920  ASPx.RemoveClassNameFromElement(element, value);
7921 },
7922 ApplyDecorationCore: function() {
7923 },
7924 EnsureElementBorder: function(element) {
7925  var border = parseInt(element.border) || 0;
7926  element.border = 1;
7927  element.border = border;
7928 }
7929});
7930var EditorStyleDecoration = ASPx.CreateClass(FocusedStyleDecoration, {
7931 constructor: function(editor) {
7932  this.constructor.prototype.constructor.call(this, editor);
7933  this.lockUpdate = false;
7934 },
7935 LockUpdate: function() {
7936  this.lockUpdate = true;
7937 },
7938 UnlockUpdate: function() {
7939  this.lockUpdate = false;
7940 },
7941 IsUpdateLocked: function() {
7942  return this.lockUpdate;
7943 },
7944 Update: function () {
7945  if(this.IsUpdateLocked())
7946   return;
7947  ASPx.FocusedStyleDecoration.prototype.Update.call(this);
7948 },
7949 ApplyStyles: function (element, inner) {
7950  this.ApplyInvalidStyle(element, inner);
7951  ASPx.FocusedStyleDecoration.prototype.ApplyStyles.call(this, element, inner);
7952 },
7953 ApplyInvalidStyle: function (element, inner) {
7954  if(this.HasDecoration("I")) {
7955   var isValid = this.editor.GetIsValid();
7956   this.ApplyDecoration("I", element, inner, !isValid);
7957  }
7958 }
7959});
7960var TextEditorStyleDecoration = ASPx.CreateClass(EditorStyleDecoration, {
7961 constructor: function(editor) {
7962  this.constructor.prototype.constructor.call(this, editor);
7963  this.nullTextClassName = "";
7964 },
7965 ApplyStyles: function(element, inner) {
7966  ASPx.EditorStyleDecoration.prototype.ApplyStyles.call(this, element, inner);
7967  this.ApplyNullTextStyle(element, inner);
7968 },
7969 ApplyNullTextStyle: function(element, inner) {
7970  if(!this.HasDecoration("N"))
7971   return;
7972  var apply = !this.editor.focused && this.editor.CanApplyNullTextDecoration();
7973  this.EnsureSpellcheckAttribute(element, apply);
7974  this.ApplyDecoration("N", element, inner, apply);
7975 },
7976 EnsureSpellcheckAttribute: function(element, apply) {
7977  if(apply)
7978   ASPx.Attr.ChangeAttribute(element, "spellcheck", "false");
7979  else
7980   ASPx.Attr.RestoreAttribute(element, "spellcheck");
7981 },
7982 ApplyNullTextClassName: function(active) {
7983  var nullTextClassName = this.GetNullTextClassName();
7984  var editorMainElement = this.editor.GetMainElement();
7985  if(active)
7986   ASPx.AddClassNameToElement(editorMainElement, nullTextClassName);
7987  else
7988   ASPx.RemoveClassNameFromElement(editorMainElement, nullTextClassName);
7989 },
7990 GetNullTextClassName: function() {
7991  if (!this.nullTextClassName)
7992   this.InitializeNullTextClassName();
7993  return this.nullTextClassName;
7994 },
7995 InitializeNullTextClassName: function() {
7996  var nullTextStyle = this.styles["N"];
7997  if (nullTextStyle) {
7998   var nullTextStyleClassNames = nullTextStyle.split(" ");
7999   for (var i = 0; i < nullTextStyleClassNames.length; i++)
8000    if (nullTextStyleClassNames[i].match("dxeNullText"))
8001     this.nullTextClassName = nullTextStyleClassNames[i];
8002  }
8003 }
8004});
8005var touchUIHelperUsePointerEvents = (ASPx.Browser.Edge || ASPx.Browser.EdgeWebKit) && ASPx.Browser.MSTouchUI && !!window.PointerEvent;
8006var TouchUIHelper = {
8007 isGesture: false,
8008 isMouseEventFromScrolling: false,
8009 isNativeScrollingAllowed: true,
8010 clickSensetivity: 10,
8011 documentTouchHandlers: {},
8012 documentEventAttachingAllowed: true,
8013 msTouchDraggableClassName: "dxMSTouchDraggable",
8014 touchMouseDownEventName: ASPx.Browser.WebKitTouchUI ? "touchstart" : (touchUIHelperUsePointerEvents ? "pointerdown" : "mousedown"),
8015 touchMouseUpEventName: ASPx.Browser.WebKitTouchUI ? "touchend" : (touchUIHelperUsePointerEvents ? "pointerup" : "mouseup"),
8016 touchMouseMoveEventName: ASPx.Browser.WebKitTouchUI ? "touchmove" : (touchUIHelperUsePointerEvents ? "pointermove" : "mousemove"),
8017 startPreventingTouchMove: function() {
8018  if(touchUIHelperUsePointerEvents)
8019   ASPx.Evt.AttachEventToDocument("touchmove", ASPx.Evt.PreventEvent);
8020 },
8021 stopPreventingTouchMove: function() {
8022  if(touchUIHelperUsePointerEvents)
8023   ASPx.Evt.DetachEventFromDocument("touchmove", ASPx.Evt.PreventEvent);
8024 },
8025 isTouchEvent: function(evt) {
8026  if(!evt) return false;
8027  return ASPx.Browser.WebKitTouchUI && ASPx.IsExists(evt.changedTouches); 
8028 },
8029 isTouchEventName: function(eventName) {
8030  return ASPx.Browser.WebKitTouchUI && (eventName.indexOf("touch") > -1 || eventName.indexOf("gesture") > -1);
8031 },
8032 getEventX: function(evt) {
8033  var touchPoint = null;
8034  if(evt.changedTouches.length > 0)
8035   touchPoint = evt.changedTouches;
8036  else if(evt.targetTouches.length > 0)
8037   touchPoint = evt.targetTouches;
8038  return touchPoint ? touchPoint[0].pageX : 0;
8039 },
8040 getEventY: function(evt) { 
8041  var touchPoint = null;
8042  if(evt.changedTouches.length > 0)
8043   touchPoint = evt.changedTouches;
8044  else if(evt.targetTouches.length > 0)
8045   touchPoint = evt.targetTouches;
8046  return touchPoint ? touchPoint[0].pageY : 0;
8047 },
8048 getWebkitMajorVersion: function(){
8049  if(!this.webkitMajorVersion){
8050   var regExp = new RegExp("applewebkit/(\\d+)", "i");
8051   var matches = regExp.exec(ASPx.Browser.UserAgent);
8052   if(matches && matches.index >= 1)
8053    this.webkitMajorVersion = matches[1];
8054  }
8055  return this.webkitMajorVersion;
8056 },
8057 getIsLandscapeOrientation: function(){
8058  if(ASPx.Browser.MacOSMobilePlatform || ASPx.Browser.AndroidMobilePlatform)
8059   return Math.abs(window.orientation) == 90;
8060  return ASPx.GetDocumentClientWidth() > ASPx.GetDocumentClientHeight();
8061 },
8062 nativeScrollingSupported: function() {
8063  var allowedSafariVersion = ASPx.Browser.Version >= 5.1 && ASPx.Browser.Version < 8; 
8064  var webkitMajorVersion = this.getWebkitMajorVersion();
8065  var allowedWebKitVersion = webkitMajorVersion > 533 && webkitMajorVersion < 600;
8066  return (ASPx.Browser.MacOSMobilePlatform && (allowedSafariVersion || allowedWebKitVersion))
8067   || (ASPx.Browser.AndroidMobilePlatform && ASPx.Browser.PlaformMajorVersion >= 3) || (ASPx.Browser.MSTouchUI);
8068 },
8069 makeScrollableIfRequired: function(element, options) {
8070  if(ASPx.Browser.WebKitTouchUI && element) {
8071   var overflow = ASPx.GetCurrentStyle(element).overflow;
8072   if(element.tagName == "DIV" &&  overflow != "hidden" && overflow != "visible" ){
8073    return this.MakeScrollable(element);
8074   }
8075  }
8076 },
8077 preventScrollOnEvent: function(evt){
8078 },
8079 handleFastTapIfRequired: function(evt, action, preventCommonClickEvents) {
8080  if(ASPx.Browser.WebKitTouchUI && evt.type == 'touchstart' && action) {
8081   this.FastTapHelper.HandleFastTap(evt, action, preventCommonClickEvents);
8082   return true;
8083  }
8084  return false;
8085 },
8086 ensureDocumentSizesCorrect: function (){
8087  return (document.documentElement.clientWidth - document.documentElement.clientHeight) / (screen.width - screen.height) > 0;

8088 },
8089 ensureOrientationChanged: function(onOrientationChangedFunction){
8090  if(ASPxClientUtils.iOSPlatform || this.ensureDocumentSizesCorrect())
8091   onOrientationChangedFunction();
8092  else {
8093   window.setTimeout(function(){
8094    this.ensureOrientationChanged(onOrientationChangedFunction);
8095   }.aspxBind(this), 100);
8096  }
8097 },
8098 onEventAttachingToDocument: function(eventName, func){
8099  if(ASPx.Browser.MacOSMobilePlatform && this.isTouchEventName(eventName)) {
8100   if(!this.documentTouchHandlers[eventName])
8101    this.documentTouchHandlers[eventName] = [];
8102   this.documentTouchHandlers[eventName].push(func);
8103   return this.documentEventAttachingAllowed;
8104  }
8105  return true;
8106 },
8107 onEventDettachedFromDocument: function(eventName, func){
8108  if(ASPx.Browser.MacOSMobilePlatform && this.isTouchEventName(eventName)) {
8109   var handlers = this.documentTouchHandlers[eventName];
8110   if(handlers)
8111    ASPx.Data.ArrayRemove(handlers, func);
8112  }
8113 },
8114 processDocumentTouchEventHandlers: function(proc) {
8115  var touchEventNames = ["touchstart", "touchend", "touchmove", "gesturestart", "gestureend"];
8116  for(var i = 0; i < touchEventNames.length; i++) {
8117   var eventName = touchEventNames[i];
8118   var handlers = this.documentTouchHandlers[eventName];
8119   if(handlers) {
8120    for(var j = 0; j < handlers.length; j++) {
8121     proc(eventName,handlers[j]);
8122    }
8123   }
8124  }
8125 },
8126 removeDocumentTouchEventHandlers: function() {
8127  if(ASPx.Browser.MacOSMobilePlatform) {
8128   this.documentEventAttachingAllowed = false;
8129   this.processDocumentTouchEventHandlers(ASPx.Evt.DetachEventFromDocumentCore);
8130  }
8131 },
8132 restoreDocumentTouchEventHandlers: function () {
8133  if(ASPx.Browser.MacOSMobilePlatform) {
8134   this.documentEventAttachingAllowed = true;
8135   this.processDocumentTouchEventHandlers(ASPx.Evt.AttachEventToDocumentCore);
8136  }
8137 },
8138 IsNativeScrolling: function() {
8139  return TouchUIHelper.nativeScrollingSupported() && TouchUIHelper.isNativeScrollingAllowed;
8140 },
8141 pointerEnabled: !!(window.PointerEvent || window.MSPointerEvent),
8142 pointerDownEventName: window.PointerEvent ? "pointerdown" : "MSPointerDown",
8143 pointerUpEventName: window.PointerEvent ? "pointerup" : "MSPointerUp",
8144 pointerCancelEventName: window.PointerEvent ? "pointercancel" : "MSPointerCancel",
8145 pointerMoveEventName: window.PointerEvent ? "pointermove" : "MSPointerMove",
8146 pointerOverEventName: window.PointerEvent ? "pointerover" : "MSPointerOver",
8147 pointerOutEventName: window.PointerEvent ? "pointerout" : "MSPointerOut",
8148 pointerType: {
8149  Touch: "touch",
8150  Pen: "pen",
8151  Mouse: "mouse"
8152 },
8153 msGestureEnabled: !!(window.PointerEvent || window.MSPointerEvent) && typeof(MSGesture) != "undefined",
8154 msTouchCreateGesturesWrapper: function(element, onTap){
8155  if(!TouchUIHelper.msGestureEnabled) 
8156   return;
8157  var gesture = new MSGesture();
8158  gesture.target = element;
8159  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.pointerDownEventName, function(evt){
8160   gesture.addPointer(evt.pointerId);
8161  });
8162  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.pointerUpEventName, function(evt){
8163   gesture.stop();
8164  });
8165  if(onTap)
8166   ASPx.Evt.AttachEventToElement(element, "MSGestureTap", onTap);
8167  return gesture;
8168 },
8169 useLongTapHelper: function () {
8170  return ASPx.Browser.Safari && ASPx.Browser.TouchUI;
8171 },
8172 attachLongTapHandler: function(element, handler, onlyBubbling) {
8173  var timerID = -1;
8174  var timeout = 1000;
8175  var event = null;
8176  var preventClickEvent = false;
8177  var startX = -1;
8178  var startY = -1;
8179  var pixelLimit = 5;
8180  function onTouchMouseDown(evt) {
8181   abortWating();
8182   event = evt;
8183   startX = evt.pageX;
8184   startY = evt.pageY;
8185   preventClickEvent = false;
8186   timerID = window.setTimeout(onTimeout, timeout);
8187  }
8188  function onTouchMouseMove(evt) {
8189   if (!isUnderTouch())
8190    return;
8191   var shiftX = Math.abs(startX - evt.pageX),
8192    shiftY = Math.abs(startY - evt.pageY),
8193    maxShift = Math.max(shiftX, shiftY);
8194   if (maxShift > pixelLimit)
8195    abortWating();
8196  }
8197  function onTouchMouseUp(evt) {
8198   abortWating();
8199   if (preventClickEvent) {
8200    ASPx.Evt.PreventEventAndBubble(evt);
8201    preventClickEvent = false;
8202   }
8203  }
8204  function onTimeout() {
8205   handler(event);
8206   preventClickEvent = true;
8207   abortWatingInternal();
8208  }
8209  function isUnderTouch() {
8210   return timerID !== -1;
8211  }
8212  function abortWating() {
8213   if (isUnderTouch()) {
8214    window.clearTimeout(timerID);
8215    abortWatingInternal();
8216   }
8217  }
8218  function abortWatingInternal() {
8219   timerID = -1;
8220   event = null;
8221  }
8222  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.touchMouseDownEventName, onTouchMouseDown, onlyBubbling);
8223  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.touchMouseMoveEventName, onTouchMouseMove, onlyBubbling);
8224  ASPx.Evt.AttachEventToElement(element, TouchUIHelper.touchMouseUpEventName, onTouchMouseUp, onlyBubbling);
8225  element.style["-webkit-user-select"] = "none";
8226  return function () {
8227   ASPx.Evt.DetachEventFromElement(element, TouchUIHelper.touchMouseDownEventName, onTouchMouseDown);

8228   ASPx.Evt.DetachEventFromElement(element, TouchUIHelper.touchMouseMoveEventName, onTouchMouseMove);
8229   ASPx.Evt.DetachEventFromElement(element, TouchUIHelper.touchMouseUpEventName, onTouchMouseUp);
8230   element.style["-webkit-user-select"] = "";
8231  };
8232 }
8233};
8234var CacheHelper = {};
8235CacheHelper.GetCachedValueCore = function(obj, key, func, cacheObj, fillValueMethod) {
8236 if(!cacheObj)
8237  cacheObj = obj;
8238 if(!cacheObj.cache)
8239  cacheObj.cache = {};
8240 if(!key) 
8241  key = "default";
8242 fillValueMethod(obj, key, func, cacheObj);
8243 return cacheObj.cache[key];
8244};
8245CacheHelper.GetCachedValue = function(obj, key, func, cacheObj) {
8246 return CacheHelper.GetCachedValueCore(obj, key, func, cacheObj, 
8247  function(obj, key, func, cacheObj) {
8248   if(!ASPx.IsExists(cacheObj.cache[key]))
8249    cacheObj.cache[key] = func.apply(obj, []);
8250  });
8251};
8252CacheHelper.GetCachedElement = function(obj, key, func, cacheObj) {
8253 return CacheHelper.GetCachedValueCore(obj, key, func, cacheObj, 
8254  function(obj, key, func, cacheObj) {
8255   if(!ASPx.IsValidElement(cacheObj.cache[key]))
8256    cacheObj.cache[key] = func.apply(obj, []);
8257  });
8258};
8259CacheHelper.GetCachedElements = function(obj, key, func, cacheObj) {
8260 return CacheHelper.GetCachedValueCore(obj, key, func, cacheObj, 
8261  function(obj, key, func, cacheObj) {
8262   if(!ASPx.IsValidElements(cacheObj.cache[key])){
8263    var elements = func.apply(obj, []);
8264    if(!Ident.IsArray(elements))
8265     elements = [elements];
8266    cacheObj.cache[key] = elements;
8267   }
8268  });
8269};
8270CacheHelper.GetCachedElementById = function(obj, id, cacheObj) {
8271 return CacheHelper.GetCachedElement(obj, id, function() { return ASPx.GetElementById(id); }, cacheObj);
8272};
8273CacheHelper.GetCachedChildById = function(obj, parent, id, cacheObj) {
8274 return CacheHelper.GetCachedElement(obj, id, function() { return ASPx.GetChildById(parent, id); }, cacheObj);
8275};
8276CacheHelper.DropCachedValue = function(cacheObj, key) {
8277 cacheObj.cache[key] = null;
8278};  
8279CacheHelper.DropCache = function(cacheObj) {
8280 cacheObj.cache = null;
8281};  
8282var DomObserver = ASPx.CreateClass(null, {
8283 constructor: function() {
8284  this.items = { };
8285 },
8286 subscribe: function(elementID, callbackFunc) {
8287  var item = this.items[elementID];
8288  if(item)
8289   this.unsubscribe(elementID);
8290  item = {
8291   elementID: elementID,
8292   callbackFunc: callbackFunc,
8293   pauseCount: 0
8294  };
8295  this.prepareItem(item);
8296  this.items[elementID] = item;
8297 },
8298 prepareItem: function(item) {
8299 },
8300 unsubscribe: function(elementID) {
8301  this.items[elementID] = null;
8302 },
8303 getItemElement: function(item) {
8304  var element = this.getElementById(item.elementID);
8305  if(element)
8306   return element;
8307  this.unsubscribe(item.elementID);
8308  return null;
8309 },
8310 getElementById: function(elementID) {
8311  var element = document.getElementById(elementID);
8312  return element && ASPx.IsValidElement(element) ? element : null;
8313 },
8314 pause: function(element, includeSubtree) {
8315  this.changeItemsState(element, includeSubtree, true);
8316 },
8317 resume: function(element, includeSubtree) {
8318  this.changeItemsState(element, includeSubtree, false);
8319 },
8320 forEachItem: function(processFunc, context) {
8321  context = context || this;
8322  for(var itemName in this.items) {
8323   if(!this.items.hasOwnProperty(itemName))
8324    continue;
8325   var item = this.items[itemName];
8326   if(item) {
8327    var needBreak = processFunc.call(context, item);
8328    if(needBreak)
8329     return;
8330   }
8331  }
8332 },
8333 changeItemsState: function(element, includeSubtree, pause) {
8334  this.forEachItem(function(item) {
8335   if(!element)
8336    this.changeItemState(item, pause);
8337   else {
8338    var itemElement = this.getItemElement(item);
8339    if(itemElement && (element == itemElement || (includeSubtree && ASPx.GetIsParent(element, itemElement)))) {
8340     this.changeItemState(item, pause);
8341     if(!includeSubtree)
8342      return true;
8343    }
8344   }
8345  }.aspxBind(this));
8346 },
8347 changeItemState: function(item, pause) {
8348  if(pause)
8349   this.pauseItem(item);
8350  else
8351   this.resumeItem(item);
8352 },
8353 pauseItem: function(item) {
8354  item.paused = true;
8355  item.pauseCount++;
8356 },
8357 resumeItem: function(item) {
8358  if(item.pauseCount > 0) {
8359   if(item.pauseCount == 1)
8360    item.paused = false;
8361   item.pauseCount--;
8362  }
8363 }
8364});
8365DomObserver.IsMutationObserverAvailable = function() {
8366 return !!window.MutationObserver;
8367};
8368var TimerObserver = ASPx.CreateClass(DomObserver, {
8369 constructor: function() {
8370  this.constructor.prototype.constructor.call(this);
8371  this.timerID = -1;
8372  this.observationTimeout = 300;
8373 },
8374 subscribe: function(elementID, callbackFunc) {
8375  DomObserver.prototype.subscribe.call(this, elementID, callbackFunc);
8376  if(!this.isActivated())
8377   this.startObserving();
8378 },
8379 isActivated: function() {
8380  return this.timerID !== -1;
8381 },
8382 startObserving: function() {
8383  if(this.isActivated())
8384   window.clearTimeout(this.timerID);
8385  this.timerID = window.setTimeout(this.onTimeout, this.observationTimeout);
8386 },
8387 onTimeout: function() {
8388  var observer = _aspxGetDomObserver();
8389  observer.doObserve();
8390  observer.startObserving();
8391 },
8392 doObserve: function() {
8393  if(!ASPx.documentLoaded) return;
8394  this.forEachItem(function(item) {
8395   if(!item.paused)
8396    this.doObserveForItem(item);
8397  }.aspxBind(this));
8398 },
8399 doObserveForItem: function(item) {
8400  var element = this.getItemElement(item);
8401  if(element)
8402   item.callbackFunc.call(this, element);
8403 }
8404});
8405var MutationObserver = ASPx.CreateClass(DomObserver, {
8406 constructor: function() {
8407  this.constructor.prototype.constructor.call(this);
8408  this.callbackTimeout = 10;
8409 },
8410 prepareItem: function(item) {
8411  item.callbackTimerID = -1;
8412  var target = this.getElementById(item.elementID);
8413  if(!target)
8414   return;
8415  var observerCallbackFunc = function() {
8416   if(item.callbackTimerID === -1) {
8417    var timeoutHander = function() {
8418     item.callbackTimerID = -1;
8419     item.callbackFunc.call(this, target);
8420    }.aspxBind(this);
8421    item.callbackTimerID = window.setTimeout(timeoutHander, this.callbackTimeout);
8422   }
8423  }.aspxBind(this);
8424  var observer = new window.MutationObserver(observerCallbackFunc);
8425  var config = { attributes: true, childList: true, characterData: true, subtree: true };
8426  observer.observe(target, config);
8427  item.observer = observer;
8428  item.config = config;
8429 },
8430 unsubscribe: function(elementID) {
8431  var item = this.items[elementID];
8432  if(item) {
8433   item.observer.disconnect();
8434   item.observer = null;
8435  }
8436  DomObserver.prototype.unsubscribe.call(this, elementID);
8437 },
8438 pauseItem: function(item) {
8439  DomObserver.prototype.pauseItem.call(this, item);
8440  item.observer.disconnect();
8441 },
8442 resumeItem: function(item) {
8443  DomObserver.prototype.resumeItem.call(this, item);
8444  if(!item.paused) {
8445   var target = this.getItemElement(item);
8446   if(target)
8447    item.observer.observe(target, item.config);
8448  }
8449 }
8450});
8451var domObserver = null;
8452function _aspxGetDomObserver() {
8453 if(domObserver == null)
8454  domObserver = DomObserver.IsMutationObserverAvailable() ? new MutationObserver() : new TimerObserver();
8455 return domObserver;
8456}
8457var ControlUpdateWatcher = ASPx.CreateClass(null, {
8458 constructor: function() {
8459  this.helpers = { };
8460  this.clearLockerTimerID = -1;
8461  this.clearLockerTimerDelay = 15;
8462  this.postProcessing = false;
8463  this.init();
8464 },
8465 init: function() {
8466  var postHandler = aspxGetPostHandler();
8467  postHandler.Post.AddHandler(this.OnPost, this);
8468 },
8469 Add: function(helper) {
8470  this.helpers[helper.GetName()] = helper;
8471 },

8472 CanSendCallback: function(dxCallbackOwner, arg) {
8473  this.LockConfirmOnBeforeWindowUnload();
8474  var modifiedHelpers = this.FilterModifiedHelpersByDXCallbackOwner(this.GetModifiedHelpers(), dxCallbackOwner, arg);
8475  if(modifiedHelpers.length === 0) return true;
8476  var modifiedHelpersInfo = this.GetToConfirmAndToResetLists(modifiedHelpers, dxCallbackOwner.name);
8477  if(!modifiedHelpersInfo) return true;
8478  if(modifiedHelpersInfo.toConfirm.length === 0) {
8479   this.ResetClientChanges(modifiedHelpersInfo.toReset);
8480   return true;
8481  }
8482  var helper = modifiedHelpersInfo.toConfirm[0];
8483  if(!confirm(helper.GetConfirmUpdateText()))
8484   return false;
8485  this.ResetClientChanges(modifiedHelpersInfo.toReset);
8486  return true;
8487 },
8488 OnPost: function(s, e) {
8489  if(this.isDxCallback(e))
8490   return;
8491  this.postProcessing = true;
8492  this.LockConfirmOnBeforeWindowUnload();
8493  var modifiedHelpersInfo = this.GetModifedHelpersInfo(e);
8494  if(!modifiedHelpersInfo)
8495   return;
8496  if(modifiedHelpersInfo.toConfirm.length === 0) {
8497   this.ResetClientChanges(modifiedHelpersInfo.toReset);
8498   return;
8499  }
8500  var helper = modifiedHelpersInfo.toConfirm[0];
8501  if(!confirm(helper.GetConfirmUpdateText())) {
8502   e.cancel = true;
8503   this.finishPostProcessing();
8504  }
8505  if(!e.cancel)
8506   this.ResetClientChanges(modifiedHelpersInfo.toReset);
8507 },
8508 isDxCallback: function(e) {
8509  return e.isDXCallback || this.isInternalUploadControlCallback();
8510 },
8511 isInternalUploadControlCallback: function() {
8512  var isInCallback = false;
8513  for(var key in this.helpers) {
8514   if(this.helpers.hasOwnProperty(key)) {
8515    var helper = this.helpers[key];
8516    isInCallback = isInCallback || helper.isInUploadCallback();
8517   }
8518  }
8519  return isInCallback;
8520 },
8521 finishPostProcessing: function() {
8522  this.postProcessing = false;
8523 },
8524 GetModifedHelpersInfo: function(e) {
8525  var modifiedHelpers = this.FilterModifiedHelpers(this.GetModifiedHelpers(), e);
8526  if(modifiedHelpers.length === 0) return;
8527  return this.GetToConfirmAndToResetLists(modifiedHelpers, e && e.ownerID);
8528 },
8529 GetToConfirmAndToResetLists: function(modifiedHelpers, ownerID) {
8530  var resetList = [ ];
8531  var confirmList = [ ];
8532  for(var i = 0; i < modifiedHelpers.length; i++) {
8533   var helper = modifiedHelpers[i];
8534   if(!helper.GetConfirmUpdateText()) { 
8535    resetList.push(helper);
8536    continue;
8537   }
8538   if(helper.CanShowConfirm(ownerID)) { 
8539    resetList.push(helper);
8540    confirmList.push(helper);
8541   }
8542  }
8543  return { toConfirm: confirmList, toReset: resetList };
8544 },
8545 FilterModifiedHelpers: function(modifiedHelpers, e) {
8546  if(modifiedHelpers.length === 0)
8547   return [ ];
8548  if(this.RequireProcessUpdatePanelCallback(e))
8549   return this.FilterModifiedHelpersByUpdatePanels(modifiedHelpers);
8550  if(this.postProcessing)
8551   return this.FilterModifiedHelpersByPostback(modifiedHelpers);
8552  return modifiedHelpers;
8553 },
8554 FilterModifiedHelpersByDXCallbackOwner: function(modifiedHelpers, dxCallbackOwner, arg) {
8555  var result = [ ];
8556  for(var i = 0; i < modifiedHelpers.length; i++) {
8557   var helper = modifiedHelpers[i];
8558   if(helper.NeedConfirmOnCallback(dxCallbackOwner, arg))
8559    result.push(helper);
8560  }
8561  return result;
8562 },
8563 FilterModifiedHelpersByUpdatePanels: function(modifiedHelpers) {
8564  var result = [ ];
8565  var updatePanels = this.GetUpdatePanelsWaitedForUpdate();
8566  for(var i = 0; i < updatePanels.length; i++) {
8567   var panelID = updatePanels[i].replace(/\$/g, "_");
8568   var panel = ASPx.GetElementById(panelID);
8569   if(!panel) continue;
8570   for(var j = 0; j < modifiedHelpers.length; j++) {
8571    var helper = modifiedHelpers[j];
8572    if(ASPx.GetIsParent(panel, helper.GetControlMainElement()))
8573     result.push(helper);
8574   }
8575  }
8576  return result;
8577 },
8578 FilterModifiedHelpersByPostback: function(modifiedHelpers) {
8579  var result = [ ];
8580  for(var i = 0; i < modifiedHelpers.length; i++) {
8581   var helper = modifiedHelpers[i];
8582   if(helper.NeedConfirmOnPostback())
8583    result.push(helper);
8584  }
8585  return result;
8586 },
8587 RequireProcessUpdatePanelCallback: function(e) {
8588  var rManager = this.GetMSRequestManager();
8589  if(rManager && e && e.isMSAjaxCallback)
8590   return rManager._postBackSettings.async;
8591  return false;
8592 },
8593 GetUpdatePanelsWaitedForUpdate: function() {
8594  var rManager = this.GetMSRequestManager();
8595  if(!rManager) return [ ];

8596  var panelUniqueIDs = rManager._postBackSettings.panelsToUpdate || [ ];
8597  var panelClientIDs = [ ];
8598  for(var i = 0; i < panelUniqueIDs.length; i++) {
8599   var index = ASPx.Data.ArrayIndexOf(rManager._updatePanelIDs, panelUniqueIDs[i]);
8600   if(index >= 0)
8601    panelClientIDs.push(rManager._updatePanelClientIDs[index]);
8602  }
8603  return panelClientIDs;
8604 },
8605 GetMSRequestManager: function() {
8606  return ASPx.GetMSAjaxRequestManager();
8607 },
8608 GetModifiedHelpers: function() {
8609  var result = [ ];
8610  for(var key in this.helpers) { 
8611   if(this.helpers.hasOwnProperty(key)) {
8612    var helper = this.helpers[key];
8613    if(helper.HasChanges())
8614     result.push(helper);
8615   }
8616  }
8617  return result;
8618 },
8619 ResetClientChanges: function(modifiedHelpers) {
8620  for(var i = 0; i < modifiedHelpers.length; i++)
8621   modifiedHelpers[i].ResetClientChanges();
8622 },
8623 GetConfirmUpdateMessage: function() {
8624  if(this.confirmOnWindowUnloadLocked) return;
8625  var modifiedHelpersInfo = this.GetModifedHelpersInfo();
8626  if(!modifiedHelpersInfo || modifiedHelpersInfo.toConfirm.length === 0) 
8627   return;
8628  var helper = modifiedHelpersInfo.toConfirm[0];
8629  return helper.GetConfirmUpdateText();
8630 },
8631 LockConfirmOnBeforeWindowUnload: function() {
8632  this.confirmOnWindowUnloadLocked = true;
8633  this.clearLockerTimerID = ASPx.Timer.ClearTimer(this.clearLockerTimerID);
8634  this.clearLockerTimerID = window.setTimeout(function() {
8635   this.confirmOnWindowUnloadLocked = false;
8636  }.aspxBind(this), this.clearLockerTimerDelay);
8637 },
8638 OnWindowBeforeUnload: function(e) {
8639  var confirmMessage = this.GetConfirmUpdateMessage();
8640  if(confirmMessage)
8641   e.returnValue = confirmMessage;
8642  this.finishPostProcessing();
8643  return confirmMessage;
8644 },
8645 OnWindowUnload: function(e) {
8646  if(this.confirmOnWindowUnloadLocked) return;
8647  var modifiedHelpersInfo = this.GetModifedHelpersInfo();
8648  if(!modifiedHelpersInfo) return;
8649  this.ResetClientChanges(modifiedHelpersInfo.toReset);
8650 },
8651 OnMouseDown: function(e) {
8652 },
8653 OnFocusIn: function(e) {
8654 },
8655 PreventBeforeUnloadOnLinkClick: function(e) {
8656  if(ASPx.GetObjectKeys(this.helpers).length == 0)
8657   return;
8658  var link = ASPx.GetParentByTagName(ASPx.Evt.GetEventSource(e), "A");
8659  if(!link || link.dxgvLinkClickHanlderAssigned)
8660   return;
8661  var url = ASPx.Attr.GetAttribute(link, "href");
8662  if(!url || url.indexOf("javascript:") < 0)
8663   return;
8664  ASPx.Evt.AttachEventToElement(link, "click", function(ev) { return ASPx.Evt.PreventEvent(ev); });
8665  link.dxgvLinkClickHanlderAssigned = true;
8666 }
8667});
8668ControlUpdateWatcher.Instance = null;
8669ControlUpdateWatcher.getInstance = function () {
8670 if (!ControlUpdateWatcher.Instance) {
8671  ControlUpdateWatcher.Instance = new ControlUpdateWatcher();
8672  ASPx.Evt.AttachEventToElement(window, "beforeunload", function(e) {
8673   return ControlUpdateWatcher.Instance.OnWindowBeforeUnload(e);
8674  });
8675  ASPx.Evt.AttachEventToElement(window, "unload", function(e) {
8676   ControlUpdateWatcher.Instance.OnWindowUnload(e);
8677  });
8678  ASPx.Evt.AttachEventToDocument("mousedown", function(e) {
8679   ControlUpdateWatcher.Instance.OnMouseDown(e);
8680  });
8681  ASPx.Evt.AttachEventToDocument("focusin", function(e) {
8682   ControlUpdateWatcher.Instance.OnFocusIn(e);
8683  });
8684 }
8685 return ControlUpdateWatcher.Instance;
8686};
8687var UpdateWatcherHelper = ASPx.CreateClass(null, {
8688 constructor: function(owner) {
8689  this.owner = owner;
8690  this.ownerWatcher = ControlUpdateWatcher.getInstance();
8691  this.ownerWatcher.Add(this);
8692 },
8693 GetName: function() {
8694  return this.owner.name;
8695 },
8696 GetControlMainElement: function() {
8697  return this.owner.GetMainElement();
8698 },
8699 GetControlParentForm: function(){
8700  return ASPx.GetParentByTagName(this.GetControlMainElement(), "FORM");
8701 },
8702 CanShowConfirm: function(requestOwnerID) {
8703  return true;
8704 },
8705 HasChanges: function() {
8706  return false;
8707 },
8708 GetConfirmUpdateText: function() {
8709  return "";
8710 },
8711 NeedConfirmOnCallback: function(dxCallbackOwner) {
8712  return true;
8713 },
8714 NeedConfirmOnPostback: function() {
8715  if(ASPx.IsUploadSubmitRequest)
8716   return !ASPx.IsUploadSubmitRequest(this.GetControlParentForm(

8716));
8717  return true;
8718 },
8719 ResetClientChanges: function() {
8720 },
8721 ConfirmOnCustomControlEvent: function() {
8722  var confirmMessage = this.GetConfirmUpdateText();
8723  if(confirmMessage)
8724   return confirm(confirmMessage);
8725  return false;
8726 },
8727 isInUploadCallback: function() {
8728  return false;
8729 }
8730});
8731var ControlTabIndexManager = ASPx.CreateClass(null, {
8732 constructor: function() {
8733  this.elementsWithChangedTabIndex = {};
8734 },
8735 getChangedElementsForControlId: function(id) {
8736  if(!this.elementsWithChangedTabIndex[id])
8737   this.elementsWithChangedTabIndex[id] = [];
8738  return this.elementsWithChangedTabIndex[id];
8739 },
8740 isElementWithChangedIndex: function(element) {
8741  for(var key in this.elementsWithChangedTabIndex)
8742   if(this.elementsWithChangedTabIndex.hasOwnProperty(key))
8743    if(this.elementsWithChangedTabIndex[key].indexOf(element) !== -1)
8744     return true;
8745  return false;
8746 },
8747 changeTabIndexAttribute: function(element, id) {
8748  var elements = this.getChangedElementsForControlId(id);
8749  ASPx.Attr.ChangeTabIndexAttribute(element);
8750  if(elements.indexOf(element) === -1)
8751   elements.push(element);
8752 },
8753 restoreTabIndexAttribute: function(element, id) {
8754  var elements = this.getChangedElementsForControlId(id),
8755   index = elements.indexOf(element);
8756  if(index !== -1) {
8757   elements.splice(index, 1);
8758   if(!this.isElementWithChangedIndex(element))
8759    ASPx.Attr.RestoreTabIndexAttribute(element);
8760  }
8761 }
8762});
8763ControlTabIndexManager.Instance = null;
8764ControlTabIndexManager.getInstance = function() {
8765 if(!ControlTabIndexManager.Instance)
8766  ControlTabIndexManager.Instance = new ControlTabIndexManager();
8767 return ControlTabIndexManager.Instance;
8768};
8769var ControlCallbackHandlersQueue = ASPx.CreateClass(null, {
8770 constructor: function (owner) {
8771  this.owner = owner;
8772  this.handlerInfos = [];
8773 },
8774 addCallbackHandler: function(handlerInfo) {
8775  this.handlerInfos.push(handlerInfo);
8776 },
8777 executeCallbacksHandlers: function() {
8778  for(var i = 0, handlerInfo; handlerInfo = this.handlerInfos[i]; i++)
8779   handlerInfo.handler.call(this.owner, handlerInfo.result);
8780  this.handlerInfos = [];
8781 }
8782});
8783var ControlCallbackQueueHelper = ASPx.CreateClass(null, {
8784 constructor: function (owner) {
8785  this.owner = owner;
8786  this.pendingCallbacks = [];
8787  this.receivedCallbacks = [];
8788  this.attachEvents();
8789 },
8790 showLoadingElements: function () {
8791  this.owner.ShowLoadingDiv();
8792  if (this.owner.IsCallbackAnimationEnabled())

8793   this.owner.StartBeginCallbackAnimation();
8794  else
8795   this.owner.ShowLoadingElementsInternal();
8796 },
8797 attachEvents: function () {
8798  this.owner.EndCallback.AddHandler(this.onEndCallback.aspxBind(this));
8799  this.owner.CallbackError.AddHandler(this.onCallbackError.aspxBind(this));
8800 },
8801 detachEvents: function () {
8802  this.owner.EndCallback.RemoveHandler(this.onEndCallback);
8803  this.owner.CallbackError.RemoveHandler(this.onCallbackError);
8804 },
8805 onCallbackError: function (owner, result) {
8806  this.sendErrorToChildControl(result);
8807 },
8808 ignoreDuplicates: function () {
8809  return true;
8810 },
8811 hasDuplicate: function (arg) {
8812  for (var i in this.pendingCallbacks) {
8813   if (this.pendingCallbacks[i].arg == arg && this.pendingCallbacks[i].state != ASPx.callbackState.aborted)
8814    return true;
8815  }
8816  return false;
8817 },
8818 getToken: function (halperContext, callbackInfo) {
8819  return {
8820   cancel: function () {
8821    if (callbackInfo.state == ASPx.callbackState.sent) {
8822     callbackInfo.state = ASPx.callbackState.aborted;
8823     halperContext.sendNext();
8824    }
8825    if (callbackInfo.state == ASPx.callbackState.inTurn)
8826     ASPx.Data.ArrayRemove(halperContext.pendingCallbacks, callbackInfo);
8827   },
8828   callbackId: -1
8829  };
8830 },
8831 sendCallback: function (arg, handlerContext, handler, commandName, onBeforeSend) {
8832  if (this.ignoreDuplicates() && this.hasDuplicate(arg))
8833   return false;
8834  var handlerContext = handlerContext || this.owner;
8835  var callbackInfo = {
8836   arg: arg,
8837   handlerContext: handlerContext,
8838   handler: handler || handlerContext.OnCallback,
8839   state: ASPx.callbackState.inTurn,
8840   callbackId: -1,
8841   onBeforeSend: onBeforeSend
8842  };
8843  this.pendingCallbacks.push(callbackInfo);
8844  if (!this.hasActiveCallback()) {
8845   this.createCallbackByCallbackInfo(callbackInfo, commandName);
8846  }
8847  return this.getToken(this, callbackInfo);
8848 },
8849 hasActiveCallback: function () {
8850  return this.getCallbacksInfoByState(ASPx.callbackState.sent).length > 0;
8851 },
8852 sendNext: function () {
8853  var nextCallbackInfo = this.getCallbacksInfoByState(ASPx.callbackState.inTurn)[0];
8854  if (nextCallbackInfo) {
8855   this.createCallbackByCallbackInfo(nextCallbackInfo);
8856   return nextCallbackInfo.callbackId;
8857  }
8858 },
8859 createCallbackByCallbackInfo: function(callbackInfo, commandName) {
8860  if(callbackInfo.onBeforeSend)
8861   callbackInfo.onBeforeSend();
8862  callbackInfo.callbackId = this.owner.CreateCallback(callbackInfo.arg, commandName);
8863  callbackInfo.state = ASPx.callbackState.sent;
8864 },
8865 onEndCallback: function () {
8866  if (!this.owner.isErrorOnCallback && this.hasPendingCallbacks()) {
8867   var curCallbackId;
8868   var curCallbackInfo;
8869   var handlerContext;
8870   for (var i in this.receivedCallbacks) {
8871    if(this.receivedCallbacks.hasOwnProperty(i)) {
8872     curCallbackId = this.receivedCallbacks[i];
8873     curCallbackInfo = this.getCallbackInfoById(curCallbackId);
8874     if (curCallbackInfo.state != ASPx.callbackState.aborted) {
8875      handlerContext = curCallbackInfo.handlerContext;
8876      if (handlerContext.OnEndCallback)
8877       handlerContext.OnEndCallback();
8878      this.sendNext();
8879     }
8880     ASPx.Data.ArrayRemove(this.pendingCallbacks, curCallbackInfo);
8881    }
8882   }
8883   ASPx.Data.ArrayClear(this.receivedCallbacks);
8884  }
8885 },
8886 hasPendingCallbacks: function () {
8887  return this.pendingCallbacks && this.pendingCallbacks.length && this.pendingCallbacks.length > 0;
8888 },
8889 processCallback: function (result, callbackId) {
8890  this.receivedCallbacks.push(callbackId);
8891  if (this.hasPendingCallbacks()) {
8892   var callbackInfo = this.getCallbackInfoById(callbackId);
8893   if (callbackInfo.state != ASPx.callbackState.aborted)
8894    callbackInfo.handler.call(callbackInfo.handlerContext, result);
8895  }
8896 },
8897 getCallbackInfoById: function (id) {
8898  for (var i in this.pendingCallbacks) {
8899   if (this.pendingCallbacks[i].callbackId == id)
8900    return this.pendingCallbacks[i];
8901  }
8902 },
8903 getCallbacksInfoByState: function (state) {
8904  var result = [];
8905  for (var i in this.pendingCallbacks) {
8906   if (this.pendingCallbacks[i].state == state)
8907    result.push(this.pendingCallbacks[i]);
8908  }
8909  return result;
8910 },
8911 sendErrorToChildControl: function (callbackObj) {
8912  if (!this.hasPendingCallbacks())
8913   return;
8914  var callbackInfo = this.getCallbackInfoById(callbackObj.callbackId || 0);
8915  if (!callbackInfo)
8916   return;
8917  var hasChildControlHandler = (callbackInfo.handlerContext != this.owner) && callbackInfo.handlerContext.OnCallbackError;
8918  if (hasChildControlHandler)
8919   callbackInfo.handlerContext.OnCallbackError.call(callbackInfo.handlerContext, callbackObj.message, callbackObj.data);
8920 }
8921});
8922var AccessibilityHelperBase = ASPx.CreateClass(null, {
8923 constructor: function(control) {
8924  this.control = control;
8925  this.pronounceMessageTimeout = 500;
8926  this.pronounceIsStarted = false;
8927  this.timerID = -1;
8928 },
8929 PronounceMessage: function(text, activeItemArgs, inactiveItemArgs, mainElementArgs, ownerMainElement) {
8930  this.timerID = ASPx.Timer.ClearTimer(this.timerID);
8931  this.pronounceIsStarted = true;
8932  this.timerID = window.setTimeout(function() {
8933   this.PronounceMessageCore(text, activeItemArgs, inactiveItemArgs, mainElementArgs, ownerMainElement);
8934  }.aspxBind(this), this.getPronounceTimeout());
8935 },
8936 PronounceMessageCore: function(text) {
8937  this.processValidationState();
8938  if(this.control.IsFocused())
8939   this.control.SendMessageToAssistiveTechnology(text);
8940 },
8941 GetActiveElement: function(inputIsMainElement) {
8942  if(this.pronounceIsStarted) return null;

8943  var mainElement = inputIsMainElement ? this.control.GetInputElement() : this.getMainElement();
8944  var activeElementId = ASPx.Attr.GetAttribute(mainElement, 'aria-activedescendant');
8945  return activeElementId ? ASPx.GetElementById(activeElementId) : mainElement;
8946 },
8947 GetPronounceElement: function() { return null; },
8948 processValidationState: function() {
8949  var errorTextElement = null;
8950  if(this.control.GetErrorCell())
8951   errorTextElement = this.getAriaExplanatoryTextManager().GetErrorTextElement();
8952  var input = this.getInputElement();
8953  var invalidArg =  { "aria-invalid": !this.control.isValid ? "true" : "" };
8954  this.changeActivityAttributes(input, invalidArg);
8955  if(errorTextElement)
8956   this.getAriaExplanatoryTextManager().SetOrRemoveText([input], errorTextElement, !this.control.isValid, false, true);
8957 },
8958 getMainElement: function() {
8959  if(!ASPx.IsExistsElement(this.mainElement))
8960   this.mainElement = this.control.GetAccessibilityAssistantElement();
8961  return this.mainElement;
8962 },
8963 changeActivityAttributes: function(element, args) {
8964  if(!element)
8965   return;
8966  for(var key in args) {
8967   if(args.hasOwnProperty(key)) {
8968    var value = args[key];
8969    if(key == "innerHtml")
8970     ASPx.SetInnerHtml(element, value);
8971    else {
8972     var action = value !== "" ? ASPx.Attr.SetAttribute : ASPx.Attr.RemoveAttribute;
8973     action(element, key, value);
8974    }
8975   }
8976  }
8977 },
8978 getPronounceTimeout: function() { return this.pronounceMessageTimeout; },
8979 getInputElement: function() { return this.control.GetInputElement(); },
8980 getAriaExplanatoryTextManager: function() { return this.control.ariaExplanatoryTextManager; }
8981});
8982var AccessibilityHelper = ASPx.CreateClass(AccessibilityHelperBase, {
8983 constructor: function(control) {
8984  this.constructor.prototype.constructor.call(this, control);
8985  this.activeItem = this.getItems()[0];
8986 },
8987 PronounceMessageCore: function(text, activeItemArgs, inactiveItemArgs, mainElementArgs, ownerMainElement) {
8988  if(!this.getItems())
8989   return;
8990  this.toogleItem();
8991  var mainElement = this.getMainElement();
8992  var activeItem = this.getItem(true);
8993  var inactiveItem = this.getItem();
8994  if(ASPx.Attr.GetAttribute(mainElement, "role") != "application")
8995   mainElementArgs = this.addArguments(mainElementArgs, { "aria-activedescendant" : activeItem.id });
8996  var messageAttrObj = {};
8997  var activeItemRole = ASPx.Attr.GetAttribute(activeItem, "role");
8998  var attrName = activeItemRole == "combobox" ? "aria-label" : "innerHtml";
8999  messageAttrObj[attrName] = ASPx.Str.EncodeHtml(text);
9000  activeItemArgs = this.addArguments(activeItemArgs, messageAttrObj);
9001  messageAttrObj[attrName] = "";
9002  inactiveItemArgs = this.addArguments(inactiveItemArgs, messageAttrObj);
9003  var errorTextElement = null;
9004  if(this.control.GetErrorCell()) {
9005   errorTextElement = this.getAriaExplanatoryTextManager().GetErrorTextElement();
9006   activeItemArgs = this.addArguments(activeItemArgs,   {"aria-invalid"  : !this.control.isValid ? "true" : "" });
9007   mainElementArgs = this.addArguments(mainElementArgs, { "aria-invalid" : "" });
9008   inactiveItemArgs = this.addArguments(inactiveItemArgs,  { "aria-invalid" : "" });
9009  }
9010  this.changeActivityAttributes(activeItem, activeItemArgs);
9011  if(errorTextElement) {
9012   this.getAriaExplanatoryTextManager().SetOrRemoveText([activeItem], errorTextElement, !this.control.isValid, false, true);
9013   this.getAriaExplanatoryTextManager().SetOrRemoveText([mainElement, inactiveItem], errorTextElement, false, false, false);
9014  }
9015  this.changeActivityAttributes(mainElement, mainElementArgs);
9016  if(!!ownerMainElement && ASPx.Attr.GetAttribute(ownerMainElement, "role") != "application")
9017   this.changeActivityAttributes(ownerMainElement, { "aria-activedescendant": activeItem.id });
9018  this.changeActivityAttributes(inactiveItem, inactiveItemArgs);
9019  this.pronounceIsStarted = false;
9020 },
9021 GetPronounceElement: function() {
9022  return this.getItem(true);
9023 },
9024 getItems: function() {
9025  if(!ASPx.IsExistsElement(this.items))
9026   this.items = ASPx.GetChildElementNodes(this.getMainElement());
9027  return this.items;
9028 },
9029 getItem: function(isActive) {
9030  if(isActive)
9031   return this.activeItem;
9032  var items = this.getItems();

9033  return items[0] === this.activeItem ? items[1] : items[0];
9034 },
9035 toogleItem: function() {
9036  this.activeItem = this.getItem();
9037 },
9038 addArguments: function(targetArgs, newArgs) {
9039  if(!targetArgs) targetArgs = { };
9040  for(var key in newArgs) {
9041   if(newArgs.hasOwnProperty(key) && !targetArgs.hasOwnProperty(key))
9042    targetArgs[key] = newArgs[key];
9043  }
9044  return targetArgs;
9045 }
9046});
9047var AccessibilityPronouncer = ASPx.CreateClass(null, {
9048 constructor: function() {
9049  this.pronouncerId = "dxPronouncer";
9050  this.initialized = false;
9051  this.focusableMessageElement = null;
9052  this.messageElement = null;
9053  this.pronouncers = {
9054   live: new AccessibilityLivePronouncer(this),
9055   descendant: new AccessibilityDescendantPronouncer(this)
9056  };
9057 },
9058 Pronounce: function(args, type) {
9059  this.pronouncers[type].Pronounce(args);
9060 },
9061 EnsureInitialize: function() {
9062  if(!this.initialized)
9063   this.initialize();
9064 },
9065 RemoveState: function() {
9066  for(var pronouncer in this.pronouncers)
9067   if(this.pronouncers.hasOwnProperty(pronouncer))
9068    pronouncer.RemoveState();
9069 },
9070 RestoreControlState: function(type, mainElement) {
9071  this.pronouncers[type].RestoreControlState(mainElement);
9072 },
9073 RestoreElementsState: function(type, elements) {
9074  this.pronouncers[type].RestoreElementsState(elements);
9075 },
9076 RestoreElementState: function(type, element) {
9077  this.pronouncers[type].RestoreElementState(element);
9078 },
9079 initialize: function() {
9080  this.createFocusableMessageElement();
9081  this.createMessageElement();
9082  this.prepareFocusableMessageElement();
9083  this.setAttributesForKeyboardNavigation();
9084  this.initialized = true;
9085 },
9086 createFocusableMessageElement: function() {
9087  var focusableMessageElement = document.createElement("DIV");
9088  document.body.appendChild(focusableMessageElement);
9089  this.focusableMessageElement = focusableMessageElement;   
9090 },
9091 prepareFocusableMessageElement: function() {
9092  this.focusableMessageElement.className = "dxAIFME";
9093 },
9094 setAttributesForKeyboardNavigation: function() {
9095  ASPx.Attr.Aria.SetApplicationRole(this.focusableMessageElement);
9096  ASPx.Attr.Aria.SetSilence(this.focusableMessageElement);
9097 },
9098 createMessageElement: function() {
9099  var messageElement = document.createElement("DIV");
9100  messageElement.id = this.pronouncerId;
9101  ASPx.Attr.SetAttribute(messageElement, "role", "note");
9102  this.focusableMessageElement.appendChild(messageElement);
9103  this.messageElement = messageElement;
9104 },
9105 getMessage: function(messagePartsArg) {
9106  var messageParts = messagePartsArg.filter(function(x) { return ASPx.IsExists(x); });
9107  return messageParts.join(", ");
9108 }
9109});
9110var AccessibilityPronouncerBase = ASPx.CreateClass(null, {
9111 constructor: function() {
9112  this.state = { };
9113 },
9114 Pronounce: function(args) {
9115  var messageElement = this.getMessageElement();
9116  ASPx.Attr.Aria.SetOrRemoveLabel(messageElement);
9117  ASPx.SetInnerHtml(messageElement, "");
9118  this.PronounceCore(args);
9119 },
9120 PronounceCore: function(args) { },
9121 SaveElementState: function(element) { 
9122  if(this.state[element.id])
9123   return;
9124  this.state[element.id] = {
9125   element: element,
9126   descendant: ASPx.Attr.GetAttribute(element, ASPx.Attr.Aria.descendant)
9127  };
9128 },
9129 RemoveState: function() {
9130  this.state = { };
9131 },
9132 RestoreControlState: function(mainElement) { 
9133  for(var elementInfo in this.state) {
9134   if(this.state.hasOwnProperty(elementInfo)) {
9135    var element = this.state[elementInfo].element;
9136    if(!mainElement || ASPx.GetIsParent(mainElement, element))
9137     this.RestoreElementState(element);
9138   }
9139  }
9140 },
9141 RestoreElementsState: function(elements) { 
9142  for(var i = 0; i < elements.length; i++)
9143   this.RestoreElementState(elements[i]);
9144 },
9145 RestoreElementState: function(element) {
9146  var elementState = this.state[element.id];
9147  if(!elementState)
9148   return;
9149  ASPx.Attr.Aria.SetOrRemoveDescendant(element, elementState.descendant);
9150  delete this.state[element.id];
9151 },
9152 getMessage: function(args) {
9153  return ASPx.AccessibilityPronouncer.getMessage(args.messageParts);
9154 },
9155 getMessageElement: function() {
9156  return ASPx.AccessibilityPronouncer.messageElement;
9157 },
9158 getFocusableMessageElement: function() {
9159   return ASPx.AccessibilityPronouncer.focusableMessageElement;
9160 }
9161});
9162var AccessibilityLivePronouncer = ASPx.CreateClass(AccessibilityPronouncerBase, {
9163 constructor: function() {
9164  this.constructor.prototype.constructor.call(this);
9165 },
9166 PronounceCore: function(args) {

9167  var message = this.getMessage(args);
9168  var messageElement = this.getMessageElement();
9169  ASPx.Attr.SetAttribute(this.getFocusableMessageElement(), "aria-live", "assertive");
9170  ASPx.Attr.Aria.SetAtomic(this.getFocusableMessageElement(), "true");
9171  ASPx.SetInnerHtml(messageElement, ASPx.Str.EncodeHtml(message));
9172 }
9173});
9174var AccessibilityDescendantPronouncer = ASPx.CreateClass(AccessibilityPronouncerBase, {
9175 constructor: function() {
9176  this.constructor.prototype.constructor.call(this);
9177 },
9178 PronounceCore: function(args) {
9179  var message = this.getMessage(args);
9180  var activeElement = ASPx.GetActiveElement();
9181  var messageElement = this.getMessageElement();
9182  this.SaveElementState(activeElement);
9183  ASPx.Attr.RemoveAttribute(this.getFocusableMessageElement(), "aria-live");
9184  ASPx.Attr.RemoveAttribute(this.getFocusableMessageElement(), "aria-atomic");
9185  ASPx.Attr.Aria.SetOrRemoveLabel(messageElement, message);
9186  ASPx.Attr.Aria.SetOrRemoveDescendant(activeElement, messageElement.id);
9187 }
9188});
9189ASPx.AccessibilityPronouncerType = {
9190 live: "live",
9191 descendant: "descendant"
9192};
9193ASPx.AccessibilityPronouncer = new AccessibilityPronouncer();
9194var RestoreFocusHelper = ASPx.CreateClass(null, {
9195 constructor: function() {
9196  this.excludedIDs = [ "DXCBtn" ]; 
9197  this.pronouncerType = ASPx.AccessibilityPronouncerType.live;
9198  this.callbackQueue = [];
9199  this.Initialize();
9200 },
9201 Initialize: function() {
9202  var that = this;
9203  ASPx.attachToLoad(function() {
9204   ASPxClientControl.GetControlCollection().BeginCallback.AddHandler(that.OnBeginCallback, that);
9205   ASPxClientControl.GetControlCollection().EndCallback.AddHandler(that.OnEndCallback, that);
9206  });
9207 },
9208 OnBeginCallback: function(s, e) {
9209  var control = e.control;
9210  if(!control.allowRestoreFocusOnCallbacks())
9211   return;
9212  control.accessibilityFocusTreeLine = this.getFocusTreeLine(control);
9213  var controlHasCallbackTreeLine = this.callbackQueueContainsTreeLine(control);
9214  this.pushTreeLineInfoIntoCallbackQueue(control);
9215  if(control.accessibilityFocusTreeLine && !controlHasCallbackTreeLine)
9216   control.SendMessageToAssistiveTechnology(this.getDefaultCallbackMessage());
9217 },
9218 OnEndCallback: function(s, e) {
9219  var control = e.control;
9220  if(!control.allowRestoreFocusOnCallbacks())
9221   return;
9222  var treeLineInfo = this.shiftTreeLineInfoFromCallbackQueue(control);
9223  if(treeLineInfo.queueLength == 0) {
9224   if(!control.accessibilityFocusTreeLine && treeLineInfo.treeLine)
9225    control.accessibilityFocusTreeLine = treeLineInfo.treeLine;
9226   var focusElement = this.findFocusElement(control);
9227   var focusIsManagerByPopupwindow = this.isFocusManagedByActivePopupWindow(focusElement);
9228   var focusIsManagedByControl = control.shouldPreventFocusRestoringOnCallback && control.shouldPreventFocusRestoringOnCallback();
9229   if(!focusIsManagerByPopupwindow && !focusIsManagedByControl)
9230    ASPx.AccessibilityUtils.SetFocusAccessible(focusElement);
9231   delete control.accessibilityFocusTreeLine;
9232  }
9233 },
9234 pushTreeLineInfoIntoCallbackQueue: function(control) {
9235  var controlTreeLine = control.accessibilityFocusTreeLine ? control.accessibilityFocusTreeLine.slice(0) : null;
9236  if(!this.callbackQueue[control.name])
9237   this.callbackQueue[control.name] = [];
9238  this.callbackQueue[control.name].push(controlTreeLine);
9239 },
9240 shiftTreeLineInfoFromCallbackQueue: function(control) {
9241  var treeLineInfo = { queueLength: 0, treeLine: null };
9242  var treeLines = this.callbackQueue[control.name];
9243  if(treeLines && treeLines.length > 0) {
9244   treeLineInfo.treeLine = treeLines.shift();
9245   var linesCount = treeLines.length;
9246   treeLineInfo.queueLength = linesCount;
9247   if(linesCount > 0 && !treeLines[0] && treeLineInfo.treeLine)
9248    treeLines[0] = treeLineInfo.treeLine.slice(0);
9249  }
9250  return treeLineInfo;
9251 },
9252 callbackQueueContainsTreeLine: function(control) {
9253  var treeLines = this.callbackQueue[control.name];
9254  if(!treeLines || treeLines.length == 0) 
9255   return false;
9256  if(treeLines[treeLines.length - 1])
9257   return true;
9258  return false;
9259 },
9260 getDefaultCallbackMessage: function() {
9261  return ASPx.AccessibilitySR.DefaultCallbackMessage;
9262 },
9263 isFocusManagedByActivePopupWindow: function(focusElement) {
9264  var popupControl = this.getActivePopupControl();
9265  if(!popupControl || popupControl.accessibleFocusElement)
9266   return false;
9267  this.initializePopupAccessibleFocusElement(popupControl, focusElement);
9268  return popupControl.setFocusOnCallback;
9269 },
9270 getActivePopupControl: function() {
9271  var activePopupWindow = ASPx.GetPopupControlCollection && ASPx.GetPopupControlCollection().GetCurrentActiveWindowElement();
9272  if(!activePopupWindow)
9273   return null;
9274  var popupInfo = ASPx.GetPopupControlCollection().GetPopupWindowFromID(activePopupWindow.id);
9275  return popupInfo.popupControl;
9276 },
9277 initializePopupAccessibleFocusElement: function(popupControl, focusElement) {
9278  if(popupControl.setFocusOnCallback)
9279   popupControl.accessibleFocusElement = focusElement;
9280  else {
9281   var parentControl = popupControl.GetParentControl();
9282   if(parentControl && parentControl.GetMainElement())
9283    popupControl.accessibleFocusElement = ASPx.FindFirstChildActionElement(parentControl.GetMainElement());
9284  }
9285 },
9286 getFocusTreeLine: function(control) {
9287  var element = ASPx.GetActiveElement();
9288  if(!ASPx.IsExistsElement(element))
9289   return null;
9290  var mainElement = control.GetMainElement();
9291  if(!ASPx.GetIsParent(mainElement, element)) {
9292   var treeInfo = this.findFocusedControlElement(mainElement, element);
9293   element = treeInfo.focusElement;
9294   mainElement = treeInfo.rootElement;
9295  }
9296  return this.getTreeLineCore(mainElement, element);
9297 },
9298 getTreeLineCore: function(mainElement, element) {
9299  if(!element) return null;
9300  treeLine = [ ];
9301  while(element) {
9302   treeLine.push({ 

9303    id: element.id,
9304    tagName: element.tagName,
9305    index: ASPx.Data.ArrayIndexOf(element.parentNode.childNodes, element)
9306   });
9307   if(element === mainElement || element === document.body)
9308    break;
9309   element = element.parentNode;
9310  }
9311  return treeLine;
9312 },
9313 findFocusedControlElement: function(mainElement, activeElement) {
9314  var element = null;
9315  var parentElement = mainElement;
9316  var focusedEditor = ASPx.IsExists(ASPx.GetFocusedEditor) ? ASPx.GetFocusedEditor() : null;
9317  if(focusedEditor && ASPx.GetIsParent(mainElement, focusedEditor.GetMainElement()))
9318   element = focusedEditor.GetFocusableInputElement();
9319  else {
9320   if(mainElement && activeElement) {
9321    var mainControl = ASPx.GetClientControlByElementID(mainElement.id);
9322    var parentControls = ASPx.GetParentClientControls(activeElement.id);
9323    for(var i = parentControls.length - 1; i > -1; i--) {   
9324     if(mainControl.name == parentControls[i].name) {
9325      element = activeElement;
9326      var rootIndex = i > 0 ? i - 1 : i;
9327      parentElement = parentControls[rootIndex].GetMainElement();
9328      if(!parentElement && parentControls[rootIndex].GetCurrentWindowElement)
9329       parentElement = parentControls[rootIndex].GetCurrentWindowElement();
9330      break;
9331     }
9332    }
9333   }
9334  }
9335  return { focusElement: element, rootElement: parentElement }; 
9336 },
9337 findFocusElement: function(control) {
9338  if(!control.accessibilityFocusTreeLine)
9339   return;
9340  var treeLine = control.accessibilityFocusTreeLine.slice(0);
9341  var focusElementParent = this.findFocusElementParentById(treeLine);
9342  if(!focusElementParent) 
9343   return;
9344  return this.findFocusElementFromDOMTree(treeLine, focusElementParent);
9345 },
9346 findFocusElementParentById: function(treeLine) {
9347  for(var i = 0; i < treeLine.length; i++) {
9348   var id = treeLine[i].id;
9349   if(!this.isValidId(id))
9350    continue;
9351   var element = document.getElementById(id);
9352   if(element) {
9353    treeLine.splice(i, treeLine.length - i);
9354    treeLine.reverse();
9355    return element;
9356   }
9357  }
9358  return null;
9359 },
9360 findFocusElementFromDOMTree: function(treeLine, focusElementParent) {
9361  var element = focusElementParent;
9362  for(var i = 0; i < treeLine.length; i++) {
9363   var info = treeLine[i];
9364   if(info.index >= element.childNodes.length) {
9365    element = element.childNodes.length > 0 ? element.childNodes[element.childNodes.length - 1] : null;
9366    return this.findNeighbourFocusElement(element, focusElementParent);
9367   }
9368   var child = element.childNodes[info.index];
9369   if(child.tagName !== info.tagName)
9370    return this.findNeighbourFocusElement(child, focusElementParent);
9371   element = child;
9372  }
9373  return element;
9374 },
9375 findNeighbourFocusElement: function(element, focusElementParent) {
9376  ASPx.ActionElementsCache.BeginUsage();
9377  var result = this.findNeighbourFocusElementCore(element, focusElementParent);
9378  ASPx.ActionElementsCache.EndUsage();
9379  return result;
9380 },
9381 findNeighbourFocusElementCore: function(element, focusElementParent) {
9382  if(!element || !element.parentNode) return null;
9383  var neighbours = element.parentNode.childNodes;
9384  var indices = this.calcLeftRightIndices(ASPx.Data.ArrayIndexOf(neighbours, element), neighbours.length);
9385  for(var i = 0; i < indices.length; i++) {
9386   var index = indices[i];
9387   var actionElement = ASPx.FindFirstChildActionElement(neighbours[index]);
9388   if(actionElement)
9389    return actionElement;
9390  }
9391  if(element === focusElementParent)
9392   return null;
9393  return this.findNeighbourFocusElement(element.parentNode, focusElementParent);
9394 },
9395 calcLeftRightIndices: function(startIndex, count) {
9396  var indices = [ ];
9397  var incSides = [ 0, 0 ];
9398  var index = startIndex;
9399  for(var i = 0; i < count; i++) {
9400   indices.push(index);
9401   var even = i % 2 === 0;
9402   var nextIndex = this.calcNextIndex(startIndex, count, incSides, even);
9403   if(nextIndex < 0)
9404    nextIndex = this.calcNextIndex(startIndex, count, incSides, !even);
9405   index = nextIndex;
9406  }
9407  return indices;
9408 },
9409 calcNextIndex: function(startIndex, count, incSides, even) {
9410  var sideIndex = even ? 0 : 1;
9411  var inc = incSides[sideIndex];
9412  inc += even ? -1 : 1;
9413  var nextIndex = startIndex + inc;
9414  if(nextIndex >= 0 && nextIndex < count) {
9415   incSides[sideIndex] = inc;
9416   return nextIndex;
9417  }
9418  return -1;
9419 },
9420 isValidId: function(id) {
9421  return id && !this.isExcludedId(id);
9422 },
9423 isExcludedId: function(id) {
9424  var result = false;
9425  for(var i = 0; i < this.excludedIDs.length; i++) {
9426   if(id.indexOf(this.excludedIDs[i]) > -1) {
9427    result = true;
9428    break;
9429   }
9430  }
9431  return result;
9432 }
9433});
9434var EventStorage = ASPx.CreateClass(null, {
9435 constructor: function() {
9436  this.bag = { };
9437 },
9438 Save: function(e, data, overwrite) {
9439  var key = this.getEventKey(e);
9440  if(this.bag.hasOwnProperty(key) && !overwrite)
9441   return;
9442  this.bag[key] = data;
9443  window.setTimeout(function() { delete this.bag[key]; }.aspxBind(this), 100);
9444 },
9445 Load: function(e) {
9446  var key = this.getEventKey(e);
9447  return this.bag[key];
9448 },
9449 getEventKey: function(e) {
9450  if(ASPx.IsExists(e.timeStamp))
9451   return e.timeStamp.toString();
9452  var eventSource = ASPx.Evt.GetEventSource(e);
9453  var type = e.type.toString();
9454  return eventSource ? type + "_" + eventSource.uniqueID.toString() : type;
9455 }
9456});
9457ASPx.RestoreFocusHelper = new RestoreFocusHelper();
9458EventStorage.Instance = null;
9459EventStorage.getInstance = function() {
9460 if(!EventStorage.Instance)
9461  EventStorage.Instance = new EventStorage();
9462 return EventStorage.Instance;
9463};
9464var GetGlobalObject = function(objectName) {
9465 var fields = objectName.split('.');
9466 var obj = window[fields[0]];
9467 for(var i = 1;

9467 obj && i < fields.length; i++) {
9468  obj = obj[fields[i]];
9469 }
9470 return obj;
9471};
9472var GetExternalScriptProcessor = function() {
9473 return ASPx.ExternalScriptProcessor ? ASPx.ExternalScriptProcessor.getInstance() : null;
9474};
9475var SAVED_WIDTH_ATTR = "data-dx-ripple-saved-width";
9476var RIPPLE_FIXED_ROW_ATTR = "data-dx-ripple-locked";
9477var READ_ONLY_COMBOBOX_MARKER_CSS_CLASS = "dxICBReadonlyMarker";
9478var ThemesWithRipple = ['Material'];
9479var RippleHelper = {
9480 rippleTargetClassName: "dxRippleTarget",
9481 rippleTargetExternalClassName: "dxRippleTargetExternal",
9482 rippleContainerClassName: "dxRippleContainer",
9483 rippleClassName: "dxRipple",
9484 touchRadius: -1,
9485 isMobileExternalRipple: null,
9486 zoom: 1,
9487 Init: function() {
9488  if(this.getIsRippleFunctionalityEnabled()) {
9489   setTimeout(function() {
9490    this.calcTouchRadius();
9491   }.aspxBind(this), 0);
9492  }
9493 },
9494 calcTouchRadius: function() {
9495  var testBlock = document.createElement("DIV");
9496  ASPx.SetStyles(testBlock, {
9497   height: "1in",
9498   width: "1in",
9499   left: "-100%",
9500   top: "-100%",
9501   position: "absolute"
9502  });
9503  document.body.appendChild(testBlock);
9504  this.touchRadius = (1.8 / 2.54) * Math.max(testBlock.offsetWidth, testBlock.offsetHeight);
9505  document.body.removeChild(testBlock);
9506 },
9507 isRippleFunctionalityEnabled: null,
9508 checkRippleFunctionality: function() {
9509  if(ASPx.Browser.Safari && ASPx.Browser.Version <= 5.1)
9510   return false;
9511  for(var i = 0; i < ThemesWithRipple.length; i++) {
9512   var firstRippleThemeElement = document.querySelector("[class*='_" + ThemesWithRipple[i] + "']");
9513   if(firstRippleThemeElement)
9514    return true;
9515  }  
9516  return false;
9517 },
9518 ReInit: function() {
9519  this.isRippleFunctionalityEnabled = null;
9520  this.Init();
9521 },
9522 onDocumentMouseDown: function(evt) {
9523  if(RippleHelper.getIsRippleFunctionalityEnabled())
9524   RippleHelper.processMouseDown(evt);
9525 },
9526 getIsRippleFunctionalityEnabled: function() {
9527  if(!ASPx.IsExists(this.isRippleFunctionalityEnabled))
9528   this.isRippleFunctionalityEnabled = this.checkRippleFunctionality();
9529  return this.isRippleFunctionalityEnabled;
9530 },
9531   createTargetInfo: function(target) {
9532  return { 
9533   x: ASPx.GetAbsoluteX(target),
9534   y: ASPx.GetAbsoluteY(target),
9535   width: target.offsetWidth,
9536   height: target.offsetHeight,
9537   classNames: ASPx.GetClassNameList(target),
9538   getTarget: function() { return target; },
9539   getRect: function() { return {x: this.x, y: this.y, width: this.width, height: this.height }; }
9540  };
9541 },
9542 createEventInfo: function(evt) {
9543  return { x: this.getEventX(evt), y: this.getEventY(evt) };
9544 },
9545 processMouseDown: function(evt) {
9546  var evtSource = ASPx.Evt.GetEventSource(evt);
9547  var rippleTarget = this.getRippleTargetElement(evtSource);
9548  if(this.needToProcessRipple(rippleTarget, evtSource))
9549   this.processRipple(this.createTargetInfo(rippleTarget), this.createEventInfo(evt));
9550 },
9551 getRippleTargetElement: function(evtSource) {
9552  if(this.hasRippleMarker(evtSource))
9553   return evtSource;
9554  if(evtSource.tagName && evtSource.tagName.toLowerCase() == "input" && ASPx.ElementContainsCssClass(evtSource, "dxTI")) {
9555   var elements = ASPx.GetChildElementNodesByPredicate(evtSource.parentNode.parentNode, function(element) {
9556    return this.hasRippleMarker(element);
9557   }.aspxBind(this));
9558   return elements && elements[0];
9559  }
9560  return ASPx.GetParent(evtSource, function(element) {
9561   return this.hasRippleMarker(element);
9562  }.aspxBind(this));
9563 },
9564 hasRippleMarker: function(element) {
9565  if(!ASPx.IsExistsElement(element))
9566   return false;
9567  var computedStyles = window.getComputedStyle(element, ":before");
9568  if(ASPx.IsExists(computedStyles)) {
9569   var content = computedStyles.getPropertyValue("content");
9570   if(content.indexOf(this.rippleTargetExternalClassName) > -1) {
9571    ASPx.AddClassNameToElement(element, this.rippleTargetExternalClassName);
9572    return true;
9573   }
9574   return content.indexOf(this.rippleTargetClassName) > -1;
9575  }
9576  return false;
9577 },
9578 needToProcessRipple: function(rippleTarget, evtSource) {
9579  if(!rippleTarget || !ASPx.AnimationUtils)
9580   return false;
9581  var isClearButton = ASPx.ElementContainsCssClass(rippleTarget, "dxeButton") && rippleTarget.id && rippleTarget.id.indexOf("B-100") !== -1;
9582  var isEmptyCalendarDay = ASPx.ElementContainsCssClass(rippleTarget, "dxeCalendarDay") && ASPx.Str.Trim(rippleTarget.textContent) == "";
9583  var isReadonly = ASPx.ElementContainsCssClass(rippleTarget, READ_ONLY_COMBOBOX_MARKER_CSS_CLASS);
9584  var tempFixDisable = ASPx.ElementContainsCssClass(rippleTarget, "dxSwitcher") && ASPx.Browser.MacOSMobilePlatform;
9585  var rippleIsForbidden = isReadonly || isClearButton || isEmptyCalendarDay || ASPx.GetParentByPartialClassName(rippleTarget, "Disabled") ||
9586   ASPx.ElementContainsCssClass(rippleTarget, "dxgvBatchEditCell") || ASPx.ElementContainsCssClass(rippleTarget, "dxcvEditForm") ||
9587   ASPx.GetParentByPartialClassName(evtSource, "dxcvFocusedCell") || tempFixDisable;
9588  return !rippleIsForbidden;
9589 },
9590 hasBothOverflow: function(style) {
9591  return style.overflow == "scroll" || style.overflow == "auto" || style.overflow == "hidden";
9592 },
9593 hasOverflowX: function(style) {
9594  return style.overflowX == "scroll" || style.overflowX == "auto" || style.overflowX == "hidden";
9595 },
9596 hasOverflowY: function(style) {
9597  return style.overflowY == "scroll" || style.overflowY == "auto" || style.overflowY == "hidden";
9598 },
9599 getExternalRippleContainerSize: function(targetRect) {
9600  if(ASPx.Browser.MobileUI) {
9601   var origTouchRadius = this.getOriginTouchRadius();
9602   if(origTouchRadius < targetRect.width || origTouchRadius < targetRect.height)
9603    origTouchRadius = Math.max(targetRect.width, targetRect.height);
9604   return {x: targetRect.x + (targetRect.width - origTouchRadius) / 2, y: targetRect.y + (targetRect.height - origTouchRadius) / 2, width: origTouchRadius, height: origTouchRadius };
9605  }
9606  var result = { x: 0, y: 0, width: 0, height: 0 };
9607  var diff = targetRect.width - targetRect.height;
9608  if(diff > 0) {
9609   result.x = targetRect.x;
9610   result.y = targetRect.y - diff / 2;
9611   result.width = targetRect.width;
9612   result.height = targetRect.width;
9613  } else {
9614   result.x = targetRect.x + diff / 2;
9615   result.y = targetRect.y;
9616   result.width = targetRect.height;
9617   result.height = targetRect.height;
9618  }
9619  return result;
9620 },
9621 getInternalContainerSize: function(targetInfo) {
9622  var parentWithOverflow = RippleHelper.getParentWithOverflow(targetInfo.getTarget());
9623  if(!ASPx.IsExists(parentWithOverflow))
9624   return targetInfo;
9625  var parentWithOverflowStyle = ASPx.GetCurrentStyle(parentWithOverflow);
9626  var bothOverflow = this.hasBothOverflow(parentWithOverflowStyle);
9627  var overflowX = this.hasOverflowX(parentWithOverflowStyle);
9628  var overflowY = this.hasOverflowY(parentWithOverflowStyle);
9629  var parentRect = {
9630   x: ASPx.GetAbsoluteX(parentWithOverflow),
9631   y: ASPx.GetAbsoluteY(parentWithOverflow),
9632   width: parentWithOverflow.offsetWidth,
9633   height: parentWithOverflow.offsetHeight
9634  };
9635  return this.getInternalContainerSizeCore(targetInfo, parentRect, bothOverflow, overflowX, overflowY);
9636 },
9637 getInternalContainerSizeCore: function(targetRect, parentRect, bothOverflow, overflowX, overflowY) {
9638  var result = {};
9639  ASPx.Data.MergeHashTables(result, targetRect);
9640  if(bothOverflow || overflowX) {
9641   result.x = targetRect.x < parentRect.x ? parentRect.x : targetRect.x;
9642   if(targetRect.x + targetRect.width > parentRect.x + parentRect.width)
9643    result.width = parentRect.x + parentRect.width - targetRect.x;
9644   if(parentRect.x > targetRect.x)
9645    result.width -= (parentRect.x - targetRect.x);
9646  }
9647  if(bothOverflow || overflowY) {
9648   result.y = targetRect.y < parentRect.y ? parentRect.y : targetRect.y;
9649   if(targetRect.y + targetRect.height > parentRect.y + parentRect.height)
9650    result.height = parentRect.y + parentRect.height - targetRect.y;
9651   if(parentRect.y > targetRect.y)
9652    result.height -= (parentRect.y - targetRect.y);
9653  }
9654  return result;
9655 },
9656 calculateRippleContainerSize: function(targetInfo, isExternalRipple) {
9657  return isExternalRipple ? this.getExternalRippleContainerSize(targetInfo) : this.getInternalContainerSize(targetInfo);
9658 },
9659 getParentWithOverflow: function(rippleTarget) {
9660  var result = ASPx.GetParent(rippleTarget, function(element) {
9661   var elementStyle = ASPx.GetCurrentStyle(element);
9662   return this.hasBothOverflow(elementStyle) || this.hasOverflowX(elementStyle) || this.hasOverflowY(elementStyle);
9663  }.aspxBind(this));
9664  return result;
9665 },
9666 getDuration: function(targetInfo) {
9667  return this.IsExternalRipple(targetInfo) || ASPx.Browser.MobileUI ? 650 : 450;
9668 },
9669 createRippleTransition: function(container, rippleElement, radius, targetInfo) {
9670  var rippleSize = 2 * radius;
9671  var transitionProperties = {
9672   width: { from: 0, to: rippleSize, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "width", unit: "px" },
9673   height: { from: 0, to: rippleSize, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "height", unit: "px" },
9674   marginLeft: { from: 0, to: -rippleSize / 2, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "marginLeft", unit: "px" },
9675   marginTop: { from: 0, to: -rippleSize / 2, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "marginTop", unit: "px" },
9676   opacity: { from: 1, to: 0.05, transition: ASPx.AnimationConstants.Transitions.RIPPLE, propName: "o

9676pacity", unit: "%" }
9677  };
9678  var rippleTransition = ASPx.AnimationUtils.createMultipleAnimationTransition(rippleElement, {
9679   transition: ASPx.AnimationConstants.Transitions.RIPPLE,
9680   duration: this.getDuration(targetInfo),
9681   needForceTransitionEndByTimerFlag: true, 
9682   onComplete: function() {
9683    this.RemoveRippleContainer(container.parentElement);
9684   }.bind(this)
9685  });
9686  rippleTransition.Start(transitionProperties);
9687 },
9688 needForceTransitionEndByTimer: function() { return true; }, 
9689 calculateRadius: function(isExternalRipple, posX, posY, containerRect) {
9690  var radius = -1;
9691  if(isExternalRipple) {
9692   if(ASPx.Browser.MobileUI)
9693    radius = this.getOriginTouchRadius() / 2;
9694   else
9695    radius = Math.max(containerRect.height, containerRect.width);
9696  } else {
9697   var width1 = posX - containerRect.x;
9698   var width2 = containerRect.width - width1;
9699   var height1 = posY - containerRect.y;
9700   var height2 = containerRect.height - height1;
9701   var rippleWidth = Math.max(width1, width2);
9702   var rippleHeight = Math.max(height1, height2);
9703   radius = Math.sqrt(Math.pow(rippleHeight, 2) + Math.pow(rippleWidth, 2));
9704  }
9705  return radius;
9706 },
9707 createRippleElement: function(container, rippleCenter) {
9708  var rippleElement = document.createElement("DIV");
9709  rippleElement.className = this.rippleClassName;
9710  container.appendChild(rippleElement);
9711  ASPxClientUtils.SetAbsoluteX(rippleElement, rippleCenter.x);
9712  ASPxClientUtils.SetAbsoluteY(rippleElement, rippleCenter.y);
9713  return rippleElement;
9714 },
9715 processRipple: function(targetInfo, eventInfo) {
9716  this.initRippleProcess();
9717  var isExternalRipple = this.IsExternalRipple(targetInfo);
9718  var rippleCenter = this.getRippleCenter(targetInfo.getRect(), eventInfo, isExternalRipple);
9719  var container = this.createRippleContainer(targetInfo, isExternalRipple);
9720  var rippleElement = this.createRippleElement(container, rippleCenter);
9721  var radius = this.calculateRadius(isExternalRipple, rippleCenter.x, rippleCenter.y, this.getElementRect(container));
9722  this.createRippleTransition(container, rippleElement, radius, targetInfo);
9723 },
9724 initRippleProcess: function() {
9725  this.isMobileExternalRipple = null;
9726  this.zoom = screen.width / window.innerWidth;
9727 },
9728 getRippleCenter: function(targetInfo, eventInfo, isExternalRipple) {
9729  var posX = 0;
9730  var posY = 0;
9731  if(isExternalRipple) {
9732   posX = targetInfo.x + targetInfo.width / 2;
9733   posY = targetInfo.y + targetInfo.height / 2;
9734  } else {
9735   posX = eventInfo.x;
9736   posY = eventInfo.y;
9737  }
9738  return {x: posX, y: posY};
9739 },
9740 createRippleContainer: function(targetInfo, isExternalRipple) {
9741  var containerParent = targetInfo.getTarget();
9742  if(!containerParent)
9743   return;
9744  var containerTagName = containerParent.tagName == "TR" ? "TD" : "DIV";
9745  var container = document.createElement(containerTagName);
9746  container.className = this.rippleContainerClassName;
9747  if(containerParent.parentNode && containerParent.tagName == "IMG")
9748   containerParent = containerParent.parentNode;
9749  if(this.isARowInFixedLayoutTable(containerParent))
9750   this.lockFixedLayoutTableSizes(containerParent);
9751  containerParent.appendChild(container);
9752  if(isExternalRipple)
9753   container.style.borderRadius = "50%";
9754  var containerRect = this.calculateRippleContainerSize(targetInfo, isExternalRipple);
9755  this.assignContainerSettings(container, containerRect);
9756  return container;
9757 },
9758 isARowInFixedLayoutTable: function(containerParent) {
9759  if(containerParent.tagName !== "TR")
9760   return false;
9761  var parentTable = this.getParentTable(containerParent);
9762  return parentTable && ASPx.GetCurrentStyle(parentTable)["table-layout"] === "fixed";
9763 },
9764 processFirstRowOfFixedTable: function(containerRow, rowAction, cellAction) {
9765  var firstRow = this.getFirstRow(containerRow);
9766  rowAction(firstRow);
9767  var cells = ASPx.Data.CollectionToArray(firstRow.cells);
9768  cells.forEach(cellAction);
9769 },
9770 getParentTable: function(element) {
9771  var parentTable = element;
9772  while(parentTable && parentTable.tagName !== "TABLE")
9773   parentTable = parentTable.parentElement;
9774  return parentTable;
9775 },
9776 lockFixedLayoutTableSizes: function(containerRow) {
9777  var firstRow = this.getFirstRow(containerRow);
9778  if(this.incLockCount(firstRow) === 1) {
9779   var cells = ASPx.Data.CollectionToArray(firstRow.cells);
9780   var widths = cells.map(function(cell) { return cell.style.width; });
9781   var computedWidths = cells.map(function(cell) {
9782    return window.getComputedStyle(cell).width;
9783   });
9784   var fixWidth = function(cell, i) {
9785    if(ASPx.Attr.IsExistsAttribute(cell, SAVED_WIDTH_ATTR))
9786     return;
9787    if(widths[i])
9788     ASPx.Attr.SetAttribute(cell, SAVED_WIDTH_ATTR, widths[i]);
9789    cell.style.width = computedWidths[i];
9790   };

9791   cells.forEach(fixWidth);
9792  }
9793 }, 
9794 unlockFixedLayoutTableSizes: function(containerRow) {
9795  var firstRow = this.getFirstRow(containerRow);   
9796  if(this.decLockCount(firstRow) === 0) {
9797   var cells = ASPx.Data.CollectionToArray(firstRow.cells);
9798   var restoreState = function(cell) {
9799    if(ASPx.Attr.IsExistsAttribute(cell, SAVED_WIDTH_ATTR)) {
9800     cell.style.width = ASPx.Attr.GetAttribute(cell, SAVED_WIDTH_ATTR);
9801     ASPx.Attr.RemoveAttribute(cell, SAVED_WIDTH_ATTR);
9802    } else {
9803     cell.style.width = null;
9804    }
9805   };
9806   cells.forEach(restoreState);
9807  }
9808 },
9809 getFirstRow: function(containerRow) { return ASPx.GetChildByTagName(containerRow.parentElement, "TR", 0); },
9810 incLockCount: function(elem) { return this.changeLockCount(elem, 1); },
9811 decLockCount: function(elem) { return this.changeLockCount(elem, -1); },
9812 changeLockCount: function(elem, diff) {
9813  var lockCounter = this.getLockCount(elem);
9814  lockCounter += diff;
9815  lockCounter = Math.max(0, lockCounter);
9816  if(lockCounter === 0)
9817   ASPx.Attr.RemoveAttribute(elem, RIPPLE_FIXED_ROW_ATTR);
9818  else
9819   ASPx.Attr.SetAttribute(elem, RIPPLE_FIXED_ROW_ATTR, lockCounter);
9820  return lockCounter;
9821 },
9822 getLockCount: function(lockElement) {
9823  var attrValue = ASPx.Attr.GetAttribute(lockElement, RIPPLE_FIXED_ROW_ATTR);
9824  return parseInt(attrValue) || 0;
9825 },
9826 assignContainerSettings: function(container, containerRect) {
9827  var properties = {
9828   height: containerRect.height,
9829   width: containerRect.width,
9830   left: ASPx.PrepareClientPosForElement(containerRect.x, container, true),
9831   top: ASPx.PrepareClientPosForElement(containerRect.y, container, false)
9832  };
9833  if(ASPx.Browser.MobileUI)
9834   ASPx.Data.MergeHashTables(properties, {marginTop: 0, marginLeft: 0 });
9835  ASPx.SetStyles(container, properties, ASPx.Browser.MobileUI);
9836 },
9837 IsExternalRipple: function(targetInfo) {
9838  var hasExternalRippleClassName = ASPx.ElementContainsCssClass(targetInfo.getTarget(), this.rippleTargetExternalClassName);
9839  if(!ASPx.Browser.MobileUI)
9840   return hasExternalRippleClassName;
9841  return hasExternalRippleClassName || this.IsMobileExternalRipple(targetInfo);
9842 },
9843 IsMobileExternalRipple: function(targetInfo) {
9844  if(this.isMobileExternalRipple == null) {
9845   var originTouchRadius = this.getOriginTouchRadius();
9846   this.isMobileExternalRipple = ASPx.Browser.MobileUI && targetInfo.width < originTouchRadius && targetInfo.height < originTouchRadius;
9847  }
9848  return this.isMobileExternalRipple;
9849 },
9850 RemoveRippleContainer: function(element) {
9851  if(!element)
9852   return;
9853  var childs = ASPx.GetChildNodesByClassName(element, this.rippleContainerClassName);
9854  var rippleContainer = childs.length > 0 ? childs[0] : null;
9855  if(rippleContainer != null) {
9856   var containerParent = rippleContainer.parentNode;
9857   containerParent.removeChild(rippleContainer);
9858   if(this.isARowInFixedLayoutTable(containerParent))
9859    this.unlockFixedLayoutTableSizes(containerParent);
9860  }
9861 },
9862 getEventX: function(evt) {
9863  return ASPxClientUtils.GetEventX(evt);
9864 },
9865 getEventY: function(evt) {
9866  return ASPxClientUtils.GetEventY(evt);
9867 },
9868 getOriginTouchRadius: function() {
9869  return this.touchRadius / this.zoom;
9870 },
9871 getElementRect: function(element) {
9872  return { x: ASPx.GetAbsoluteX(element), y: ASPx.GetAbsoluteY(element), width: element.offsetWidth, height: element.offsetHeight };
9873 }
9874};
9875var AccessibilitySR = {
9876 AddStringResources: function(stringResourcesObj) {
9877  if(stringResourcesObj) {
9878   for(var key in stringResourcesObj)
9879    if(stringResourcesObj.hasOwnProperty(key))
9880     this[key] = stringResourcesObj[key];
9881  }
9882 }
9883};
9884ASPx.OrderedMap = OrderedMap;
9885ASPx.CollectionBase = CollectionBase;
9886ASPx.FunctionIsInCallstack = _aspxFunctionIsInCallstack;
9887ASPx.RaisePostHandlerOnPost = aspxRaisePostHandlerOnPost;
9888ASPx.GetPostHandler = aspxGetPostHandler;
9889ASPx.ProcessScriptsAndLinks = _aspxProcessScriptsAndLinks;
9890ASPx.InitializeLinks = _aspxInitializeLinks;
9891ASPx.InitializeScripts = _aspxInitializeScripts;
9892ASPx.RunStartupScripts = _aspxRunStartupScripts;
9893ASPx.IsStartupScriptsRunning = _aspxIsStartupScriptsRunning;
9894ASPx.AddScriptsRestartHandler = _aspxAddScriptsRestartHandler;
9895ASPx.GetFocusedElement = _aspxGetFocusedElement;
9896ASPx.GetDomObserver = _aspxGetDomObserver;

9897ASPx.CacheHelper = CacheHelper;
9898ASPx.ControlTree = ControlTree;
9899ASPx.ControlAdjuster = ControlAdjuster;
9900ASPx.GetControlAdjuster = GetControlAdjuster;
9901ASPx.ControlCallbackHandlersQueue = ControlCallbackHandlersQueue;
9902ASPx.ResourceManager = ResourceManager;
9903ASPx.UpdateWatcherHelper = UpdateWatcherHelper;
9904ASPx.EventStorage = EventStorage;
9905ASPx.GetGlobalObject = GetGlobalObject;
9906ASPx.GetExternalScriptProcessor = GetExternalScriptProcessor;
9907ASPx.CheckBoxCheckState = CheckBoxCheckState;
9908ASPx.CheckBoxInputKey = CheckBoxInputKey;
9909ASPx.CheckableElementStateController = CheckableElementStateController;
9910ASPx.CheckableElementHelper = CheckableElementHelper;
9911ASPx.CheckBoxInternal = CheckBoxInternal;
9912ASPx.CheckBoxInternalCollection = CheckBoxInternalCollection;
9913ASPx.ControlCallbackQueueHelper = ControlCallbackQueueHelper;
9914ASPx.FocusedStyleDecoration = FocusedStyleDecoration;
9915ASPx.EditorStyleDecoration = EditorStyleDecoration;
9916ASPx.TextEditorStyleDecoration = TextEditorStyleDecoration;
9917ASPx.AccessibilitySR = AccessibilitySR;
9918ASPx.KbdHelper = KbdHelper;
9919ASPx.AccessKeysHelper = AccessKeysHelper;
9920ASPx.AccessKey = AccessKey;
9921ASPx.IFrameHelper = IFrameHelper;
9922ASPx.Ident = Ident;
9923ASPx.TouchUIHelper = TouchUIHelper;
9924ASPx.ControlUpdateWatcher = ControlUpdateWatcher;
9925ASPx.ControlTabIndexManager = ControlTabIndexManager;
9926ASPx.AccessibilityHelperBase = AccessibilityHelperBase;
9927ASPx.AccessibilityHelper = AccessibilityHelper;
9928ASPx.RippleHelper = RippleHelper;
9929ASPx.ThemesWithRipple = ThemesWithRipple;
9930ASPx.NetworkError = NetworkError;
9931window.ASPxClientEvent = ASPxClientEvent;
9932window.ASPxClientEventArgs = ASPxClientEventArgs;
9933window.ASPxClientCancelEventArgs = ASPxClientCancelEventArgs;
9934window.ASPxClientProcessingModeEventArgs = ASPxClientProcessingModeEventArgs;
9935window.ASPxClientProcessingModeCancelEventArgs = ASPxClientProcessingModeCancelEventArgs;
9936ASPx.Evt.AttachEventToDocument(TouchUIHelper.touchMouseDownEventName, RippleHelper.onDocumentMouseDown);
9937ASPx.classesScriptParsed = true;
9938})(ASPx, { GCCheckInterval: 5000 });
9939
9940(function () {
9941 IntersectionObserversManager = ASPx.CreateClass(null, {
9942  constructor: function() {
9943   this.rootElementToObserverMap = this.createMap();
9944   this.elementToHandlerMap = this.createMap();
9945   this.clearInvalidElementsInterval = null;
9946   this.clearInvalidElementsPeriod = 5000;
9947  },
9948  AddTargetElement: function(element, rootElement, visibilityChangedHandler) {
9949   this.addTargetElementCore(element, rootElement, visibilityChangedHandler);
9950  },
9951  SubscribeElemensVisibilityChangeInBrowserWindow: function (element, visibilityChangedHandler) {
9952   this.addTargetElementCore(element, null, visibilityChangedHandler);
9953  },
9954  createMap: function() {
9955   return new Map();
9956  },
9957  getObserver: function() {
9958   return IntersectionObserver;
9959  },
9960  initializeObserver: function(rootElement) {
9961   if(!this.rootElementToObserverMap.get(rootElement)) {
9962    var options = {
9963     root: rootElement,
9964     rootMargin: '-1px',
9965     threshold: 0.0 
9966    };
9967    var observerClass = this.getObserver();
9968    var observer = new observerClass(this.visibilityChanged.bind(this), options);
9969    this.rootElementToObserverMap.set(rootElement, observer);
9970   }
9971  },
9972  addTargetElementCore: function(element, rootElement, visibilityChangedHandler) {
9973   this.initializeObserver(rootElement);
9974   if(!this.isAlreadyObserved(element)) {
9975    var observer = this.rootElementToObserverMap.get(rootElement);
9976    if(observer) {
9977     observer.observe(element);
9978     this.setObservedMarker(element);
9979     this.setElementVisibilityChangedHandler(element, visibilityChangedHandler, observer);
9980     if(this.clearInvalidElementsInterval === null) {
9981      this.clearInvalidElementsInterval = setInterval(this.removeDeletedElements.bind(this), this.clearInvalidElementsPeriod);
9982     }
9983    }
9984   }
9985  },
9986  visibilityChanged: function(entries, observer) {
9987   entries.forEach(function (entry) {
9988    if(ASPx.IsExistsElement(entry.target)){
9989     var element = this.elementToHandlerMap.get(observer);
9990     if(element) {
9991      var handler = element.get(entry.target);
9992      if(handler)
9993       handler(entry.isIntersecting);
9994     }
9995    }
9996   }.bind(this));
9997  },
9998  removeDeletedElements: function() {

9999   this.elementToHandlerMap.forEach(function(elements, observer) {
10000    elements.forEach(function(handler, element) {
10001     if(!ASPx.IsExistsElement(element)) {
10002      elements.delete(element);
10003     }
10004    }.bind(this));
10005    if(elements.size === 0) {
10006     this.elementToHandlerMap.delete(observer);
10007    }
10008   }.bind(this));
10009   if(this.elementToHandlerMap.size === 0) {
10010    clearInterval(this.clearInvalidElementsInterval);
10011    this.clearInvalidElementsInterval = null;
10012   }
10013  },
10014  setElementVisibilityChangedHandler: function(element, visibilityChangedHandler, observer) {
10015   if(!this.elementToHandlerMap.get(observer))
10016    this.elementToHandlerMap.set(observer, this.createMap());
10017   var el = this.elementToHandlerMap.get(observer);
10018   if(el)
10019    el.set(element, visibilityChangedHandler);
10020  },
10021  isAlreadyObserved: function(element) {
10022   return !!element.dxObserved;
10023  },
10024  setObservedMarker: function(element) {
10025   element.dxObserved = true;
10026  },
10027  reset: function() {
10028   this.rootElementToObserverMap.forEach(function(observer, rootElement) {
10029    observer.disconnect();
10030   }.bind(this));
10031   this.rootElementToObserverMap = this.createMap();
10032   this.elementToHandlerMap = this.createMap();
10033   this.clearInvalidElementsInterval = null;
10034   this.clearInvalidElementsPeriod = 5000;
10035  }
10036 });
10037 IntersectionObserversManagerForOldBrowsers = ASPx.CreateClass(null, {
10038  SubscribeElemensVisibilityChangeInBrowserWindow: function() { }
10039 });
10040 ASPx.IntersectionObserversManager = ASPx.IntersectionObserversManager || ((typeof(IntersectionObserver) !== "undefined") ? new IntersectionObserversManager() : new IntersectionObserversManagerForOldBrowsers());
10041}
10042)(ASPx);
10043
10044(function () {
10045ASPx.StateItemsExist = false;
10046ASPx.FocusedItemKind = "FocusedStateItem";
10047ASPx.HoverItemKind = "HoverStateItem";
10048ASPx.PressedItemKind = "PressedStateItem";
10049ASPx.SelectedItemKind = "SelectedStateItem";
10050ASPx.DisabledItemKind = "DisabledStateItem";
10051ASPx.ReadOnlyItemKind = "ReadOnlyStateItem";
10052ASPx.CachedStatePrefix = "cached";
10053ASPxStateItem = ASPx.CreateClass(null, {
10054 constructor: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, kind, disableApplyingStyleToLink){
10055  this.name = name;
10056  this.classNames = classNames;
10057  this.customClassNames = [];
10058  this.resultClassNames = [];
10059  this.cssTexts = cssTexts;
10060  this.postfixes = postfixes;
10061  this.imageObjs = imageObjs;
10062  this.imagePostfixes = imagePostfixes;
10063  this.kind = kind;
10064  this.classNamePostfix = kind.substr(0, 1).toLowerCase();
10065  this.enabled = true;
10066  this.needRefreshBetweenElements = false;
10067  this.elements = null;
10068  this.images = null;
10069  this.links = [];
10070  this.colorChanged = [];
10071  this.textDecorationChanged = [];
10072  this.disableApplyingStyleToLink = !!disableApplyingStyleToLink; 
10073 },
10074 GetCssText: function(index){
10075  if(ASPx.IsExists(this.cssTexts[index]))
10076   return this.cssTexts[index];
10077  return this.cssTexts[0];
10078 },
10079 CreateStyleRule: function(index){
10080  if(this.GetCssText(index) == "") return "";
10081  var styleSheet = ASPx.GetCurrentStyleSheet();
10082  if(styleSheet)
10083   return ASPx.CreateImportantStyleRule(styleSheet, this.GetCssText(index), this.classNamePostfix);  
10084  return ""; 
10085 },
10086 GetClassName: function(index){
10087  if(ASPx.IsExists(this.classNames[index]))
10088   return this.classNames[index];
10089  return this.classNames[0];
10090 },
10091 GetResultClassName: function(index){
10092  if(!ASPx.IsExists(this.resultClassNames[index])) {
10093   if(!ASPx.IsExists(this.customClassNames[index]))
10094    this.customClassNames[index] = this.CreateStyleRule(index);
10095   if(this.GetClassName(index) != "" && this.customClassNames[index] != "")
10096    this.resultClassNames[index] = this.GetClassName(index) + " " + this.customClassNames[index];
10097   else if(this.GetClassName(index) != "")
10098    this.resultClassNames[index] = this.GetClassName(index);
10099   else if(this.customClassNames[index] != "")
10100    this.resultClassNames[index] = this.customClassNames[index];
10101   else
10102    this.resultClassNames[index] = "";
10103  }
10104  return this.resultClassNames[index];
10105 },
10106 GetElements: function(element){
10107  if(!this.elements || !ASPx.IsValidElements(this.elements)){
10108   if(this.postfixes && this.postfixes.length > 0){
10109    this.elements = [ ];
10110    var parentNode = element.parentNode;
10111    if(parentNode){

10112     for(var i = 0; i < this.postfixes.length; i++){
10113      var id = this.name + this.postfixes[i];
10114      this.elements[i] = ASPx.GetChildById(parentNode, id);
10115      if(!this.elements[i])
10116       this.elements[i] = ASPx.GetElementById(id);
10117     }
10118    }
10119   }
10120   else
10121    this.elements = [element];
10122  }
10123  return this.elements;
10124 },
10125 GetImages: function(element){
10126  if(!this.images || !ASPx.IsValidElements(this.images)){
10127   this.images = [ ];
10128   if(this.imagePostfixes && this.imagePostfixes.length > 0){
10129    var elements = this.GetElements(element);
10130    for(var i = 0; i < this.imagePostfixes.length; i++){
10131     var id = this.name + this.imagePostfixes[i];
10132     for(var j = 0; j < elements.length; j++){
10133      if(!elements[j]) continue;
10134      if(elements[j].id == id)
10135       this.images[i] = elements[j];
10136      else
10137       this.images[i] = ASPx.GetChildById(elements[j], id);
10138      if(this.images[i])
10139       break;
10140     }
10141    }
10142   }
10143  }
10144  return this.images;
10145 },
10146 Apply: function(element){
10147  if(!this.enabled) return;
10148  try{
10149   this.ApplyStyle(element);
10150   if(this.imageObjs && this.imageObjs.length > 0)
10151    this.ApplyImage(element);
10152  }
10153  catch(e){
10154  }
10155 },
10156 ApplyStyle: function(element){
10157  var elements = this.GetElements(element);
10158  for(var i = 0; i < elements.length; i++){
10159   if(!elements[i]) continue;
10160   var elementColor, elementTextDecoration;
10161   if(this.colorChanged[i] === undefined) {
10162    elementColor = window.getComputedStyle(elements[i]).color;
10163   }
10164   if(this.textDecorationChanged[i] === undefined) {
10165    elementTextDecoration = window.getComputedStyle(elements[i]).textDecoration;
10166   }
10167   if(this.GetResultClassName(i) != "") {
10168    var className = elements[i].className.replace(this.GetResultClassName(i), "");
10169    elements[i].className = ASPx.Str.Trim(className) + " " + this.GetResultClassName(i);
10170   }
10171   if(this.colorChanged[i] === undefined) {
10172    this.colorChanged[i] = window.getComputedStyle(elements[i]).color !== elementColor;
10173   }
10174   if(this.textDecorationChanged[i] === undefined) {
10175    this.textDecorationChanged[i] = window.getComputedStyle(elements[i]).textDecoration !== elementTextDecoration;
10176   }
10177   if(!ASPx.Browser.Opera || ASPx.Browser.Version >= 9)
10178    this.ApplyStyleToLinks(elements, i);
10179  }
10180 },
10181 ApplyStyleToLinks: function(elements, index){
10182  if(this.disableApplyingStyleToLink)
10183   return;
10184  if(!ASPx.IsValidElements(this.links[index]))
10185   this.links[index] = ASPx.GetNodesByTagName(elements[index], "A");
10186  for(var i = 0; i < this.links[index].length; i++)
10187   this.ApplyStyleToLinkElement(this.links[index][i], index);
10188 },
10189 ApplyStyleToLinkElement: function(link, index) {
10190  if(this.colorChanged[index])
10191   ASPx.Attr.ChangeAttributeExtended(link.style, "color", link, "saved" + this.kind + "Color", "inherit");
10192  if(this.textDecorationChanged[index])
10193   ASPx.Attr.ChangeAttributeExtended(link.style, "text-decoration", link, "saved" + this.kind + "TextDecoration", "inherit");
10194 },
10195 ApplyImage: function(element){
10196  var images = this.GetImages(element);
10197  for(var i = 0; i < images.length; i++){
10198   if(!images[i] || !this.imageObjs[i]) continue;
10199   var useSpriteImage = typeof(this.imageObjs[i]) != "string";
10200   var newUrl = "", newCssClass = "", newBackground = "";
10201   if(useSpriteImage){
10202    newUrl = ASPx.EmptyImageUrl;           
10203    if(this.imageObjs[i].spriteCssClass) 
10204     newCssClass = this.imageObjs[i].spriteCssClass;

10205    if(this.imageObjs[i].spriteBackground)
10206     newBackground = this.imageObjs[i].spriteBackground;
10207   }
10208   else{
10209    newUrl = this.imageObjs[i];
10210    if(ASPx.Attr.IsExistsAttribute(images[i].style, "background"))   
10211     newBackground = " ";
10212   }
10213   if(newUrl != "")
10214    ASPx.Attr.ChangeAttributeExtended(images[i], "src", images[i], "saved" + this.kind + "Src", newUrl);
10215   if(newCssClass != "")
10216    this.ApplyImageClassName(images[i], newCssClass);
10217   if(newBackground != ""){
10218    if(ASPx.Browser.WebKitFamily) {
10219     var savedBackground = ASPx.Attr.GetAttribute(images[i].style, "background");
10220     if(!useSpriteImage)
10221      savedBackground += " " + images[i].style["backgroundPosition"];
10222     ASPx.Attr.SetAttribute(images[i], "saved" + this.kind + "Background", savedBackground);
10223     ASPx.Attr.SetAttribute(images[i].style, "background", newBackground);
10224    }
10225    else
10226     ASPx.Attr.ChangeAttributeExtended(images[i].style, "background", images[i], "saved" + this.kind + "Background", newBackground);
10227   }     
10228  }
10229 },
10230 ApplyImageClassName: function(element, newClassName){
10231  if(ASPx.Attr.GetAttribute(element, "saved" + this.kind + "ClassName"))
10232   this.CancelImageClassName(element);
10233  var className = element.className;
10234  ASPx.Attr.SetAttribute(element, "saved" + this.kind + "ClassName", className);
10235  element.className = className + " " + newClassName;
10236 },
10237 Cancel: function(element){
10238  if(!this.enabled) return;
10239  try{  
10240   if(this.imageObjs && this.imageObjs.length > 0)
10241    this.CancelImage(element);
10242   this.CancelStyle(element);
10243  }
10244  catch(e){
10245  }
10246 },
10247 CancelStyle: function(element){
10248  var elements = this.GetElements(element);
10249  for(var i = 0; i < elements.length; i++){
10250   if(!elements[i]) continue;
10251   if(this.GetResultClassName(i) != "") {
10252    var className = ASPx.Str.Trim(elements[i].className.replace(this.GetResultClassName(i), ""));
10253    elements[i].className = className;
10254   }
10255   if(!ASPx.Browser.Opera || ASPx.Browser.Version >= 9)
10256    this.CancelStyleFromLinks(elements, i);
10257  }
10258 },
10259 CancelStyleFromLinks: function(elements, index){
10260  if(this.disableApplyingStyleToLink)
10261   return;
10262  if(!ASPx.IsValidElements(this.links[index]))
10263   this.links[index] = ASPx.GetNodesByTagName(elements[index], "A");
10264  for(var i = 0; i < this.links[index].length; i++)
10265   this.CancelStyleFromLinkElement(this.links[index][i], index);
10266 },
10267 CancelStyleFromLinkElement: function(link, index){
10268  ASPx.Attr.RestoreAttributeExtended(link.style, "color", link, "saved" + this.kind + "Color");
10269  ASPx.Attr.RestoreAttributeExtended(link.style, "text-decoration", link, "saved" + this.kind + "TextDecoration");
10270 },
10271 CancelImage: function(element){
10272  var images = this.GetImages(element);
10273  for(var i = 0; i < images.length; i++){
10274   if(!images[i] || !this.imageObjs[i]) continue;
10275   ASPx.Attr.RestoreAttributeExtended(images[i], "src", images[i], "saved" + this.kind + "Src");
10276   this.CancelImageClassName(images[i]);
10277   ASPx.Attr.RestoreAttributeExtended(images[i].style, "background", images[i], "saved" + this.kind + "Background");
10278  }
10279 },
10280 CancelImageClassName: function(element){
10281  var savedClassName = ASPx.Attr.GetAttribute(element, "saved" + this.kind + "ClassName");
10282  if(ASPx.IsExists(savedClassName)) {
10283   element.className = savedClassName;
10284   ASPx.Attr.RemoveAttribute(element, "saved" + this.kind + "ClassName");
10285  }
10286 },
10287 Clone: function(){
10288  return new ASPxStateItem(this.name, this.classNames, this.cssTexts, this.postfixes, 
10289   this.imageObjs, this.imagePostfixes, this.kind, this.disableApplyingStyleToLink);
10290 },
10291 IsChildElement: function(element){
10292  if(element != null){
10293   var elements = this.GetElements(element);
10294   for(var i = 0; i < elements.length; i++){
10295    if(!elements[i]) continue;
10296    if(ASPx.GetIsParent(elements[i], element)) 
10297     return true;
10298   }
10299  }
10300  return false;
10301 },
10302 ForceRedrawAppearance: function(element) {
10303  if(!aspxGetStateController().IsForceRedrawAppearanceLocked()) {
10304   var value = element.style.opacity;
10305   element.style.opacity = "0.7777";
10306   var dummy = element.offsetWidth;
10307   element.style.opacity = value;
10308  }
10309 }
10310});
10311ASPxClientStateEventArgs = ASPx.CreateClass(null, {
10312 constructor: function(item, element){
10313  this.item = item;
10314  this.element = element;
10315  this.toElement = null;
10316  this.fromElement = null;
10317  this.htmlEvent = null;
10318 }
10319});
10320ASPxStateController = ASPx.CreateClass(null, {
10321 constructor: function(){
10322  this.focusedItems = { };
10323  this.hoverItems = { };
10324  this.pressedItems = { };
10325  this.selectedItems = { };
10326  this.disabledItems = {};
10327  this.readOnlyItems = {};
10328  this.disabledScheme = {};
10329  this.currentFocusedElement = null;
10330  this.currentFocusedItemName = null;
10331  this.currentHoverElement = null;
10332  this.currentHoverItemName = null;
10333  this.currentPressedElement = null;
10334  this.currentPressedItemName = null;
10335  this.savedCurrentPressedElement = null;
10336  this.savedCurrentMouseMoveSrcElement = null;
10337  this.forceRedrawAppearanceLockCount = 0;
10338  this.stateItemType = ASPxStateItem;
10339  this.AfterSetFocusedState = new ASPxClientEvent();
10340  this.AfterClearFocusedState = new ASPxClientEvent();
10341  this.AfterSetHoverState = new ASPxClientEvent();
10342  this.AfterClearHoverState = new ASPxClientEvent();
10343  this.AfterSetPressedState = new ASPxClientEvent();
10344  this.AfterClearPressedState = new ASPxClientEvent();
10345  this.AfterDisabled = new ASPxClientEvent();
10346  this.AfterEnabled = new ASPxClientEvent();
10347  this.BeforeSetFocusedState = new ASPxClientEvent();
10348  this.BeforeClearFocusedState = new ASPxClientEvent();
10349  this.BeforeSetHoverState = new ASPxClientEvent();
10350  this.BeforeClearHoverState = new ASPxClientEvent();
10351  this.BeforeSetPressedState = new ASPxClientEvent();
10352  this.BeforeClearPressedState = new ASPxClientEvent();
10353  this.BeforeDisabled = new ASPxClientEvent();
10354  this.BeforeEnabled = new ASPxClientEvent();
10355  this.FocusedItemKeyDown = new ASPxClientEvent();
10356 }, 
10357 AddHoverItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink){
10358  this.AddItem(this.hoverItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.HoverItemKind, disableApplyingStyleToLink);
10359  this.AddItem(this.focusedItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.FocusedItemKind, disableApplyingStyleToLink);
10360 },
10361 AddPressedItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink){
10362  this.AddItem(this.pressedItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.PressedItemKind, disableApplyingStyleToLink);
10363 },
10364 AddSelectedItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink){
10365  this.AddItem(this.selectedItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.SelectedItemKind, disableApplyingStyleToLink);
10366 },
10367 AddDisabledItem: function (name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink, rootId) {
10368  this.AddItem(this.disabledItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes,
10369   ASPx.DisabledItemKind, disableApplyingStyleToLink, this.addIdToDisabledItemScheme, rootId);
10370 },
10371 AddReadOnlyItem: function(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink) {
10372  this.AddItem(this.readOnlyItems, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, ASPx.ReadOnlyItemKind, disableApplyingStyleToLink);
10373 },
10374 addIdToDisabledItemScheme: function(rootId, childId) {
10375  if (!rootId)
10376   return;
10377  if (!this.disabledScheme[rootId])
10378   this.disabledScheme[rootId] = [rootId];

10379  if (childId && (rootId != childId) && ASPx.Data.ArrayIndexOf(this.disabledScheme[rootId], childId) == -1)
10380   this.disabledScheme[rootId].push(childId);
10381 },
10382 removeIdFromDisabledItemScheme: function(rootId, childId) {
10383  if (!rootId || !this.disabledScheme[rootId])
10384   return;
10385  ASPx.Data.ArrayRemove(this.disabledScheme[rootId], childId);
10386  if (this.disabledScheme[rootId].length == 0)
10387   delete this.disabledScheme[rootId];
10388 },
10389 AddItem: function (items, name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, kind, disableApplyingStyleToLink, onAdd, rootId) {
10390  var type = this.getStateItemType();
10391  var stateItem = new type(name, classNames, cssTexts, postfixes, imageObjs, imagePostfixes, kind, disableApplyingStyleToLink);
10392  if (postfixes && postfixes.length > 0) {
10393   for (var i = 0; i < postfixes.length; i++) {
10394    items[name + postfixes[i]] = stateItem;
10395    if (onAdd)
10396     onAdd.call(this, rootId, name + postfixes[i]);
10397   }
10398  }
10399  else {
10400   if (onAdd)
10401    onAdd.call(this, rootId, name);
10402   items[name] = stateItem;
10403  }
10404  ASPx.StateItemsExist = true;
10405 },
10406 getStateItemType: function () { return this.stateItemType; },
10407 withCustomStateItemType: function (newType, callback) {
10408  this.stateItemType = newType;
10409  callback(this);
10410  this.stateItemType = ASPxStateItem;
10411 },
10412 RemoveHoverItem: function(name, postfixes){
10413  this.RemoveItem(this.hoverItems, name, postfixes);
10414  this.RemoveItem(this.focusedItems, name, postfixes);
10415 },
10416 RemovePressedItem: function(name, postfixes){
10417  this.RemoveItem(this.pressedItems, name, postfixes);
10418 },
10419 RemoveSelectedItem: function(name, postfixes){
10420  this.RemoveItem(this.selectedItems, name, postfixes);
10421 },
10422 RemoveDisabledItem: function (name, postfixes, rootId) {
10423  this.RemoveItem(this.disabledItems, name, postfixes, this.removeIdFromDisabledItemScheme, rootId);
10424 },
10425 RemoveReadOnlyItem: function(name, postfixes) {
10426  this.RemoveItem(this.readOnlyItems, name, postfixes);
10427 },
10428 RemoveItem: function (items, name, postfixes, onRemove, rootId) {
10429  if (postfixes && postfixes.length > 0) {
10430   for (var i = 0; i < postfixes.length; i++) {
10431    delete items[name + postfixes[i]];
10432    if (onRemove)
10433     onRemove.call(this, rootId, name + postfixes[i]);
10434   }
10435  }
10436  else {
10437   delete items[name];
10438   if (onRemove)
10439    onRemove.call(this, rootId, name);
10440  }
10441 },
10442 RemoveDisposedItems: function(){
10443  this.RemoveDisposedItemsByType(this.hoverItems);
10444  this.RemoveDisposedItemsByType(this.pressedItems);
10445  this.RemoveDisposedItemsByType(this.focusedItems);
10446  this.RemoveDisposedItemsByType(this.selectedItems);
10447  this.RemoveDisposedItemsByType(this.disabledItems);
10448  this.RemoveDisposedItemsByType(this.disabledScheme);
10449  this.RemoveDisposedItemsByType(this.readOnlyItems);
10450 },
10451 RemoveDisposedItemsByType: function(items){
10452  for(var key in items) {
10453   if(items.hasOwnProperty(key)) {
10454    var item = items[key];
10455    var element = document.getElementById(key);
10456    if(!element || !ASPx.IsValidElement(element))
10457     delete items[key];
10458    try {
10459     if(item && item.elements) {
10460      for(var i = 0; i < item.elements.length; i++) {
10461       if(!ASPx.IsValidElements(item.links[i]))
10462        item.links[i] = null;
10463      }
10464     }
10465    }
10466    catch(e) {
10467    }
10468   }
10469  }
10470 },
10471 GetFocusedElement: function(srcElement){
10472  return this.GetItemElement(srcElement, this.focusedItems, ASPx.FocusedItemKind);
10473 },
10474 GetHoverElement: function(srcElement){
10475  return this.GetItemElement(srcElement, this.hoverItems, ASPx.HoverItemKind);
10476 },
10477 GetPressedElement: function(srcElement){
10478  return this.GetItemElement(srcElement, this.pressedItems, ASPx.PressedItemKind);
10479 },
10480 GetSelectedElement: function(srcElement){
10481  return this.GetItemElement(srcElement, this.selectedItems, ASPx.SelectedItemKind);
10482 },
10483 GetDisabledElement: function(srcElement){
10484  return this.GetItemElement(srcElement, this.disabledItems, ASPx.DisabledItemKind);
10485 },
10486 GetReadOnlyElement: function(srcElement) {
10487  return this.GetItemElement(srcElement, this.readOnlyItems, ASPx.ReadOnlyItemKind);
10488 },
10489 GetItemElement: function(srcElement, items, kind){
10490  if(srcElement && srcElement[ASPx.CachedStatePrefix + kind]){
10491   var cachedElement = srcElement[ASPx.CachedStatePrefix + kind];
10492   if(cachedElement != ASPx.EmptyObject)
10493    return cachedElement;
10494   return null;
10495  }
10496  var element = srcElement;
10497  while(element != null) {

10498   var item = items[element.id];
10499   if(item){
10500    this.CacheItemElement(srcElement, kind, element);
10501    element[kind] = item;
10502    return element;
10503   }
10504   element = element.parentNode;
10505  }
10506  this.CacheItemElement(srcElement, kind, ASPx.EmptyObject);
10507  return null;
10508 },
10509 CacheItemElement: function(srcElement, kind, value){
10510  if(srcElement && !srcElement[ASPx.CachedStatePrefix + kind])
10511   srcElement[ASPx.CachedStatePrefix + kind] = value;
10512 },
10513 DoSetFocusedState: function(element, fromElement){
10514  var item = element[ASPx.FocusedItemKind];
10515  if(item){
10516   var args = new ASPxClientStateEventArgs(item, element);
10517   args.fromElement = fromElement;
10518   this.BeforeSetFocusedState.FireEvent(this, args);
10519   item.Apply(element);
10520   this.AfterSetFocusedState.FireEvent(this, args);
10521  }
10522 },
10523 DoClearFocusedState: function(element, toElement){
10524  var item = element[ASPx.FocusedItemKind];
10525  if(item){
10526   var args = new ASPxClientStateEventArgs(item, element);
10527   args.toElement = toElement;
10528   this.BeforeClearFocusedState.FireEvent(this, args);
10529   item.Cancel(element);
10530   this.AfterClearFocusedState.FireEvent(this, args);
10531  }
10532 },
10533 DoSetHoverState: function(element, fromElement){
10534  var item = element[ASPx.HoverItemKind];
10535  if(item){
10536   var args = new ASPxClientStateEventArgs(item, element);
10537   args.fromElement = fromElement;
10538   this.BeforeSetHoverState.FireEvent(this, args);
10539   item.Apply(element);
10540   this.AfterSetHoverState.FireEvent(this, args);
10541  }
10542 },
10543 DoClearHoverState: function(element, toElement){
10544  var item = element[ASPx.HoverItemKind];
10545  if(item){
10546   var args = new ASPxClientStateEventArgs(item, element);
10547   args.toElement = toElement;
10548   this.BeforeClearHoverState.FireEvent(this, args);
10549   item.Cancel(element);
10550   this.AfterClearHoverState.FireEvent(this, args);
10551  }
10552 },
10553 DoSetPressedState: function(element){
10554  var item = element[ASPx.PressedItemKind];
10555  if(item){
10556   var args = new ASPxClientStateEventArgs(item, element);
10557   this.BeforeSetPressedState.FireEvent(this, args);
10558   item.Apply(element);
10559   this.AfterSetPressedState.FireEvent(this, args);
10560  }
10561 },
10562 DoClearPressedState: function(element){
10563  var item = element[ASPx.PressedItemKind];
10564  if(item){
10565   var args = new ASPxClientStateEventArgs(item, element);
10566   this.BeforeClearPressedState.FireEvent(this, args);
10567   item.Cancel(element);
10568   this.AfterClearPressedState.FireEvent(this, args);
10569  }
10570 },
10571 SetCurrentFocusedElement: function(element){
10572  if(this.currentFocusedElement && !ASPx.IsValidElement(this.currentFocusedElement)){
10573   this.currentFocusedElement = null;
10574   this.currentFocusedItemName = "";
10575  }
10576  if(this.currentFocusedElement != element){
10577   var oldCurrentFocusedElement = this.currentFocusedElement;
10578   var item = (element != null) ? element[ASPx.FocusedItemKind] : null;
10579   var itemName = (item != null) ? item.name : "";
10580   if(this.currentFocusedItemName != itemName){
10581    if(this.currentHoverItemName != "")
10582     this.SetCurrentHoverElement(null);
10583    if(this.currentFocusedElement != null)
10584     this.DoClearFocusedState(this.currentFocusedElement, element);
10585    this.currentFocusedElement = element;
10586    item = (element != null) ? element[ASPx.FocusedItemKind] : null;
10587    this.currentFocusedItemName = (item != null) ? item.name : "";
10588    if(this.currentFocusedElement != null)
10589     this.DoSetFocusedState(this.currentFocusedElement, oldCurrentFocusedElement);
10590   }
10591  }
10592 },
10593 GetCurrentHoverElement: function() {
10594  return this.currentHoverElement;
10595 },
10596 SetCurrentHoverElement: function(element){
10597  if(this.currentHoverElement && !ASPx.IsValidElement(this.currentHoverElement)){
10598   this.currentHoverElement = null;
10599   this.currentHoverItemName = "";
10600  }
10601  var item = (element != null) ? element[ASPx.HoverItemKind] : null;
10602  if(item && !item.enabled) { 
10603   element = this.GetItemElement(element.parentNode, this.hoverItems, ASPx.HoverItemKind);
10604   item = (element != null) ? element[ASPx.HoverItemKind] : null;
10605  }
10606  if(this.currentHoverElement != element){
10607   var oldCurrentHoverElement = this.currentHoverElement,
10608    itemName = (item != null) ? item.name : "";
10609   if(this.currentHoverItemName != itemName || (item != null && item.needRefreshBetweenElements)){
10610    if(this.currentHoverElement != null)
10611     this.DoClearHoverState(this.currentHoverElement, element);
10612    item = (element != null) ? element[ASPx.HoverItemKind] : null;
10613    if(item == null || item.enabled){
10614     this.currentHoverElement = element;
10615     this.currentHoverItemName = (item != null) ? item.name : "";
10616     if(this.currentHoverElement != null)
10617      this.DoSetHoverState(this.currentHoverElement, oldCurrentHoverElement);
10618    }
10619   }
10620  }
10621 },
10622 SetCurrentPressedElement: function(element){
10623  if(this.currentPressedElement && !ASPx.IsValidElement(this.currentPressedElement)){
10624   this.currentPressedElement = null;
10625   this.currentPressedItemName = "";
10626  }
10627  if(this.currentPressedElement != element){
10628   if(this.currentPressedElement != null)
10629    this.DoClearPressedState(this.currentPressedElement);
10630   var item = (element != null) ? element[ASPx.PressedItemKind] : null;
10631   if(item == null || item.enabled){
10632    this.currentPressedElement = element;
10633    this.currentPressedItemName = (item != null) ? item.name : "";
10634    if(this.currentPressedElement != null)
10635     this.DoSetPressedState(this.currentPressedElement);
10636   }
10637  }
10638 },
10639 SetCurrentFocusedElementBySrcElement: function(srcElement){
10640  var element = this.GetFocusedElement(srcElement);
10641  this.SetCurrentFocusedElement(element);
10642 },
10643 SetCurrentHoverElementBySrcElement: function(srcElement){
10644  var element = this.GetHoverElement(srcElement);
10645  this.SetCurrentHoverElement(element);
10646 },
10647 SetCurrentPressedElementBySrcElement: function(srcElement){
10648  var element = this.GetPressedElement(srcElement);
10649  this.SetCurrentPressedElement(element);
10650 },
10651 SetPressedElement: function (element) {
10652  this.SetCurrentHoverElement(null);
10653  this.SetCurrentPressedElementBySrcElement(element);
10654  this.savedCurrentPressedElement = this.currentPressedElement;
10655 },
10656 SelectElement: function (element) {
10657  var item = element[ASPx.SelectedItemKind];
10658  if(item)
10659   item.Apply(element);
10660 }, 
10661 SelectElementBySrcElement: function(srcElement){
10662  var element = this.GetSelectedElement(srcElement);
10663  if(element != null) this.SelectElement(element);
10664 }, 
10665 DeselectElement: function(element){
10666  var item = element[ASPx.SelectedItemKind];
10667  if(item)
10668   item.Cancel(element);
10669 }, 
10670 DeselectElementBySrcElement: function(srcElement){
10671  var element = this.GetSelectedElement(srcElement);
10672  if(element != null) this.DeselectElement(element);
10673 },
10674 SetElementEnabled: function(element, enable){
10675  if(enable)
10676   this.EnableElement(element);
10677  else
10678   this.DisableElement(element);
10679 },
10680 SetElementReadOnly: function(element, readOnly) {
10681  var element = this.GetReadOnlyElement(element);
10682  if (element != null) {
10683   var item = element[ASPx.ReadOnlyItemKind];
10684   if(item) {
10685    if(readOnly) {
10686     if(item.name == this.currentPressedItemName)
10687      this.SetCurrentPressedElement(null);
10688     if(item.name == this.currentHoverItemName)
10689      this.SetCurrentHoverElement(null);
10690    }
10691    if(readOnly)
10692     item.Apply(element);
10693    else
10694     item.Cancel(element);
10695   }
10696  }
10697 },
10698 SetElementWithChildNodesEnabled: function (parentName, enabled) {
10699  var procFunct = (enabled ? this.EnableElement : this.DisableElement);
10700  var childItems = this.disabledScheme[parentName];
10701  if (childItems && childItems.length > 0)
10702   for (var i = 0; i < childItems.length; i++) {
10703    procFunct.call(this, document.getElementById(childItems[i]));
10704   }
10705 },
10706 DisableElement: function (element) {
10707  var element = this.GetDisabledElement(element);
10708  if(element != null) {
10709   var item = element[ASPx.DisabledItemKind];
10710   if(item){
10711    var args = new ASPxClientStateEventArgs(item, element);
10712    this.BeforeDisabled.FireEvent(this, args);
10713    if(item.name == this.currentPressedItemName)
10714     this.SetCurrentPressedElement(null);
10715    if(item.name == this.currentHoverItemName)
10716     this.SetCurrentHoverElement(null);
10717    item.Apply(element);
10718    this.SetMouseStateItemsEnabled(item.name, item.postfixes, false);
10719    this.AfterDisabled.FireEvent(this, args);
10720   }
10721  }
10722 }, 
10723 EnableElement: function(element){
10724  var element = this.GetDisabledElement(element);
10725  if(element != null) {
10726   var item = element[ASPx.DisabledItemKind];
10727   if(item){
10728    var args = new ASPxClientStateEventArgs(item, element);
10729    this.BeforeEnabled.FireEvent(this, args);
10730    item.Cancel(element);
10731    this.SetMouseStateItemsEnabled(item.name, item.postfixes, true);
10732    this.AfterEnabled.FireEvent(this, args);
10733   }
10734  }
10735 }, 
10736 SetMouseStateItemsEnabled: function(name, postfixes, enabled){   
10737  if(postfixes && postfixes.length > 0){
10738   for(var i = 0; i < postfixes.length; i ++){
10739    this.SetItemsEnabled(this.hoverItems, name + postfixes[i], enabled);
10740    this.SetItemsEnabled(this.pressedItems, name + postfixes[i], enabled);
10741    this.SetItemsEnabled(this.focusedItems, name + postfixes[i], enabled);
10742   }
10743  }
10744  else{
10745   this.SetItemsEnabled(this.hoverItems, name, enabled);
10746   this.SetItemsEnabled(this.pressedItems, name, enabled);
10747   this.SetItemsEnabled(this.focusedItems, name, enabled);
10748  }  
10749 },
10750 SetItemsEnabled: function(items, name, enabled){   
10751  if(items[name])
10752   items[name].enabled = enabled;
10753 },
10754 OnFocusMove: function(evt){
10755  var element = ASPx.Evt.GetEventSource(evt);
10756  aspxGetStateController().SetCurrentFocusedElementBySrcElement(element);
10757 },
10758 OnMouseMove: function(evt, checkElementChanged){
10759  var srcElement = ASPx.Evt.GetEventSource(evt);
10760  if(checkElementChanged && srcElement == this.savedCurrentMouseMoveSrcElement) return;
10761  this.savedCurrentMouseMoveSrcElement = srcElement;
10762  if(this.savedCurrentPressedElement == null)
10763   this.SetCurrentHoverElementBySrcElement(srcElement);
10764  else{
10765   var element = this.GetPressedElement(srcElement);
10766   if(element != this.currentPressedElement){
10767    if(element == this.savedCurrentPressedElement)
10768     this.SetCurrentPressedElement(this.savedCurrentPressedElement);
10769    else
10770     this.SetCurrentPressedElement(null);
10771   }
10772  }
10773 },
10774 OnMouseDown: function(evt){
10775  if(!ASPx.Evt.IsLeftButtonPressed(evt)) return;
10776  var srcElement = ASPx.Evt.GetEventSource(evt);
10777  this.OnMouseDownOnElement(srcElement);
10778 },
10779 OnMouseDownOnElement: function (element) {
10780  if(this.GetPressedElement(element) == null) return;
10781  this.SetPressedElement(element);
10782 },
10783 OnMouseUp: function(evt){
10784  var srcElement = ASPx.Evt.GetEventSource(evt);
10785  this.OnMouseUpOnElement(srcElement);
10786 },
10787 OnMouseUpOnElement: function(element){
10788  if(this.savedCurrentPressedElement == null) return;
10789  this.ClearSavedCurrentPressedElement();
10790  this.SetCurrentHoverElementBySrcElement(element);
10791 },
10792 OnMouseOver: function(evt){
10793  var element = ASPx.Evt.GetEventSource(evt);
10794  if(element && element.tagName == "IFRAME")
10795   this.OnMouseMove(evt, true);
10796 },
10797 OnKeyDown: function(evt){
10798  var element = this.GetFocusedElement(ASPx.Evt.GetEventSource(evt));
10799  if(element != null && element == this.currentFocusedElement) {
10800   var item = element[ASPx.FocusedItemKind];
10801   if(item){
10802    var args = new ASPxClientStateEventArgs(item, element);
10803    args.htmlEvent = evt;
10804    this.FocusedItemKeyDown.FireEvent(this, args);
10805   }
10806  }
10807 },
10808 OnKeyUpOnElement: function(evt) {
10809  if(this.savedCurrentPressedElement != null && ASPx.Evt.IsActionKeyPressed(evt))
10810   this.ClearSavedCurrentPressedElement();
10811 },
10812 OnSelectStart: function(evt){
10813  if(this.savedCurrentPressedElement) {
10814   ASPx.Selection.Clear();
10815   return false;
10816  }
10817 },
10818 ClearSavedCurrentPressedElement: function() {
10819  this.savedCurrentPressedElement = null;
10820  this.SetCurrentPressedElement(null);
10821 },
10822 ClearCache: function(srcElement, kind) {
10823  if(srcElement[ASPx.CachedStatePrefix + kind])
10824   srcElement[ASPx.CachedStatePrefix + kind] = null;
10825 },
10826 ClearElementCache: function(srcElement) {
10827  this.ClearCache(srcElement, ASPx.FocusedItemKind);
10828  this.ClearCache(srcElement, ASPx.HoverItemKind);
10829  this.ClearCache(srcElement, ASPx.PressedItemKind);
10830  this.ClearCache(srcElement, ASPx.SelectedItemKind);
10831  this.ClearCache(srcElement, ASPx.DisabledItemKind);
10832 },
10833 ClearElementCacheInContainer: function(container) {
10834  var elements = ASPx.GetNodes(container);
10835  elements.push(container);
10836  ASPx.Data.ForEach(elements, this.ClearElementCache.bind(this));
10837 },
10838 LockForceRedrawAppearance: function() {
10839  this.forceRedrawAppearanceLockCount++;
10840 },
10841 UnlockForceRedrawAppearance: function() {
10842  this.forceRedrawAppearanceLockCount--;
10843 },
10844 IsForceRedrawAppearanceLocked: function() {
10845  return this.forceRedrawAppearanceLockCount > 0;
10846 },
10847 GetHoverItem: function(srcElement) {
10848  var element = this.GetHoverElement(srcElement);
10849  return (element != null) ? element[ASPx.HoverItemKind] : null;
10850 }
10851});
10852var stateController = null;
10853function aspxGetStateController(){
10854 if(stateController == null)
10855  stateController = new ASPxStateController();
10856 return stateController;
10857}
10858function aspxAddStateItems(method, namePrefix, classes, disableApplyingStyleToLink){
10859 for(var i = 0; i < classes.length; i ++){
10860  for(var j = 0; j < classes[i][2].length; j ++) {
10861   var name = namePrefix;
10862   if(classes[i][2][j])
10863    name += "_" + classes[i][2][j];
10864   var postfixes = classes[i][3] || null;
10865   var imageObjs = (classes[i][4] && classes[i][4][j]) || null;
10866   var imagePostfixes = classes[i][5] || null;
10867   method.call(aspxGetStateController(), name, classes[i][0], classes[i][1], postfixes, imageObjs, imagePostfixes, disableApplyingStyleToLink, namePrefix);
10868  }
10869 }
10870}
10871ASPx.AddHoverItems = function(namePrefix, classes, disableApplyingStyleToLink){
10872 aspxAddStateItems(aspxGetStateController().AddHoverItem, namePrefix, classes, disableApplyingStyleToLink);
10873};
10874ASPx.AddPressedItems = function(namePrefix, classes, disableApplyingStyleToLink){
10875 aspxAddStateItems(aspxGetStateController().AddPressedItem, namePrefix, classes, disableApplyingStyleToLink);
10876};
10877ASPx.AddSelectedItems = function(namePrefix, classes, disableApplyingStyleToLink){
10878 aspxAddStateItems(aspxGetStateController().AddSelectedItem, namePrefix, classes, disableApplyingStyleToLink);
10879};
10880ASPx.AddDisabledItems = function(namePrefix, classes, disableApplyingStyleToLink){
10881 aspxAddStateItems(aspxGetStateController().AddDisabledItem, namePrefix, classes, disableApplyingStyleToLink);
10882};
10883ASPx.AddReadOnlyItems = function(namePrefix, classes, disableApplyingStyleToLink) {
10884 aspxAddStateItems(aspxGetStateController().AddReadOnlyItem, namePrefix, classes, disableApplyingStyleToLink);
10885};
10886function aspxRemoveStateItems(method, namePrefix, classes){
10887 for(var i = 0; i < classes.length; i ++){
10888  for(var j = 0; j < classes[i][0].length; j ++) {
10889   var name = namePrefix;
10890   if(classes[i][0][j])
10891    name += "_" + classes[i][0][j];
10892   method.call(aspxGetStateController(), name, classes[i][1], namePrefix);
10893  }
10894 }
10895}
10896ASPx.RemoveHoverItems = function(namePrefix, classes){
10897 aspxRemoveStateItems(aspxGetStateController().RemoveHoverItem, namePrefix, classes);
10898};
10899ASPx.RemovePressedItems = function(namePrefix, classes){
10900 aspxRemoveStateItems(aspxGetStateController().RemovePressedItem, namePrefix, classes);
10901};
10902ASPx.RemoveSelectedItems = function(namePrefix, classes){
10903 aspxRemoveStateItems(aspxGetStateController().RemoveSelectedItem, namePrefix, classes);
10904};
10905ASPx.RemoveDisabledItems = function(namePrefix, classes){
10906 aspxRemoveStateItems(aspxGetStateController().RemoveDisabledItem, namePrefix, classes);
10907};
10908ASPx.RemoveReadOnlyItems = function(namePrefix, classes) {
10909 aspxRemoveStateItems(aspxGetStateController().RemoveReadOnlyItem, namePrefix, classes);
10910};
10911ASPx.AddAfterClearFocusedState = function(handler){
10912 aspxGetStateController().AfterClearFocusedState.AddHandler(handler);
10913};

10914ASPx.AddAfterSetFocusedState = function(handler){
10915 aspxGetStateController().AfterSetFocusedState.AddHandler(handler);
10916};
10917ASPx.AddAfterClearHoverState = function(handler){
10918 aspxGetStateController().AfterClearHoverState.AddHandler(handler);
10919};
10920ASPx.AddAfterSetHoverState = function(handler){
10921 aspxGetStateController().AfterSetHoverState.AddHandler(handler);
10922};
10923ASPx.AddAfterClearPressedState = function(handler){
10924 aspxGetStateController().AfterClearPressedState.AddHandler(handler);
10925};
10926ASPx.AddAfterSetPressedState = function(handler){
10927 aspxGetStateController().AfterSetPressedState.AddHandler(handler);
10928};
10929ASPx.AddAfterDisabled = function(handler){
10930 aspxGetStateController().AfterDisabled.AddHandler(handler);
10931};
10932ASPx.AddAfterEnabled = function(handler){
10933 aspxGetStateController().AfterEnabled.AddHandler(handler);
10934};
10935ASPx.AddBeforeClearFocusedState = function(handler){
10936 aspxGetStateController().BeforeClearFocusedState.AddHandler(handler);
10937};
10938ASPx.AddBeforeSetFocusedState = function(handler){
10939 aspxGetStateController().BeforeSetFocusedState.AddHandler(handler);
10940};
10941ASPx.AddBeforeClearHoverState = function(handler){
10942 aspxGetStateController().BeforeClearHoverState.AddHandler(handler);
10943};
10944ASPx.AddBeforeSetHoverState = function(handler){
10945 aspxGetStateController().BeforeSetHoverState.AddHandler(handler);
10946};
10947ASPx.AddBeforeClearPressedState = function(handler){
10948 aspxGetStateController().BeforeClearPressedState.AddHandler(handler);
10949};
10950ASPx.AddBeforeSetPressedState = function(handler){
10951 aspxGetStateController().BeforeSetPressedState.AddHandler(handler);
10952};
10953ASPx.AddBeforeDisabled = function(handler){
10954 aspxGetStateController().BeforeDisabled.AddHandler(handler);
10955};
10956ASPx.AddBeforeEnabled = function(handler){
10957 aspxGetStateController().BeforeEnabled.AddHandler(handler);
10958};
10959ASPx.AddFocusedItemKeyDown = function(handler){
10960 aspxGetStateController().FocusedItemKeyDown.AddHandler(handler);
10961};
10962ASPx.SetHoverState = function(element){
10963 aspxGetStateController().SetCurrentHoverElementBySrcElement(element);
10964};
10965ASPx.ClearHoverState = function(evt){
10966 aspxGetStateController().SetCurrentHoverElementBySrcElement(null);
10967};
10968ASPx.UpdateHoverState = function(evt){
10969 aspxGetStateController().OnMouseMove(evt, false);
10970};
10971ASPx.SetFocusedState = function(element){
10972 aspxGetStateController().SetCurrentFocusedElementBySrcElement(element);
10973};
10974ASPx.ClearFocusedState = function(evt){
10975 aspxGetStateController().SetCurrentFocusedElementBySrcElement(null);
10976};
10977ASPx.UpdateFocusedState = function(evt){
10978 aspxGetStateController().OnFocusMove(evt);
10979};
10980ASPx.AccessibilityMarkerClass = "dxalink";
10981ASPx.AssignAccessibilityEventsToChildrenLinks = function(container, clearFocusedStateOnMouseOut){
10982 var links = ASPx.GetNodesByPartialClassName(container, ASPx.AccessibilityMarkerClass);
10983 for(var i = 0; i < links.length; i++)
10984  ASPx.AssignAccessibilityEventsToLink(links[i], clearFocusedStateOnMouseOut);
10985};
10986ASPx.AssignAccessibilityEventsToLink = function(link, clearFocusedStateOnMouseOut) {
10987 if(!ASPx.ElementContainsCssClass(link, ASPx.AccessibilityMarkerClass))
10988  return;
10989 ASPx.AssignAccessibilityEventsToLinkCore(link, clearFocusedStateOnMouseOut);
10990};
10991ASPx.AssignAccessibilityEventsToLinkCore = function (link, clearFocusedStateOnMouseOut) {
10992 ASPx.Evt.AttachEventToElement(link, "focus", function (e) { ASPx.UpdateFocusedState(e); });
10993 var clearFocusedStateHandler = function (e) { ASPx.ClearFocusedState(e); };
10994 ASPx.Evt.AttachEventToElement(link, "blur", clearFocusedStateHandler);
10995 if(clearFocusedStateOnMouseOut)
10996  ASPx.Evt.AttachEventToElement(link, "mouseout", clearFocusedStateHandler);
10997};
10998ASPx.Evt.AttachEventToDocument("mousemove", function(evt) {
10999 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
11000  aspxGetStateController().OnMouseMove(evt, true);
11001});
11002ASPx.Evt.AttachEventToDocument(ASPx.TouchUIHelper.touchMouseDownEventName, function(evt) {
11003 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
11004  aspxGetStateController().OnMouseDown(evt);
11005});
11006ASPx.Evt.AttachEventToDocument(ASPx.TouchUIHelper.touchMouseUpEventName, function(evt) {
11007 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
11008  aspxGetStateController().OnMouseUp(evt);
11009});
11010ASPx.Evt.AttachEventToDocument("mouseover", function(evt) {
11011 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
11012  aspxGetStateController().OnMouseOver(evt);
11013});
11014ASPx.Evt.AttachEventToDocument("keydown", function(evt) {
11015 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
11016  aspxGetStateController().OnKeyDown(evt);
11017});
11018ASPx.Evt.AttachEventToDocument("selectstart", function(evt) {
11019 if(ASPx.classesScriptParsed && ASPx.StateItemsExist)
11020  return aspxGetStateController().OnSelectStart(evt);
11021});
11022ASPx.GetStateController = aspxGetStateController;

11023ASPx.StateItem = ASPxStateItem;
11024})();
11025
11026(function () {
11027 var ASPx = window.ASPx || {};
11028 ASPx.ASPxImageLoad = {};
11029 ASPx.ASPxImageLoad.dxDefaultLoadingImageCssClass = "dxe-loadingImage";
11030 ASPx.ASPxImageLoad.dxDefaultLoadingImageCssClassRegexp = new RegExp("dx\\w+-loadingImage");
11031 ASPx.ASPxImageLoad.OnLoad = function (image, customLoadingImage, isOldIE, customBackgroundImageUrl) {
11032  image.dxCustomBackgroundImageUrl = "";
11033  image.dxShowLoadingImage = true;
11034  image.dxCustomLoadingImage = customLoadingImage;
11035  if (customBackgroundImageUrl != "")
11036   image.dxCustomBackgroundImageUrl = "url('" + customBackgroundImageUrl + "')";
11037  ASPx.ASPxImageLoad.prepareImageBackground(image, isOldIE);
11038  ASPx.ASPxImageLoad.removeHandlers(image);
11039  image.className = image.className.replace(ASPx.ASPxImageLoad.dxDefaultLoadingImageCssClassRegexp, "");
11040 };
11041 ASPx.ASPxImageLoad.removeASPxImageBackground = function (image, isOldIE) {
11042  if (isOldIE) 
11043   image.style.removeAttribute("background-image");
11044  else 
11045   image.style.backgroundImage = "";
11046 };
11047 ASPx.ASPxImageLoad.prepareImageBackground = function (image, isOldIE) {
11048  ASPx.ASPxImageLoad.removeASPxImageBackground(image, isOldIE);
11049  if (image.dxCustomBackgroundImageUrl != "")
11050   image.style.backgroundImage = image.dxCustomBackgroundImageUrl;
11051 };
11052 ASPx.ASPxImageLoad.removeHandlers = function (image) {
11053  image.removeAttribute("onload");
11054  image.removeAttribute("onabort");
11055  image.removeAttribute("onerror");
11056 };
11057 window.ASPx = ASPx;
11058})();
11059(function() {
11060var CheckingScriptObjectCommand = ASPx.CreateClass(null, {
11061 constructor: function(scriptName, markerObjectName) {
11062  this.scriptName = scriptName;
11063  this.markerObjectName = markerObjectName;
11064  this.isExisted = false;
11065 },
11066 Run: function() {
11067  var markerObj = this.GetMarkerObject();
11068  this.isExisted = !!markerObj;
11069  if(this.isExisted)
11070   markerObj.DXPatched = true;
11071 },
11072 GetErrorMessage: function() {
11073  return this.GetErrorMessageCore(true);
11074 },
11075 GetErrorMessageCore: function(isScriptRequired){
11076  var markerObj = this.GetMarkerObject();
11077  if(this.isExisted && markerObj && markerObj.DXPatched || !isScriptRequired && !markerObj)
11078   return null;
11079  if(isScriptRequired && !this.GetMarkerObject()){
11080   if(this.isExisted)
11081    return this.scriptName + " script was attached but has been overridden.";
11082   else
11083    return this.scriptName + " script was not attached.";
11084  }
11085  if(!this.isExisted)
11086   return this.scriptName + " script was attached after DevExpress scripts.";
11087  return this.scriptName + " script was attached multiple times and mixed up with DevExpress scripts.";
11088 },
11089 GetMarkerObject: function() {
11090  return ASPx.GetGlobalObject(this.markerObjectName);
11091 }
11092});
11093var PatchScriptCommand = ASPx.CreateClass(CheckingScriptObjectCommand, {
11094 constructor: function(scriptName, markerObjectName, patchMethod, required) {
11095  this.constructor.prototype.constructor.call(this, scriptName, markerObjectName);
11096  this.required = required;
11097  this.patchMethod = patchMethod;
11098 },
11099 Run: function() {
11100  CheckingScriptObjectCommand.prototype.Run.call(this);
11101  if(this.isExisted)
11102   this.patchMethod();
11103 },
11104 GetErrorMessage: function() {  
11105  return this.GetErrorMessageCore(this.required);
11106 }
11107});

11108var ExternalScriptProcessor = ASPx.CreateClass(null, {
11109 constructor: function() {
11110  this.commands = {};
11111 },
11112 Process: function(scriptName, markerObjectName, patchMethod, required) {
11113  var newCommand = this.CreateCommand(scriptName, markerObjectName, patchMethod, !!required);
11114  var oldCommand = this.commands[markerObjectName];
11115  if(oldCommand) {
11116   if(!oldCommand.patchMethod && !newCommand.patchMethod)
11117    newCommand = null;
11118   else if(newCommand.patchMethod && (!oldCommand.patchMethod || oldCommand.required))
11119    newCommand.required = true;
11120   else if(oldCommand.patchMethod && !newCommand.patchMethod) {
11121    oldCommand.required = true;
11122    newCommand = null;
11123   }
11124  }
11125  if(newCommand) {
11126   this.commands[markerObjectName] = newCommand;
11127   newCommand.Run();
11128  }
11129 },
11130 CreateCommand: function(scriptName, markerObjectName, patchMethod, required) {
11131  if(patchMethod)
11132   return new PatchScriptCommand(scriptName, markerObjectName, patchMethod, required);
11133  return new CheckingScriptObjectCommand(scriptName, markerObjectName);
11134 },
11135 ShowErrorMessages: function() {
11136  var messages = this.GetErrorMessages();
11137  var console = window.console;
11138  if(!messages.length || !console || !ASPx.IsFunction(console.error))
11139   return;
11140  for(var i = 0; i < messages.length; i++) {
11141   console.error(messages[i]);
11142  }
11143  ASPx.ShowKBErrorMessage("Please check the correctness of script registration on the page. For details, see ", "T272309");
11144 },
11145 GetErrorMessages: function() {
11146  var messages = [];
11147  for (var key in this.commands) {
11148   if (this.commands.hasOwnProperty(key)) {
11149    var message = this.commands[key].GetErrorMessage();
11150    if (message)
11151     messages.push(message);
11152   }
11153  }
11154  return messages;
11155 }
11156});
11157ExternalScriptProcessor.Instance = null;
11158ExternalScriptProcessor.getInstance = function() {
11159 if(!ExternalScriptProcessor.Instance)
11160  ExternalScriptProcessor.Instance = new ExternalScriptProcessor();
11161 return ExternalScriptProcessor.Instance;
11162};
11163ASPx.ExternalScriptProcessor = ExternalScriptProcessor;
11164})();
11165(function module(ASPx) {
11166ASPx.modules.Controls = module;
11167var ASPxClientBeginCallbackEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11168 constructor: function(command){
11169  this.constructor.prototype.constructor.call(this);
11170  this.command = command;
11171 }
11172});
11173var ASPxClientGlobalBeginCallbackEventArgs = ASPx.CreateClass(ASPxClientBeginCallbackEventArgs, {
11174 constructor: function(control, command){
11175  this.constructor.prototype.constructor.call(this, command);
11176  this.control = control;
11177 }
11178});
11179var ASPxClientEndCallbackEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11180 constructor: function(command){
11181  this.constructor.prototype.constructor.call(this);
11182  this.command = command;
11183 }
11184});
11185var ASPxClientGlobalEndCallbackEventArgs = ASPx.CreateClass(ASPxClientEndCallbackEventArgs, {
11186 constructor: function(control){
11187  this.constructor.prototype.constructor.call(this);
11188  this.control = control;
11189 }
11190});
11191var ASPxClientCustomDataCallbackEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11192 constructor: function(result) {
11193  this.constructor.prototype.constructor.call(this);
11194  this.result = result;
11195 }
11196});
11197var ASPxClientCallbackErrorEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11198 constructor: function (message, callbackId) {
11199  this.constructor.prototype.constructor.call(this);
11200  this.message = message;
11201  this.handled = false;
11202  this.callbackId = callbackId;
11203 }
11204});
11205var ASPxClientGlobalCallbackErrorEventArgs = ASPx.CreateClass(ASPxClientCallbackErrorEventArgs, {
11206 constructor: function (control, message, callbackId) {
11207  this.constructor.prototype.constructor.call(this, message, callbackId);
11208  this.control = control;
11209 }
11210});
11211var ASPxClientValidationCompletedEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11212 constructor: function (container, validationGroup, invisibleControlsValidated, isValid, firstInvalidControl, firstVisibleInvalidControl) {
11213  this.constructor.prototype.constructor.call(this);
11214  this.container = container;
11215  this.validationGroup = validationGroup;
11216  this.invisibleControlsValidated = invisibleControlsValidated;
11217  this.isValid = isValid;
11218  this.firstInvalidControl = firstInvalidControl;

11219  this.firstVisibleInvalidControl = firstVisibleInvalidControl;
11220 }
11221});
11222var ASPxClientControlsInitializedEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11223 constructor: function(isCallback) {
11224  this.isCallback = isCallback;
11225 }
11226});
11227var ASPxClientControlBeforePronounceEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11228 constructor: function(messageParts, control){
11229  this.constructor.prototype.constructor.call(this);
11230  this.messageParts = messageParts;
11231  this.control = control;
11232 }
11233});
11234var ASPxClientControlUnloadEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11235 constructor: function(control){
11236  this.constructor.prototype.constructor.call(this);
11237  this.control = control;
11238 }
11239});
11240var ASPxClientEndFocusEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11241 constructor: function(item) {
11242  this.constructor.prototype.constructor.call(this);
11243  this.item = item;
11244 }
11245});
11246var ASPxClientItemFocusedEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11247 constructor: function(item) {
11248  this.constructor.prototype.constructor.call(this);
11249  this.item = item;
11250 }
11251});
11252var BeforeInitCallbackEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11253 constructor: function(callbackOwnerID){
11254  this.constructor.prototype.constructor.call(this);
11255  this.callbackOwnerID = callbackOwnerID;
11256 }
11257});
11258var ASPxClientBrowserWindowResizedInternalEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
11259 constructor: function(eventInfo) {
11260  this.constructor.prototype.constructor.call(this);
11261  this.htmlEvent = eventInfo.htmlEvent;
11262  this.windowClientWidth = eventInfo.wndWidth;
11263  this.windowClientHeigth = eventInfo.wndHeight;
11264  this.previousWindowClientWidth = eventInfo.prevWndWidth;
11265  this.previousWindowClientHeight = eventInfo.prevWndHeight;
11266  this.virtualKeyboardShownOnAndroid = eventInfo.virtualKeyboardShownOnAndroid;
11267 }
11268});
11269ASPx.createControl = function(type, name, windowName, properties, events, setupMethod, data){
11270 var globalName = windowName && windowName.length > 0 ? windowName : name;
11271 var dxo = new type(name);
11272 var haveWrapper = ASPx.Platform === "NETCORE" && dxo.createWrapper && !DevExpress.AspNetCore.Internal.BackwardCompatibility.useLegacyClientAPI;
11273 if(haveWrapper) {
11274  window[globalName] = dxo.createWrapper();
11275  dxo.aspNetCoreWrapperInstance = window[globalName];
11276 }
11277 else
11278  dxo.InitGlobalVariable(globalName);
11279 if(properties)
11280  dxo.SetProperties(properties);
11281 if(events)
11282  dxo.SetEvents(events);
11283 if(setupMethod)
11284  setupMethod.call(dxo);
11285 if(data)
11286  dxo.SetData(data);
11287 dxo.AfterCreate();
11288};
11289var ASPxClientControlBase = ASPx.CreateClass(null, {
11290 constructor: function(name){
11291  this.name = name;
11292  this.uniqueID = name;   
11293  this.globalName = name;
11294  this.stateObject = null;
11295  this.needEncodeState = true;
11296  this.encodeHtml = true;
11297  this.enabled = true;
11298  this.clientEnabled = true;
11299  this.savedClientEnabled = true;
11300  this.clientVisible = true;
11301  this.accessibilityCompliant = false;
11302  this.parseJSPropertiesOnCallbackError = false;
11303  this.autoPostBack = false;
11304  this.allowMultipleCallbacks = true;
11305  this.callBack = null;
11306  this.enableCallbackAnimation = false;
11307  this.enableSlideCallbackAnimation = false;
11308  this.slideAnimationDirection = null;

11309  this.beginCallbackAnimationProcessing = false;
11310  this.endCallbackAnimationProcessing = false;
11311  this.savedCallbackResult = null;
11312  this.savedCallbacks = null;
11313  this.isCallbackAnimationPrevented = false;
11314  this.lpDelay = 300;
11315  this.lpTimer = -1;
11316  this.requestCount = 0;
11317  this.enableSwipeGestures = false;
11318  this.disableSwipeGestures = false;
11319  this.supportGestures = false;
11320  this.repeatedGestureValue = 0;
11321  this.repeatedGestureCount = 0;
11322  this.isInitialized = false;
11323  this.initialFocused = false;
11324  this.leadingAfterInitCall = ASPxClientControl.LeadingAfterInitCallConsts.None; 
11325  this.serverEvents = [];
11326  this.loadingPanelElement = null;
11327  this.loadingDivElement = null;  
11328  this.hasPhantomLoadingElements = false;
11329  this.mainElement = null;
11330  this.touchUIMouseScroller = null;
11331  this.hiddenFields = {};
11332  this.scPrefix = "dx";
11333  this.callbackHandlersQueue = new ASPx.ControlCallbackHandlersQueue(this);
11334  this.callbackCommand = {};
11335  this.currentCallbackID = -1;
11336  this.InitializeIntersectionObserversManager();
11337  this.Init = new ASPxClientEvent();
11338  this.BeginCallback = new ASPxClientEvent();
11339  this.EndCallback = new ASPxClientEvent();
11340  this.EndCallbackAnimationStart = new ASPxClientEvent();
11341  this.CallbackError = new ASPxClientEvent();
11342  this.CustomDataCallback = new ASPxClientEvent();
11343  this.BeforePronounce = new ASPxClientEvent();
11344  this.Unload = new ASPxClientEvent();
11345  this.Disposed = new ASPxClientEvent(); 
11346  aspxGetControlCollection().Add(this);
11347 },
11348 Initialize: function() {
11349  if(this.callBack != null)
11350   this.InitializeCallBackData();
11351  if (this.useCallbackQueue())
11352   this.callbackQueueHelper = new ASPx.ControlCallbackQueueHelper(this);
11353  ASPx.AccessibilityUtils.createAccessibleBackgrounds(this);
11354  if(this.accessibilityCompliant)
11355   ASPx.AccessibilityPronouncer.EnsureInitialize();
11356 },
11357 FinalizeInitialization: function() { },
11358 InlineInitialize: function() {
11359  this.savedClientEnabled = this.clientEnabled;
11360 },
11361 InitializeGestures: function() {
11362  if(this.isSwipeGesturesEnabled() && this.supportGestures) {
11363   ASPx.GesturesHelper.AddSwipeGestureHandler(this.name, 
11364    function() { return this.GetCallbackAnimationElement(); }.aspxBind(this), 
11365    function(evt) { return this.CanHandleGestureCore(evt); }.aspxBind(this), 
11366    function(value) { return this.AllowStartGesture(value); }.aspxBind(this),
11367    function(value) { return this.StartGesture(); }.aspxBind(this),
11368    function(value) { return this.AllowExecuteGesture(value); }.aspxBind(this),
11369    function(value) { this.ExecuteGesture(value); }.aspxBind(this),
11370    function(value) { this.CancelGesture(value); }.aspxBind(this),
11371    this.GetDefaultanimationEngineType(),
11372    this.rtl
11373   );
11374   if(ASPx.Browser.MSTouchUI)
11375    this.touchUIMouseScroller = ASPx.MouseScroller.Create(
11376     function() { return this.GetCallbackAnimationElement(); }.aspxBind(this),
11377     function() { return null; },
11378     function() { return this.GetCallbackAnimationElement(); }.aspxBind(this),
11379     function(element) { return this.NeedPreventTouchUIMouseScrolling(element); }.aspxBind(this),
11380     true
11381    );
11382  }
11383 },
11384 isSwipeGesturesEnabled: function() {
11385  return !this.disableSwipeGestures && (this.enableSwipeGestures || ASPx.Browser.TouchUI);
11386 },
11387 isSlideCallbackAnimationEnabled: function() {
11388  return this.enableSlideCallbackAnimation || this.isSwipeGesturesEnabled(); 
11389 },
11390 InitGlobalVariable: function(varName){
11391  if(!window) return;
11392  this.globalName = varName;
11393  window[varName] = this;
11394 },
11395 SetElementDisplay: function(element, value, checkCurrentStyle, makeInline) {
11396  ASPx.SetElementDisplay(element, value, checkCurrentStyle, makeInline);
11397 },
11398 SetProperties: function(properties, obj){
11399  if(!obj) obj = this;
11400  var isAspNetCoreWrapperInstanceExist = !!obj.aspNetCoreWrapperInstance;
11401  for(var name in properties){
11402   if(!properties.hasOwnProperty(name)) continue;
11403   obj[name] = properties[name];
11404   if(isAspNetCoreWrapperInstanceExist && name.indexOf("cp") === 0)
11405    obj.aspNetCoreWrapperInstance[name] = properties[name]; 
11406  }
11407 },
11408 SetEvents: function(events, obj){
11409  if(!obj) obj = this;
11410  for(var name in events){
11411   if(events.hasOwnProperty(name) && obj[name] && obj[name].AddHandler)
11412    obj[name].AddHandler(events[name]);
11413  }
11414 },
11415 SetData: function(data){
11416 },
11417 useCallbackQueue: function(){
11418  return false;
11419 },
11420 NeedPreventTouchUIMouseScrolling: function(element) {
11421  return false;
11422 },
11423 InitializeFocus: function() {
11424  if(this.initialFocused && this.IsVisible()) {
11425   if(ASPxClientUtils.iOSPlatform || ASPxClientUtils.androidPlatform)
11426    setTimeout(function() { this.Focus(); }.bind(this), ASPx.FOCUS_TIMEOUT);
11427   else
11428    this.Focus();
11429  }
11430 },
11431 AfterCreate: function() {
11432  this.AddDefaultStateControllerItems();

11433  this.InlineInitialize();
11434  this.InitializeGestures();
11435 },
11436 AfterInitialize: function() {
11437  this.initializeAriaDescriptor();
11438  this.InitializeFocus();
11439  this.isInitialized = true;
11440  this.RaiseInit();
11441  if(this.savedCallbacks) {
11442   for(var i = 0; i < this.savedCallbacks.length; i++) 
11443    this.CreateCallbackInternal(this.savedCallbacks[i].arg, this.savedCallbacks[i].command, 
11444     false, this.savedCallbacks[i].callbackInfo);
11445   this.savedCallbacks = null;
11446  }
11447 },
11448 InitializeCallBackData: function() {
11449 },
11450 AtlasPreInitialize: function() {
11451 },
11452 AtlasInitialize: function() {
11453 },
11454 IsDOMDisposed: function() { 
11455  return !ASPx.IsExistsElement(this.GetMainElement());
11456 },
11457 initializeAriaDescriptor: function() {
11458  if(this.ariaDescription) {
11459   var descriptionObject = ASPx.Json.Eval(this.ariaDescription);
11460   if(descriptionObject) {
11461    this.ariaDescriptor = new AriaDescriptor(this, descriptionObject);
11462    this.applyAccessibilityAttributes(this.ariaDescriptor); 
11463   }
11464  }
11465 },
11466 applyAccessibilityAttributes: function() { },
11467 setAriaDescription: function(selector, argsList) {
11468  if(this.ariaDescriptor)
11469   this.ariaDescriptor.setDescription(selector, argsList || [[]]);
11470 },
11471 allowRestoreFocusOnCallbacks: function(){
11472  return this.accessibilityCompliant;
11473 },
11474 HtmlEncode: function(text) {
11475  return this.encodeHtml ? ASPx.Str.EncodeHtml(text) : text;
11476 },
11477 IsServerEventAssigned: function(eventName){
11478  return ASPx.Data.ArrayIndexOf(this.serverEvents, eventName) >= 0;
11479 },
11480 OnPost: function(args){
11481  this.SerializeStateHiddenField();
11482 },
11483 SerializeStateHiddenField: function() {
11484  this.UpdateStateObject();
11485  if(this.stateObject != null)
11486   this.UpdateStateHiddenField();
11487 },
11488 OnPostFinalization: function(args){
11489 },
11490 UpdateStateObject: function(){
11491 },
11492 UpdateStateObjectWithObject: function(obj){
11493  if(!obj) return;
11494  if(!this.stateObject)
11495   this.stateObject = { };
11496  for(var key in obj)
11497   if(obj.hasOwnProperty(key))
11498    this.stateObject[key] = obj[key];
11499 },
11500 UpdateStateHiddenField: function() {
11501  var stateHiddenField = this.GetStateHiddenField();
11502  if(stateHiddenField) {
11503   var stateObjectStr = ASPx.Json.ToJson(this.stateObject, !this.needEncodeState);
11504   stateHiddenField.value = this.needEncodeState ? ASPx.Str.EncodeHtml(stateObjectStr) : stateObjectStr;
11505  }
11506 },
11507 GetStateHiddenField: function() {
11508  return this.GetHiddenField(this.GetStateHiddenFieldName(), this.GetStateHiddenFieldID(), 
11509   this.GetStateHiddenFieldParent(), this.GetStateHiddenFieldOrigin());
11510 },
11511 GetStateHiddenFieldName: function() {
11512  return this.uniqueID;
11513 },
11514 GetStateHiddenFieldID: function() {
11515  return this.name + "_State";
11516 },
11517 GetStateHiddenFieldOrigin: function() {
11518  return this.GetMainElement();
11519 },
11520 GetStateHiddenFieldParent: function() {
11521  var element = this.GetStateHiddenFieldOrigin();
11522  return element ? element.parentNode : null;
11523 },
11524 GetHiddenField: function(name, id, parent, beforeElement) {
11525  var hiddenField = this.hiddenFields[id];
11526  if(!hiddenField || !ASPx.IsValidElement(hiddenField)) {
11527   if(parent) {
11528    var existingHiddenField = ASPx.GetElementById(this.GetStateHiddenFieldID());
11529    this.hiddenFields[id] = hiddenField = existingHiddenField || ASPx.CreateHiddenField(name, id);
11530    if(existingHiddenField)
11531     return existingHiddenField;
11532    if(beforeElement)
11533     parent.insertBefore(hiddenField, beforeElement);
11534    else
11535     parent.appendChild(hiddenField);
11536   }
11537  }
11538  return hiddenField;
11539 },
11540 GetChildElement: function(idPostfix){
11541  var mainElement = this.GetMainElement();
11542  if(idPostfix.charAt && idPostfix.charAt(0) !== "_")
11543   idPostfix = "_" + idPostfix;
11544  return mainElement ? ASPx.CacheHelper.GetCachedChildById(this, mainElement, this.name + idPostfix) : null;
11545 },
11546 getChildControl: function(idPostfix) {
11547  var result = null;
11548  var childControlId = this.getChildControlUniqueID(idPostfix);
11549  ASPx.GetControlCollection().ProcessControlsInContainer(this.GetMainElement(), function(control) {
11550   if(control.uniqueID == childControlId)
11551    result = control;
11552  });
11553  return result;  
11554 },
11555 getChildControlUniqueID: function(idPostfix) {
11556  idPostfix = idPostfix.split("_").join("$");
11557  if(idPostfix.charAt && idPostfix.charAt(0) !== "$")
11558   idPostfix = "$" + idPostfix;
11559  return this.uniqueID + idPostfix;  
11560 },
11561 getInnerControl: function(idPostfix) {
11562  var name = this.name + idPostfix;
11563  var result = window[name];
11564  return result && Ident.IsASPxClientControl(result)
11565   ? result
11566   : null;
11567 },
11568 GetParentForm: function(){
11569  return ASPx.GetParentByTagName(this.GetMainElement(), "FORM");
11570 },
11571 GetMainElement: function(){
11572  if(!ASPx.IsExistsElement(this.mainElement))
11573   this.mainElement = ASPx.GetElementById(this.GetMainElementId());
11574  return this.mainElement;
11575 },
11576 GetMainElementId: function() {
11577  return this.name;
11578 },
11579 IsLoadingContainerVisible: function(){
11580  return this.IsVisible();
11581 },
11582 GetLoadingPanelElement: function(){
11583  return ASPx.GetElementById(this.name + "_LP");
11584 },
11585 GetClonedLoadingPanel: function(){
11586  return document.getElementById(this.GetLoadingPanelElement().id + "V"); 
11587 },
11588 CloneLoadingPanel: function(element, parent) {
11589  var clone = element.cloneNode(true);

11590  clone.id = element.id + "V";
11591  parent.appendChild(clone);
11592  return clone;
11593 },
11594 CreateLoadingPanelWithoutBordersInsideContainer: function(container) {
11595  var loadingPanel = this.CreateLoadingPanelInsideContainer(container, false, true, true);
11596  var contentStyle = ASPx.GetCurrentStyle(container);
11597  if(!loadingPanel || !contentStyle)
11598   return;
11599  var elements = [ ];
11600  var table = (loadingPanel.tagName == "TABLE") ? loadingPanel : ASPx.GetNodeByTagName(loadingPanel, "TABLE", 0);
11601  if(table != null)
11602   elements.push(table);
11603  else
11604   elements.push(loadingPanel);
11605  var cells = ASPx.GetNodesByTagName(loadingPanel, "TD");
11606  if(!cells) cells = [ ];
11607  for(var i = 0; i < cells.length; i++)
11608   elements.push(cells[i]);
11609  for(var i = 0; i < elements.length; i++) {
11610   var el = elements[i];
11611   el.style.backgroundColor = contentStyle.backgroundColor;
11612   ASPx.RemoveBordersAndShadows(el);
11613  }
11614 },
11615 CreateLoadingPanelInsideContainer: function(parentElement, hideContent, collapseHeight, collapseWidth) {
11616  if(this.ShouldHideExistingLoadingElements())
11617   this.HideLoadingPanel();
11618  if(parentElement == null)
11619   return null;
11620  if(!this.IsLoadingContainerVisible()) {
11621   this.hasPhantomLoadingElements = true;
11622   return null;
11623  }
11624  var element = this.GetLoadingPanelElement();
11625  if(element != null){
11626   var width = collapseWidth ? 0 : ASPx.GetClearClientWidth(parentElement);
11627   var height = collapseHeight ? 0 : ASPx.GetClearClientHeight(parentElement);
11628   if(hideContent){
11629    for(var i = parentElement.childNodes.length - 1; i > -1; i--){
11630     if(parentElement.childNodes[i].style)
11631      parentElement.childNodes[i].style.display = "none";
11632     else if(parentElement.childNodes[i].nodeType == 3) 
11633      parentElement.removeChild(parentElement.childNodes[i]);
11634    }
11635   }
11636   else
11637    parentElement.innerHTML = "";
11638   var table = document.createElement("TABLE");
11639   parentElement.appendChild(table);
11640   table.border = 0;
11641   table.cellPadding = 0;
11642   table.cellSpacing = 0;
11643   ASPx.SetStyles(table, {
11644    width: (width > 0) ? width : "100%",
11645    height: (height > 0) ? height : "100%"
11646   });
11647   var tbody = document.createElement("TBODY");
11648   table.appendChild(tbody);
11649   var tr = document.createElement("TR");
11650   tbody.appendChild(tr);
11651   var td = document.createElement("TD");
11652   tr.appendChild(td);
11653   td.align = "center";
11654   td.vAlign = "middle";
11655   element = this.CloneLoadingPanel(element, td);
11656   ASPx.SetElementDisplay(element, true);
11657   this.loadingPanelElement = element;
11658   return element;
11659  } else
11660   parentElement.innerHTML = "&nbsp;";
11661  return null;
11662 },
11663 CreateLoadingPanelWithAbsolutePosition: function(parentElement, offsetElement) {
11664  if(this.ShouldHideExistingLoadingElements())
11665   this.HideLoadingPanel();
11666  if(parentElement == null)
11667   return null;
11668  if(!this.IsLoadingContainerVisible()) {
11669   this.hasPhantomLoadingElements = true;
11670   return null;
11671  }
11672  if(!offsetElement)
11673   offsetElement = parentElement;
11674  var element = this.GetLoadingPanelElement();
11675  if(element != null) {
11676   element = this.CloneLoadingPanel(element, parentElement);
11677   ASPx.SetStyles(element, {
11678    position: "absolute"
11679   });
11680   ASPx.SetElementDisplay(element, true);
11681   ASPx.Evt.AttachEventToElement(element, ASPx.Evt.GetMouseWheelEventName(), ASPx.Evt.PreventEvent);
11682   this.SetLoadingPanelLocation(offsetElement, element);
11683   this.loadingPanelElement = element;
11684   return element;
11685  }
11686  return null;
11687 },
11688 CreateLoadingPanelInline: function(parentElement, centerInParent){
11689  if(this.ShouldHideExistingLoadingElements())
11690   this.HideLoadingPanel();
11691  if(parentElement == null)
11692   return null;
11693  if(!this.IsLoadingContainerVisible()) {
11694   this.hasPhantomLoadingElements = true;
11695   return null;
11696  }
11697  var element = this.GetLoadingPanelElement();
11698  if(element != null) {
11699   element = this.CloneLoadingPanel(element, parentElement);
11700   if(centerInParent){
11701    ASPx.SetElementDisplay(element, true);
11702    parentElement.style.textAlign = "center";
11703   }
11704   else
11705    ASPx.SetElementDisplay(element, true);
11706   this.loadingPanelElement = element;
11707   return element;
11708  }
11709  return null;
11710 },
11711 ShowLoadingPanel: function() {
11712 },
11713 ShowLoadingElements: function() {
11714  if(this.InCallback() || this.lpTimer > -1) return;
11715  this.ShowLoadingDiv();

11716  if(this.IsCallbackAnimationEnabled())
11717   this.StartBeginCallbackAnimation();
11718  else
11719   this.ShowLoadingElementsInternal();
11720 },
11721 ShowLoadingElementsInternal: function() {
11722  if(this.lpDelay > 0 && !this.IsCallbackAnimationEnabled()) 
11723   this.lpTimer = window.setTimeout(function() { 
11724    this.ShowLoadingPanelOnTimer(); 
11725   }.aspxBind(this), this.lpDelay);
11726  else {
11727   this.RestoreLoadingDivOpacity();
11728   this.ShowLoadingPanel();
11729  }
11730 },
11731 GetLoadingPanelOffsetElement: function (baseElement) {
11732  if(this.IsCallbackAnimationEnabled()) {
11733   var element = this.GetLoadingPanelCallbackAnimationOffsetElement();
11734   if(element) {
11735    var container = typeof(ASPx.AnimationHelper) != "undefined" ? ASPx.AnimationHelper.findSlideAnimationContainer(element) : null;
11736    if(container)
11737     return container.parentNode.parentNode;
11738    else
11739     return element;
11740   }
11741  }
11742  return baseElement;
11743 },
11744 GetLoadingPanelCallbackAnimationOffsetElement: function () {
11745  return this.GetCallbackAnimationElement();
11746 },
11747 IsCallbackAnimationEnabled: function () {
11748  return (this.enableCallbackAnimation || this.isSlideCallbackAnimationEnabled()) && !this.isCallbackAnimationPrevented;
11749 },
11750 GetDefaultanimationEngineType: function() {
11751  return ASPx.AnimationEngineType.DEFAULT;
11752 },

11753 StartBeginCallbackAnimation: function () {
11754  this.beginCallbackAnimationProcessing = true;
11755  this.isCallbackFinished = false;
11756  var element = this.GetCallbackAnimationElement();
11757  if (element && this.isSlideCallbackAnimationEnabled() && this.slideAnimationDirection)
11758   ASPx.AnimationHelper.slideOut(element, this.slideAnimationDirection, this.FinishBeginCallbackAnimation.aspxBind(this), this.GetDefaultanimationEngineType(), this.rtl);
11759  else if(element && this.enableCallbackAnimation) 
11760   ASPx.AnimationHelper.fadeOut(element, this.FinishBeginCallbackAnimation.aspxBind(this), null, ASPx.AnimationEngineType.JS);
11761  else
11762   this.FinishBeginCallbackAnimation();
11763 },
11764 CancelBeginCallbackAnimation: function() {
11765  if(this.beginCallbackAnimationProcessing) {
11766   this.beginCallbackAnimationProcessing = false;
11767   var element = this.GetCallbackAnimationElement();
11768   ASPx.AnimationHelper.cancelAnimation(element);
11769  }
11770 },
11771 FinishBeginCallbackAnimation: function () {
11772  this.beginCallbackAnimationProcessing = false;
11773  if(!this.isCallbackFinished)
11774   this.ShowLoadingElementsInternal();
11775  else {
11776   this.DoCallback(this.savedCallbackResult);
11777   this.savedCallbackResult = null;
11778  }
11779 },

11780 CheckBeginCallbackAnimationInProgress: function(callbackResult) {
11781  if(this.beginCallbackAnimationProcessing) {
11782   this.savedCallbackResult = callbackResult;
11783   this.isCallbackFinished = true;
11784   return true;
11785  }
11786  return false;
11787 },
11788 StartEndCallbackAnimation: function () {
11789  this.HideLoadingPanel();
11790  this.SetInitialLoadingDivOpacity();
11791  this.RaiseEndCallbackAnimationStart();
11792  this.endCallbackAnimationProcessing = true;
11793  var element = this.GetCallbackAnimationElement();
11794  if(element && this.isSlideCallbackAnimationEnabled() && this.slideAnimationDirection) 
11795   ASPx.AnimationHelper.slideIn(element, this.slideAnimationDirection, this.FinishEndCallbackAnimation.aspxBind(this), this.GetDefaultanimationEngineType(), this.rtl);
11796  else if(element && this.enableCallbackAnimation) 
11797   ASPx.AnimationHelper.fadeIn(element, this.FinishEndCallbackAnimation.aspxBind(this), null, ASPx.AnimationEngineType.JS);
11798  else
11799   this.FinishEndCallbackAnimation();
11800  this.slideAnimationDirection = null;
11801 },
11802 FinishEndCallbackAnimation: function () {
11803  this.DoEndCallback();
11804  this.endCallbackAnimationProcessing = false;
11805  this.CheckRepeatGesture();
11806 },
11807 CheckEndCallbackAnimationNeeded: function() {
11808  if(!this.endCallbackAnimationProcessing && this.requestCount == 1) {
11809   this.StartEndCallbackAnimation();
11810   return true;
11811  }
11812  return false;
11813 },
11814 PreventCallbackAnimation: function() {
11815  this.isCallbackAnimationPrevented = true;
11816 },
11817 GetCallbackAnimationElement: function() {
11818  return null;
11819 },
11820 AssignSlideAnimationDirectionByPagerArgument: function(arg, currentPageIndex) {
11821  this.slideAnimationDirection = null;
11822  if(this.isSlideCallbackAnimationEnabled() && typeof(ASPx.AnimationHelper) != "undefined") {
11823   if(arg == PagerCommands.Next || arg == PagerCommands.Last)
11824    this.slideAnimationDirection = ASPx.AnimationHelper.SLIDE_LEFT_DIRECTION;
11825   else if(arg == PagerCommands.First || arg == PagerCommands.Prev)
11826    this.slideAnimationDirection = ASPx.AnimationHelper.SLIDE_RIGHT_DIRECTION;
11827   else if(!isNaN(currentPageIndex) && arg.indexOf(PagerCommands.PageNumber) == 0) {
11828    var newPageIndex = parseInt(arg.substring(2));
11829    if (!isNaN(newPageIndex)) {
11830     var leftDir = this.rtl ? ASPx.AnimationHelper.SLIDE_LEFT_DIRECTION : ASPx.AnimationHelper.SLIDE_RIGHT_DIRECTION;
11831     var rightDir = this.rtl ? ASPx.AnimationHelper.SLIDE_RIGHT_DIRECTION : ASPx.AnimationHelper.SLIDE_LEFT_DIRECTION;
11832     this.slideAnimationDirection = newPageIndex < currentPageIndex ? leftDir : rightDir;
11833    }
11834   }
11835  }
11836 },
11837 TryShowPhantomLoadingElements: function () {
11838  if(this.hasPhantomLoadingElements && this.InCallback()) {
11839   this.hasPhantomLoadingElements = false;
11840   this.ShowLoadingDivAndPanel();
11841  }
11842 },
11843 ShowLoadingDivAndPanel: function () {
11844  this.ShowLoadingDiv();
11845  this.RestoreLoadingDivOpacity();
11846  this.ShowLoadingPanel();
11847 },
11848 HideLoadingElements: function() {

11849  this.CancelBeginCallbackAnimation();
11850  this.HideLoadingPanel();
11851  this.HideLoadingDiv();
11852 },
11853 ShowLoadingPanelOnTimer: function() {
11854  this.ClearLoadingPanelTimer();
11855  if(!this.IsDOMDisposed()) {
11856   this.RestoreLoadingDivOpacity();
11857   this.ShowLoadingPanel();
11858  }
11859 },
11860 ClearLoadingPanelTimer: function() {
11861  this.lpTimer = ASPx.Timer.ClearTimer(this.lpTimer);  
11862 },
11863 HideLoadingPanel: function() {
11864  this.ClearLoadingPanelTimer();
11865  this.hasPhantomLoadingElements = false;
11866  if(ASPx.IsExistsElement(this.loadingPanelElement)) {
11867   ASPx.RemoveElement(this.loadingPanelElement);
11868   this.loadingPanelElement = null;
11869  }
11870 },
11871 SetLoadingPanelLocation: function(offsetElement, loadingPanel, x, y, offsetX, offsetY) {
11872  if(!ASPx.IsExists(x) || !ASPx.IsExists(y)){
11873   var x1 = ASPx.GetAbsoluteX(offsetElement);
11874   var y1 = ASPx.GetAbsoluteY(offsetElement);
11875   var x2 = x1;
11876   var y2 = y1;
11877   if(offsetElement == document.body) {
11878    x1 = 0;
11879    y1 = 0;
11880    x2 = ASPx.GetDocumentMaxClientWidth();
11881    y2 = ASPx.GetDocumentMaxClientHeight();
11882   }
11883   else{
11884    x2 += offsetElement.offsetWidth;
11885    y2 += offsetElement.offsetHeight;
11886   }
11887   if(x1 < ASPx.GetDocumentScrollLeft())
11888    x1 = ASPx.GetDocumentScrollLeft();
11889   if(y1 < ASPx.GetDocumentScrollTop())
11890    y1 = ASPx.GetDocumentScrollTop();
11891   if(x2 > ASPx.GetDocumentScrollLeft() + ASPx.GetDocumentClientWidth())
11892    x2 = ASPx.GetDocumentScrollLeft() + ASPx.GetDocumentClientWidth();
11893   if(y2 > ASPx.GetDocumentScrollTop() + ASPx.GetDocumentClientHeight())
11894    y2 = ASPx.GetDocumentScrollTop() + ASPx.GetDocumentClientHeight();
11895   x = x1 + ((x2 - x1 - loadingPanel.offsetWidth) / 2);
11896   y = y1 + ((y2 - y1 - loadingPanel.offsetHeight) / 2);
11897  }
11898  if(ASPx.IsExists(offsetX) && ASPx.IsExists(offsetY)){
11899   x += offsetX;
11900   y += offsetY;
11901  }
11902  x = ASPx.PrepareClientPosForElement(x, loadingPanel, true);
11903  y = ASPx.PrepareClientPosForElement(y, loadingPanel, false);
11904  ASPx.SetStyles(loadingPanel, { left: x, top: y });
11905 },
11906 GetLoadingDiv: function(){
11907  return ASPx.GetElementById(this.name + "_LD");
11908 },
11909 CreateLoadingDiv: function(parentElement, offsetElement){
11910  if(this.ShouldHideExistingLoadingElements())
11911   this.HideLoadingDiv();
11912  if(parentElement == null) 
11913   return null;
11914  if(!this.IsLoadingContainerVisible()) {
11915   this.hasPhantomLoadingElements = true;
11916   return null;
11917  }
11918  if(!offsetElement)
11919   offsetElement = parentElement;
11920  var div = this.GetLoadingDiv();
11921  if(div != null){
11922   div = div.cloneNode(true);
11923   parentElement.appendChild(div);
11924   ASPx.SetElementDisplay(div, true);
11925   ASPx.Evt.AttachEventToElement(div, ASPx.TouchUIHelper.touchMouseDownEventName, ASPx.Evt.PreventEvent);
11926   ASPx.Evt.AttachEventToElement(div, ASPx.TouchUIHelper.touchMouseMoveEventName, ASPx.Evt.PreventEvent);
11927   ASPx.Evt.AttachEventToElement(div, ASPx.TouchUIHelper.touchMouseUpEventName, ASPx.Evt.PreventEvent);
11928   ASPx.Evt.AttachEventToElement(div, ASPx.Evt.GetMouseWheelEventName(), ASPx.Evt.PreventEvent);
11929   this.SetLoadingDivBounds(offsetElement, div);
11930   this.loadingDivElement = div;
11931   this.SetInitialLoadingDivOpacity();
11932   return div;
11933  }
11934  return null;
11935 },
11936 SetInitialLoadingDivOpacity: function() {
11937  if(!this.loadingDivElement) return;
11938  ASPx.Attr.SaveStyleAttribute(this.loadingDivElement, "opacity");
11939  ASPx.Attr.SaveStyleAttribute(this.loadingDivElement, "filter");
11940  ASPx.SetElementOpacity(this.loadingDivElement, 0.01);
11941 },
11942 RestoreLoadingDivOpacity: function() {
11943  if(!this.loadingDivElement) return;
11944  ASPx.Attr.RestoreStyleAttribute(this.loadingDivElement, "opacity");
11945  ASPx.Attr.RestoreStyleAttribute(this.loadingDivElement, "filter");
11946 },
11947 SetLoadingDivBounds: function(offsetElement, loadingDiv) {
11948  var absX = (offsetElement == document.body) ? 0 : ASPx.GetAbsoluteX(offsetElement);
11949  var absY = (offsetElement == document.body) ? 0 : ASPx.GetAbsoluteY(offsetElement);
11950  ASPx.SetStyles(loadingDiv, {
11951   left: ASPx.PrepareClientPosForElement(absX, loadingDiv, true),
11952   top: ASPx.PrepareClientPosForElement(absY, loadingDiv, false)
11953  });
11954  var width = (offsetElement == document.body) ? ASPx.GetDocumentWidth() : offsetElement.offsetWidth;
11955  var height = (offsetElement == document.body) ? ASPx.GetDocumentHeight() : offsetElement.offsetHeight;
11956  if(height < 0) 
11957   height = 0;
11958  ASPx.SetStyles(loadingDiv, { width: width, height: height });

11959  var correctedWidth = 2 * width - loadingDiv.offsetWidth;
11960  if(correctedWidth <= 0) correctedWidth = width;
11961  var correctedHeight = 2 * height - loadingDiv.offsetHeight;
11962  if(correctedHeight <= 0) correctedHeight = height;
11963  ASPx.SetStyles(loadingDiv, { width: correctedWidth, height: correctedHeight });
11964 },
11965 ShowLoadingDiv: function() {
11966 },
11967 HideLoadingDiv: function() {
11968  this.hasPhantomLoadingElements = false;
11969  if(ASPx.IsExistsElement(this.loadingDivElement)){
11970   ASPx.RemoveElement(this.loadingDivElement);
11971   this.loadingDivElement = null;
11972  }
11973 },
11974 CanHandleGesture: function(evt) {
11975  return false;
11976 },
11977 CanHandleGestureCore: function(evt) {
11978  var source = ASPx.Evt.GetEventSource(evt);
11979  if(ASPx.GetIsParent(this.loadingPanelElement, source) || ASPx.GetIsParent(this.loadingDivElement, source))
11980   return true; 
11981  var callbackAnimationElement = this.GetCallbackAnimationElement();
11982  if(!callbackAnimationElement)
11983   return false;
11984  var animationContainer = ASPx.AnimationHelper.getSlideAnimationContainer(callbackAnimationElement, false, false);
11985  if(animationContainer && ASPx.GetIsParent(animationContainer, source) && !ASPx.GetIsParent(animationContainer.childNodes[0], source))
11986   return true; 
11987  return this.CanHandleGesture(evt); 
11988 },
11989 AllowStartGesture: function() {

11990  return !this.beginCallbackAnimationProcessing && !this.endCallbackAnimationProcessing;
11991 },
11992 StartGesture: function() {
11993 },
11994 AllowExecuteGesture: function(value) {
11995  return false;
11996 },
11997 ExecuteGesture: function(value) {
11998 },
11999 CancelGesture: function(value) {
12000  if(this.repeatedGestureCount === 0) {
12001   this.repeatedGestureValue = value;
12002   this.repeatedGestureCount = 1;
12003  }
12004  else {
12005   if(this.repeatedGestureValue * value > 0)
12006    this.repeatedGestureCount++;
12007   else
12008    this.repeatedGestureCount--;
12009   if(this.repeatedGestureCount === 0)
12010    this.repeatedGestureCount = 0;
12011  }
12012 },
12013 CheckRepeatGesture: function() {
12014  if(this.repeatedGestureCount !== 0) {
12015   if(this.AllowExecuteGesture(this.repeatedGestureValue))
12016    this.ExecuteGesture(this.repeatedGestureValue, this.repeatedGestureCount);
12017   this.repeatedGestureValue = 0;
12018   this.repeatedGestureCount = 0;
12019  }
12020 },
12021 AllowExecutePagerGesture: function (pageIndex, pageCount, value) {
12022  if(pageIndex < 0) return false;
12023  if(pageCount <= 1) return false;
12024  if(value > 0 && pageIndex === 0) return false;
12025  if(value < 0 && pageIndex === pageCount - 1) return false;
12026  return true;
12027 },
12028 ExecutePagerGesture: function(pageIndex, pageCount, value, count, method) {
12029  if(!count) count = 1;
12030  var pageIndex = pageIndex + (value < 0 ? count : -count);
12031  if(pageIndex < 0) pageIndex = 0;
12032  if(pageIndex > pageCount - 1) pageIndex = pageCount - 1;
12033  method(PagerCommands.PageNumber + pageIndex);
12034 },
12035 RaiseInit: function(){
12036  if(!this.Init.IsEmpty()){
12037   var args = new ASPxClientEventArgs();
12038   this.Init.FireEvent(this, args);
12039  }
12040 },
12041 RaiseBeginCallbackInternal: function(command){
12042  if(!this.BeginCallback.IsEmpty()){
12043   var args = new ASPxClientBeginCallbackEventArgs(command);
12044   this.BeginCallback.FireEvent(this, args);
12045  }
12046 },
12047 RaiseEndCallbackInternal: function(command) {
12048  if(!this.EndCallback.IsEmpty()){
12049   var args = new ASPxClientEndCallbackEventArgs(command);
12050   this.EndCallback.FireEvent(this, args);
12051  }
12052 },
12053 RaiseCallbackErrorInternal: function(message, callbackId) {
12054  if(!this.CallbackError.IsEmpty()) {
12055   var args = new ASPxClientCallbackErrorEventArgs(message, callbackId);
12056   this.CallbackError.FireEvent(this, args);
12057   if(args.handled)
12058    return { isHandled: true, errorMessage: args.message };
12059  }
12060 },
12061 RaiseBeginCallback: function(command){
12062  this.RaiseBeginCallbackInternal(command);    
12063  aspxGetControlCollection().RaiseBeginCallback(this, command);
12064 },
12065 RaiseEndCallback: function(command){
12066  this.RaiseEndCallbackInternal(command);
12067  aspxGetControlCollection().RaiseEndCallback(this, command);
12068 },
12069 RaiseCallbackError: function (message, callbackId) {
12070  var result = this.RaiseCallbackErrorInternal(message, callbackId);
12071  if(!result) 
12072   result = aspxGetControlCollection().RaiseCallbackError(this, message, callbackId);
12073  return result;
12074 },
12075 RaiseEndCallbackAnimationStart: function(){
12076  if(!this.EndCallbackAnimationStart.IsEmpty()){
12077   var args = new ASPxClientEventArgs();
12078   this.EndCallbackAnimationStart.FireEvent(this, args);
12079  }
12080 },
12081 RaiseBeforePronounce: function(message) {
12082  var args = new ASPxClientControlBeforePronounceEventArgs(message, this);
12083  if(!this.BeforePronounce.IsEmpty())
12084   this.BeforePronounce.FireEvent(this, args);
12085  return args;
12086 },
12087 RaiseUnload: function() {
12088  var args = new ASPxClientControlUnloadEventArgs(this);
12089  if(!this.Unload.IsEmpty())
12090   this.Unload.FireEvent(this, args);
12091 },
12092 RaiseDisposed: function() {
12093  this.Disposed.FireEvent(this, new ASPxClientEventArgs(this));
12094 },
12095 SendMessageToAssistiveTechnology: function(message) {
12096  if(!this.accessibilityCompliant)
12097   return;
12098  this.PronounceMessageInternal(message, ASPx.AccessibilityPronouncerType.live);
12099 },
12100 PronounceMessageInternal: function(messageArg, type) {
12101  var message = messageArg;
12102  if(!ASPx.Ident.IsArray(messageArg))
12103   message = [messageArg];
12104  var args = this.RaiseBeforePronounce(message);
12105  ASPx.AccessibilityPronouncer.Pronounce(args, type);
12106 },
12107 IsVisible: function() {
12108  var element = this.GetMainElement();
12109  return ASPx.IsElementVisible(element);
12110 },
12111 IsDisplayedElement: function(element) {
12112  while(element && element.tagName != "BODY") {
12113   if(!ASPx.GetElementDisplay(element)) 
12114    return false;
12115   element = element.parentNode;
12116  }
12117  return true;
12118 },
12119 IsDisplayed: function() {
12120  return this.IsDisplayedElement(this.GetMainElement());
12121 },
12122 IsHiddenElement: function(element) {
12123  return element && element.offsetWidth == 0 && element.offsetHeight == 0;
12124 },
12125 IsHidden: function() {
12126  return this.IsHiddenElement(this.GetMainElement());
12127 },
12128 IsDisposed: function() {
12129  return this.disposed;
12130 },
12131 GetParentControl: function() {
12132  var mainElement = this.getActualMainElement();
12133  var popupPostfix = ASPx.PCWIdSuffix + "-1";
12134  var result = null;
12135  ASPx.GetParent(mainElement, function(element) {

12136   if(element === mainElement || !element.id)
12137    return false;
12138   var controlName = element.id.replace(popupPostfix, "");
12139   result = ASPx.GetControlCollection().Get(controlName);
12140   return !!result;
12141  });
12142  return result;
12143 },
12144 getActualMainElement: function() { return this.GetMainElement(); },
12145 findParentByType: function (type) {
12146  var ctrl = this;
12147  while (ctrl) {
12148   var parent = ctrl.GetParentControl();
12149   if (parent && parent instanceof type)
12150    return parent;
12151   ctrl = parent;
12152  }
12153  return null;
12154 },
12155 Focus: function() {
12156 },
12157 GetClientVisible: function(){
12158  return this.GetVisible();
12159 },
12160 SetClientVisible: function(visible){
12161  this.SetVisible(visible);
12162 },
12163 GetVisible: function(){
12164  return this.clientVisible;
12165 },
12166 SetVisible: function(visible){
12167  if(this.clientVisible != visible){
12168   this.clientVisible = visible;
12169   ASPx.SetElementDisplay(this.GetMainElement(), visible);
12170   if(visible) {
12171    this.AdjustControl();
12172    var mainElement = this.GetMainElement();
12173    if(mainElement)
12174     aspxGetControlCollection().AdjustControls(mainElement);
12175   }
12176  }
12177 },
12178 GetEnabled: function() {
12179  return this.clientEnabled;
12180 },
12181 SetEnabled: function(enabled) {
12182  this.clientEnabled = enabled;
12183  if(ASPxClientControl.setEnabledLocked)
12184   return;
12185  else

12186   ASPxClientControl.setEnabledLocked = true;
12187  this.savedClientEnabled = enabled;
12188  aspxGetControlCollection().ProcessControlsInContainer(this.GetMainElement(), function(control) {
12189   if(ASPx.IsFunction(control.SetEnabled))
12190    control.SetEnabled(enabled && control.savedClientEnabled);
12191  });
12192  delete ASPxClientControl.setEnabledLocked;
12193 },
12194 InCallback: function() {
12195  return this.requestCount > 0;
12196 },
12197 DoBeginCallback: function(command) {
12198  this.RaiseBeginCallback(command || "");
12199  aspxGetControlCollection().Before_WebForm_InitCallback(this.name);
12200  if(typeof(WebForm_InitCallback) != "undefined" && WebForm_InitCallback) {
12201   __theFormPostData = "";
12202   __theFormPostCollection = [ ];
12203   this.ClearPostBackEventInput("__EVENTTARGET");
12204   this.ClearPostBackEventInput("__EVENTARGUMENT");
12205   WebForm_InitCallback();
12206   this.savedFormPostData = __theFormPostData;
12207   this.savedFormPostCollection = __theFormPostCollection;
12208  }
12209 },
12210 ClearPostBackEventInput: function(id){
12211  var element = ASPx.GetElementById(id);
12212  if(element != null) element.value = "";
12213 },
12214 PerformDataCallback: function(arg, handler) {
12215  this.CreateCustomDataCallback(arg, "", handler);
12216 },
12217 sendCallbackViaQueue: function (prefix, arg, showLoadingPanel, context, handler, onBeforeSend) {
12218  if (!this.useCallbackQueue())
12219   return false;
12220  var context = context || this;
12221  var token = this.callbackQueueHelper.sendCallback(ASPx.FormatCallbackArg(prefix, arg), context, handler || context.OnCallback, prefix, onBeforeSend);
12222  if (showLoadingPanel)
12223   this.callbackQueueHelper.showLoadingElements();
12224  return token;
12225 },
12226 CreateCallback: function (arg, command, handler) {
12227  var callbackInfo = this.CreateCallbackInfo(ASPx.CallbackType.Common, handler || null);
12228  var callbackID = this.CreateCallbackByInfo(arg, command, callbackInfo);
12229  return callbackID;
12230 },
12231 CreateCustomDataCallback: function(arg, command, handler) {
12232  var callbackInfo = this.CreateCallbackInfo(ASPx.CallbackType.Data, handler);
12233  this.CreateCallbackByInfo(arg, command, callbackInfo);
12234 },
12235 CreateCallbackByInfo: function(arg, command, callbackInfo) {
12236  if(!this.CanCreateCallback()) return;
12237  var callbackID;
12238  if(typeof(WebForm_DoCallback) != "undefined" && WebForm_DoCallback && ASPx.documentLoaded || ASPx.Platform === "NETCORE")
12239   callbackID = this.CreateCallbackInternal(arg, command, true, callbackInfo);
12240  else {
12241   if(!this.savedCallbacks)
12242    this.savedCallbacks = [];
12243   var callbackInfo = { arg: arg, command: command, callbackInfo: callbackInfo };
12244   if(this.allowMultipleCallbacks)
12245    this.savedCallbacks.push(callbackInfo);
12246   else
12247    this.savedCallbacks[0] = callbackInfo;
12248  }
12249  return callbackID;
12250 },
12251 CreateCallbackInternal: function(arg, command, viaTimer, callbackInfo) {
12252  var watcher = ASPx.ControlUpdateWatcher.getInstance();
12253  if(watcher && !watcher.CanSendCallback(this, arg)) {
12254   this.CancelCallbackInternal();
12255   return;
12256  }
12257  this.requestCount++;
12258  this.DoBeginCallback(command);
12259  if(typeof(arg) == "undefined")
12260   arg = "";
12261  if(typeof(command) == "undefined")
12262   command = "";
12263  var callbackID = this.SaveCallbackInfo(callbackInfo, command),
12264   customArgs = this.GetCustomCallbackArgs();
12265  if(viaTimer)
12266   window.setTimeout(function() { this.CreateCallbackCoreWithCustomArgs(arg, command, callbackID, customArgs); }.aspxBind(this), 0);
12267  else
12268   this.CreateCallbackCoreWithCustomArgs(arg, command, callbackID, customArgs);
12269  return callbackID;
12270 },
12271 CreateCallbackCoreWithCustomArgs: function(arg, command, callbackID, customArgs) {
12272  this.CreateCallbackCore(arg, command, callbackID);
12273 },
12274 GetCustomCallbackArgs: function() {
12275  return {};
12276 },
12277 CancelCallbackInternal: function() {
12278  this.CancelCallbackCore();
12279  this.HideLoadingElements();
12280 },
12281 CancelCallbackCore: function() {
12282 },
12283 CreateCallbackCore: function(arg, command, callbackID) {
12284  var callBackMethod = this.GetCallbackMethod(command);
12285  __theFormPostData = this.savedFormPostData;
12286  __theFormPostCollection = this.savedFormPostCollection;
12287  callBackMethod.call(this, this.GetSerializedCallbackInfoByID(callbackID) + arg);
12288 },
12289 GetCallbackMethod: function(command){
12290  return this.callBack;
12291 },
12292 CanCreateCallback: function() {
12293  return !this.InCallback() || (this.allowMultipleCallbacks && !this.beginCallbackA

12293nimationProcessing && !this.endCallbackAnimationProcessing);
12294 },
12295 DoLoadCallbackScripts: function() {
12296  ASPx.ProcessScriptsAndLinks(this.name, true);
12297 },
12298 DoEndCallback: function() {
12299  if(this.IsCallbackAnimationEnabled() && this.CheckEndCallbackAnimationNeeded()) 
12300   return;
12301  this.requestCount--;
12302  if (this.requestCount < 1) 
12303   this.callbackHandlersQueue.executeCallbacksHandlers();
12304  if(this.HideLoadingPanelOnCallback() && this.requestCount < 1) 
12305   this.HideLoadingElements();
12306  if(this.isSwipeGesturesEnabled() && this.supportGestures) {
12307   ASPx.GesturesHelper.UpdateSwipeAnimationContainer(this.name);
12308   if(this.touchUIMouseScroller)
12309    this.touchUIMouseScroller.update();
12310  }
12311  this.isCallbackAnimationPrevented = false;
12312  this.OnCallbackFinalized();
12313  this.AssignEllipsisTooltips();
12314  var command = this.GetCallbackCommand();
12315  this.RaiseEndCallback(command);
12316  this.InitializeIntersectionObserversManager();
12317  this.currentCallbackID = -1;
12318 },
12319 DoFinalizeCallback: function() {
12320 },
12321 OnCallbackFinalized: function() {
12322 },
12323 AssignEllipsisTooltips: function() { },
12324 GetCallbackCommand: function() {
12325  var result = "";
12326  if(this.currentCallbackID != -1) {
12327   var command = this.callbackCommand[this.currentCallbackID];
12328   if(command)
12329    result = command;
12330  }
12331  return result;
12332 },
12333 HideLoadingPanelOnCallback: function() {
12334  return true;
12335 },
12336 ShouldHideExistingLoadingElements: function() {
12337  return true;
12338 },
12339 EvalCallbackResult: function(resultString) {
12340  return eval(resultString);
12341 },
12342 ParseJSProperties: function(resultObj) {
12343  if(resultObj.cp) {
12344   for(var name in resultObj.cp)
12345    if(resultObj.cp.hasOwnProperty(name)) {
12346     this[name] = resultObj.cp[name];
12347     if(this.aspNetCoreWrapperInstance)
12348      this.aspNetCoreWrapperInstance[name] = resultObj.cp[name]; 
12349    }
12350  }
12351 },
12352 DoCallback: function(result) {
12353  if(this.IsCallbackAnimationEnabled() && this.CheckBeginCallbackA

12353nimationInProgress(result))
12354   return;
12355  result = ASPx.Str.Trim(result);
12356  if(result instanceof ASPx.NetworkError || result.indexOf(ASPx.CallbackResultPrefix) != 0)
12357   this.ProcessCallbackGeneralError(result, false);
12358  else {
12359   var resultObj = null;
12360   try {
12361    resultObj = this.EvalCallbackResult(result);
12362   } 
12363   catch(e) {
12364   }
12365   if(resultObj) {
12366    this.currentCallbackID = resultObj.id;
12367    ASPx.CacheHelper.DropCache(this);
12368    if(resultObj.redirect) {
12369     this.ParseJSProperties(resultObj); 
12370     ASPx.Url.Redirect(resultObj.redirect);
12371    }
12372    else if(ASPx.IsExists(resultObj.generalError)) {
12373     this.ProcessCallbackGeneralError(resultObj.generalError, true);
12374    }
12375    else {
12376     var errorObj = resultObj.error;
12377     if(errorObj) { 
12378      if(this.parseJSPropertiesOnCallbackError)
12379       this.ParseJSProperties(resultObj);
12380      this.ProcessCallbackError(errorObj,resultObj.id);
12381     } else {
12382      this.ParseJSProperties(resultObj);
12383      var callbackInfo = this.DequeueCallbackInfo(resultObj.id);
12384      if(callbackInfo && callbackInfo.type == ASPx.CallbackType.Data)
12385       this.ProcessCustomDataCallback(resultObj.result, callbackInfo);
12386      else {
12387       if (this.useCallbackQueue() && this.callbackQueueHelper.getCallbackInfoById(resultObj.id))
12388        this.callbackQueueHelper.processCallback(resultObj.result, resultObj.id);
12389       else {
12390        this.ProcessCallback(resultObj.result, resultObj.id);
12391        if(callbackInfo && callbackInfo.handler) {
12392         var handlerInfo = { handler: callbackInfo.handler, result: resultObj.result.data };
12393         this.callbackHandlersQueue.addCallbackHandler(handlerInfo);
12394        }
12395       }
12396      }
12397     }
12398    }
12399   }
12400  }
12401  this.DoLoadCallbackScripts();
12402 },
12403 DoCallbackError: function(result) {
12404  this.HideLoadingElements();
12405  this.ProcessCallbackGeneralError(result, false); 
12406 },
12407 DoControlClick: function(evt) {
12408  this.OnControlClick(ASPx.Evt.GetEventSource(evt), evt);
12409 },
12410 ProcessCallback: function (result, callbackId) {
12411  this.OnCallback(result, callbackId);
12412 },
12413 ProcessCustomDataCallback: function(result, callbackInfo) {
12414  if(callbackInfo.handler != null)
12415   callbackInfo.handler(this, result);
12416  this.RaiseCustomDataCallback(result);
12417 },
12418 RaiseCustomDataCallback: function(result) {
12419  if(!this.CustomDataCallback.IsEmpty()) {
12420   var arg = new ASPxClientCustomDataCallbackEventArgs(result);
12421   this.CustomDataCallback.FireEvent(this, arg);
12422  }
12423 },
12424 OnCallback: function(result) {
12425 },
12426 CreateCallbackInfo: function(type, handler) {
12427  return { type: type, handler: handler };
12428 },
12429 GetSerializedCallbackInfoByID: function(callbackID) {
12430  return this.GetCallbackInfoByID(callbackID).type + callbackID + ASPx.CallbackSeparator;
12431 },
12432 SaveCallbackInfo: function(info, command) {
12433  var callbacks = this.GetActiveCallbacksInfo();
12434  var index = callbacks.indexOf(null);
12435  if(index === -1)
12436   index = callbacks.length;
12437  callbacks[index] = info;
12438  this.callbackCommand[index] = command;
12439  return index;
12440 },
12441 GetActiveCallbacksInfo: function() {
12442  var persistentProperties = this.GetPersistentProperties();
12443  if(!persistentProperties.activeCallbacks)
12444   persistentProperties.activeCallbacks = [ ];
12445  return persistentProperties.activeCallbacks;
12446 },
12447 GetPersistentProperties: function() {
12448  var storage = _aspxGetPersistentControlPropertiesStorage();
12449  var persistentProperties = storage[this.name];
12450  if(!persistentProperties) {
12451   persistentProperties = { };
12452   storage[this.name] = persistentProperties;
12453  }
12454  return persistentProperties;
12455 },
12456 GetCallbackInfoByID: function(callbackID) {
12457  return this.GetActiveCallbacksInfo()[callbackID];
12458 },
12459 DequeueCallbackInfo: function(index) {
12460  var activeCallbacksInfo = this.GetActiveCallbacksInfo();
12461  if(index < 0 || index >= activeCallbacksInfo.length)
12462   return null;
12463  var result = activeCallbacksInfo[index];
12464  activeCallbacksInfo[index] = null;
12465  return result;
12466 },
12467 ProcessCallbackError: function (errorObj, callbackId) {
12468  var data = ASPx.IsExists(errorObj.data) ? errorObj.data : null;
12469  var result = this.RaiseCallbackError(errorObj.message, callbackId);
12470  if(result.isHandled)
12471   this.OnCallbackErrorAfterUserHandle(result.errorMessage, data); 
12472  else
12473   this.OnCallbackError(result.errorMessage, data); 
12474 },
12475 OnCallbackError: function(errorMessage, data) {
12476  if(errorMessage)
12477   ASPx.ShowErrorAlert(errorMessage);
12478 },
12479 OnCallbackErrorAfterUserHandle: function(errorMessage, data) {
12480 },
12481 ProcessCallbackGeneralError: function(error, serverExceptionOnLastCallback) {
12482  this.serverExceptionOnLastCallback = serverExceptionOnLastCallback;
12483  var isNetworkError = error instanceof ASPx.NetworkError;
12484  var errorMessage = isNetworkError ? error.message : error;
12485  var result = this.RaiseCallbackError(errorMessage);
12486  if(result.isHandled)
12487   this.OnCallbackGeneralErrorAfterUserHandle(result.errorMessage);
12488  else if(isNetworkError)
12489   this.OnCallbackNetworkError(result.errorMessage);
12490  else
12491   this.OnCallbackGeneralError(result.errorMessage);
12492 },
12493 OnCallbackGeneralError: function(errorMessage) {
12494  this.OnCallbackError(errorMessage, null);
12495 },
12496 OnCallbackNetworkError: function(errorMessage) {
12497  console.error(errorMessage);
12498 },
12499 OnCallbackGeneralErrorAfterUserHandle: function (errorMessage) {
12500 },

12501 SendPostBack: function(params, preventConvertToUpdatePanelCallback) {
12502  if(preventConvertToUpdatePanelCallback)
12503   this.sendMSAjaxCompatPostBack(params);
12504  else
12505   this.sendPostBackInternal(params);
12506 },
12507 sendPostBackInternal: function(params) {
12508  if(typeof(__doPostBack) != "undefined")
12509   __doPostBack(this.uniqueID, params);
12510  else{
12511   var form = this.GetParentForm();
12512   if(form) form.submit();
12513  }
12514 },
12515 sendMSAjaxCompatPostBack: function(params) {
12516  var rm = ASPx.GetMSAjaxRequestManager();
12517  var triggers = rm ? rm._postBackControlClientIDs : null;
12518  var needRegister = triggers && ASPx.Ident.IsArray(triggers) && ASPx.Data.ArrayIndexOf(triggers, this.name) == -1;
12519  if(needRegister)
12520   triggers.unshift(this.name);
12521  this.sendPostBackInternal(params);
12522  if(needRegister)
12523   triggers.shift();
12524 },
12525 IsValidInstance: function () {
12526  return aspxGetControlCollection().GetByName(this.name) === this;
12527 },
12528 OnDispose: function() { 
12529  this.RaiseDisposed();
12530  var varName = this.globalName;
12531  if(varName && varName !== "" && window && window[varName] && window[varName] == this){
12532   try{
12533    delete window[varName];
12534   }
12535   catch(e){  }
12536  }
12537  if(this.callbackQueueHelper)
12538   this.callbackQueueHelper.detachEvents();
12539  if (!this.IsDisposed())
12540   this.disposed = true;
12541 },
12542 OnGlobalControlsInitialized: function(args) { 
12543 },
12544 OnGlobalBrowserWindowResized: function(args) { 
12545 },
12546 OnGlobalBeginCallback: function(args) { 
12547 },
12548 OnGlobalEndCallback: function(args) { 
12549 },
12550 OnGlobalCallbackError: function(args) { 
12551 },
12552 OnGlobalValidationCompleted: function(args) { 
12553 },
12554 AddDefaultStateControllerItems: function() {
12555  var states = this.scStates;
12556  if(!states) return;
12557  var postfix = this.scPostfix ? ("_" + this.scPostfix) : "";
12558  var mainElementId = this.GetMainElementId();
12559  if(states & 2)
12560   this.AddDefaultReadOnlyStateControllerItem(this.scPrefix + "ReadOnly" + postfix, mainElementId);
12561  if(states & 4)
12562   this.AddDefaultDisabledStateControllerItem(this.scPrefix + "Disabled" + postfix, mainElementId);
12563 },
12564 AddDefaultReadOnlyStateControllerItem: function(cssClass, mainElementId) { throw "Not implemented"; },
12565 AddDefaultDisabledStateControllerItem: function(cssClass, mainElementId) { throw "Not implemented"; },
12566 DOMContentLoaded: function() { },
12567 IsStateControllerEnabled: function() { return false; },
12568 InitializeDOM: function() {
12569  var mainElement = this.GetMainElement();
12570  if(mainElement)
12571   ASPx.SetElementInitializedFlag(mainElement);
12572 },
12573 IsDOMInitialized: function() {
12574  var mainElement = this.GetMainElement();
12575  return mainElement && ASPx.GetElementInitializedFlag(mainElement);
12576 },
12577 AdjustControl: function(nestedCall) { },
12578 OnBrowserWindowResizeInternal: function(e) { },
12579 RegisterInControlTree: function(tree) { },
12580 InitializeIntersectionObserversManager: function () {
12581  var elementToObserve = this.getElementToObserveVisibilityChange();
12582  if(elementToObserve) {
12583   ASPx.IntersectionObserversManager.SubscribeElemensVisibilityChangeInBrowserWindow(elementToObserve, this.processVisibilityChanged.bind(this));
12584  }
12585 },
12586 getElementToObserveVisibilityChange: function () { },
12587 processVisibilityChanged: function (visible) { }
12588});
12589ASPxClientControlBase.Cast = function(obj) {
12590 if(typeof obj == "string")
12591  return window[obj];
12592 return obj;
12593};
12594var persistentControlPropertiesStorage = null;
12595function _aspxGetPersistentControlPropertiesStorage() {
12596 if(persistentControlPropertiesStorage == null)
12597  persistentControlPropertiesStorage = { };
12598 return persistentControlPropertiesStorage;
12599}
12600var ELLIPSIS_MARKER_CLASS = "dx-ellipsis";
12601var ELLIPSIS_TOOLTIP_MARKER_ATTR = "dxEllipsisTitle";
12602var ASPxClientControl = ASPx.CreateClass(ASPxClientControlBase, {
12603 constructor: function(name){
12604  this.constructor.prototype.constructor.call(this, name);
12605  this.rtl = false;
12606  this.enableEllipsis = false;
12607  this.isNative = false;
12608  this.isControlCollapsed = false;
12609  this.isInsideHierarchyAdjustment = false;
12610  this.controlOwner = null;
12611  this.adjustedSizes = { };
12612  this.dialogContentHashTable = { };
12613  this.renderIFrameForPopupElements = false;
12614  this.widthValueSetInPercentage = false;
12615  this.heightValueSetInPercentage = false;
12616  this.verticalAlignedElements = { };
12617  this.wrappedTextContainers = { };
12618  this.scrollPositionState = { };
12619  this.sizingConfig = {
12620   allowSetWidth: true,
12621   allowSetHeight: true,
12622   correction : false,
12623   adjustControl : false,
12624   supportPercentHeight: false,
12625   supportAutoHeight: false
12626  };
12627  this.percentSizeConfig = {
12628   width: -1,
12629   height: -1,
12630   markerWidth: -1,
12631   markerHeight: -1
12632  };  
12633 },
12634 querySelector: function(selector) { return this.querySelectorAll(selector)[0] || null; },
12635 querySelectorAll: function(selector) {
12636  return ASPx.CacheHelper.GetCachedElement(this, "querySelectorAll_" + selector,
12637   function() { return Array.prototype.slice.call(this.GetMainElement().querySelectorAll(selector)); });
12638 },
12639 createAccessKey: function (popupItem, getPopupElement, keyTipElement, key, onlyClick, manualStopProcessing) {
12640  return new ASPx.AccessKey(popupItem, getPopupElement, keyTipElement, key, onlyClick, manualStopProcessing);
12641 },
12642 InlineInitialize: function() {
12643  this.InitializeDOM();
12644  ASPxClientControlBase.prototype.InlineInitialize.call(this);
12645 },
12646 AfterCreate: function() { 
12647  ASPxClientControlBase.prototype.AfterCreate.call(this);
12648  if(!this.CanInitializeAdjustmentOnDOMContentLoaded() || ASPx.IsStartupScriptsRunning())
12649   this.InitializeAdjustment();
12650 },
12651 DOMContentLoaded: function() {
12652  if(this.CanInitializeAdjustmentOnDOMContentLoaded()) 
12653   this.InitializeAdjustment();
12654 },
12655 CanInitializeAdjustmentOnDOMContentLoaded: function() {
12656  return true;
12657 },
12658 InitializeAdjustment: function() {
12659  this.UpdateAdjustmentFlags();
12660  this.AdjustControl();
12661 },
12662 AfterInitialize: function() {
12663  this.AdjustControl();
12664  ASPxClientControlBase.prototype.AfterInitialize.call(this);
12665 },
12666 IsStateControllerEnabled: function(){
12667  return typeof(ASPx.GetStateController) != "undefined" && ASPx.GetStateController();
12668 },
12669 GetWidth: function() {
12670  return this.GetMainElement().offsetWidth;
12671 },
12672 GetHeight: function() {
12673  return this.GetMainElement().offsetHeight;
12674 },
12675 SetWidth: function(width) {
12676  if(this.sizingConfig.allowSetWidth)

12677   this.SetSizeCore("width", width, "GetWidth", false);
12678 },
12679 SetHeight: function(height) {
12680  if(this.sizingConfig.allowSetHeight)
12681   this.SetSizeCore("height", height, "GetHeight", false);
12682 },
12683 SetSizeCore: function(sizePropertyName, size, getFunctionName, corrected) {
12684  if(size < 0 || !this.GetMainElement())
12685   return;
12686  this.GetMainElement().style[sizePropertyName] = size + "px";
12687  this.UpdateAdjustmentFlags(sizePropertyName);
12688  if(this.sizingConfig.adjustControl)
12689   this.AdjustControl(true);
12690  if(this.sizingConfig.correction && !corrected) {
12691   var realSize = this[getFunctionName]();
12692   if(realSize != size) {
12693    var correctedSize = size - (realSize - size);
12694    this.SetSizeCore(sizePropertyName, correctedSize, getFunctionName, true);
12695   }
12696  }
12697 },
12698 AdjustControl: function(nestedCall) {
12699  if(this.IsAdjustmentRequired() && (!ASPxClientControl.adjustControlLocked || nestedCall)) {
12700   ASPxClientControl.adjustControlLocked = true;
12701   try {
12702    if(!this.IsAdjustmentAllowed())
12703     return;
12704    this.AdjustControlCore();
12705    this.UpdateAdjustedSizes();
12706   } 
12707   finally {
12708    delete ASPxClientControl.adjustControlLocked;
12709   }
12710  }
12711  this.AssignEllipsisTooltips();
12712  this.TryShowPhantomLoadingElements();
12713 },
12714 ResetControlAdjustment: function () {
12715  this.adjustedSizes = { };
12716 },
12717 UpdateAdjustmentFlags: function(sizeProperty) {
12718  var mainElement = this.GetMainElement();
12719  if(mainElement) {
12720   var mainElementStyle = ASPx.GetCurrentStyle(mainElement);
12721   this.UpdatePercentSizeConfig([mainElementStyle.width, mainElement.style.width], [mainElementStyle.height, mainElement.style.height], sizeProperty);
12722  }
12723 },
12724 UpdatePercentSizeConfig: function(widths, heights, modifyStyleProperty) {
12725  switch(modifyStyleProperty) {
12726   case "width":
12727    this.UpdatePercentWidthConfig(widths);
12728    break;
12729   case "height":
12730    this.UpdatePercentHeightConfig(heights);
12731    break;
12732   default:
12733    this.UpdatePercentWidthConfig(widths);
12734    this.UpdatePercentHeightConfig(heights);
12735    break;
12736  }
12737  this.ResetControlPercentMarkerSize();
12738 },
12739 UpdatePercentWidthConfig: function(widths) {
12740  this.widthValueSetInPercentage = false;
12741  for(var i = 0; i < widths.length; i++) {
12742   if(this.IsPercentageWidth(widths[i])) {
12743    this.percentSizeConfig.width = widths[i];
12744    this.widthValueSetInPercentage = true;
12745    break;
12746   }
12747  }
12748 },
12749 IsPercentageWidth: function(width) { return ASPx.IsPercentageSize(width); },
12750 UpdatePercentHeightConfig: function(heights) {
12751  this.heightValueSetInPercentage = false;
12752    for(var i = 0; i < heights.length; i++) {
12753   if(ASPx.IsPercentageSize(heights[i])) {
12754    this.percentSizeConfig.height = heights[i];
12755    this.heightValueSetInPercentage = true;
12756    break;
12757   }
12758  }
12759 },
12760 GetAdjustedSizes: function() {
12761  var mainElement = this.GetMainElement();
12762  if(mainElement) 
12763   return { width: mainElement.offsetWidth, height: mainElement.offsetHeight };
12764  return { width: 0, height: 0 };
12765 },
12766 IsAdjusted: function() {
12767  return (this.adjustedSizes.width && this.adjustedSizes.width > 0) && (this.adjustedSizes.height && this.adjustedSizes.height > 0);
12768 },
12769 IsAdjustmentRequired: function() {
12770  if(!this.IsAdjusted())
12771   return true;
12772  if(this.widthValueSetInPercentage)
12773   return true;
12774  if(this.heightValueSetInPercentage)
12775   return true;
12776  var sizes = this.GetAdjustedSizes();
12777  for(var name in sizes){
12778   if(this.adjustedSizes[name] !== sizes[name])
12779    return true;
12780  }
12781  return false;
12782 },
12783 IsAdjustmentAllowed: function() {
12784  var mainElement = this.GetMainElement();
12785  return mainElement && this.IsDisplayed() && !this.IsHidden() && this.IsDOMInitialized();
12786 },
12787 UpdateAdjustedSizes: function() {
12788  var sizes = this.GetAdjustedSizes();
12789  for(var name in sizes)
12790   if(sizes.hasOwnProperty(name))
12791    this.adjustedSizes[name] = sizes[name];
12792 },
12793 AdjustControlCore: function() {
12794 },
12795 AdjustAutoHeight: function() {
12796 },
12797 IsControlCollapsed: function() {
12798  return this.isControlCollapsed;
12799 },
12800 NeedCollapseControl: function() {
12801  return this.NeedCollapseControlCore() && this.IsAdjustmentRequired() && this.IsAdjustmentAllowed();
12802 },
12803 NeedCollapseControlCore: function() {
12804  return false;
12805 },
12806 CollapseEditor: function() {
12807 },
12808 CollapseControl: function() {
12809  this.SaveScrollPositions();
12810  var mainElement = this.GetMainElement(),
12811   marker = this.GetControlPercentSizeMarker();
12812  marker.style.height = this.heightValueSetInPercentage && this.sizingConfig.supp

12812ortPercentHeight
12813   ? this.percentSizeConfig.height 
12814   : (mainElement.offsetHeight + "px");
12815  mainElement.style.display = "none";
12816  this.isControlCollapsed = true;
12817 },
12818 ExpandControl: function() {
12819  var mainElement = this.GetMainElement();
12820  mainElement.style.display = "";
12821  this.GetControlPercentSizeMarker().style.height = "0px";
12822  this.isControlCollapsed = false;
12823  this.RestoreScrollPositions();
12824 },
12825 CanCauseReadjustment: function() {
12826  return this.NeedCollapseControlCore();
12827 },
12828 IsExpandableByAdjustment: function() {
12829  return false;
12830 },
12831 HasFixedPosition: function() {
12832  return false;
12833 },
12834 SaveScrollPositions: function() {
12835  var mainElement = this.GetMainElement();
12836  this.scrollPositionState.outer = ASPx.GetOuterScrollPosition(mainElement.parentNode);
12837  this.scrollPositionState.inner = ASPx.GetInnerScrollPositions(mainElement);
12838 },
12839 RestoreScrollPositions: function() {
12840  ASPx.RestoreOuterScrollPosition(this.scrollPositionState.outer);
12841  ASPx.RestoreInnerScrollPositions(this.scrollPositionState.inner);
12842 },
12843 GetControlPercentSizeMarker: function() {
12844  if(this.percentSizeMarker === undefined) {
12845   this.percentSizeMarker = ASPx.CreateHtmlElementFromString("<div style='height:0px;font-size:0px;line-height:0;width:100%;'></div>");
12846   ASPx.InsertElementAfter(this.percentSizeMarker, this.GetMainElement());
12847  }
12848  return this.percentSizeMarker;
12849 },
12850 KeepControlPercentSizeMarker: function(needCollapse, needCalculateHeight) {
12851  var marker = this.GetControlPercentSizeMarker(),
12852   markerHeight;
12853  if(needCollapse)
12854   this.CollapseControl();
12855  if(this.widthValueSetInPercentage && marker.style.width !== this.percentSizeConfig.width)
12856   marker.style.width = this.percentSizeConfig.width;
12857  if(needCalculateHeight) {
12858   if(this.IsControlCollapsed())
12859    markerHeight = marker.style.height;
12860   marker.style.height = this.percentSizeConfig.height;
12861  }
12862  this.percentSizeConfig.markerWidth = marker.offsetWidth;
12863  if(needCalculateHeight) {
12864   this.percentSizeConfig.markerHeight = marker.offsetHeight;
12865   if(this.IsControlCollapsed())
12866    marker.style.height = markerHeight;
12867   else
12868    marker.style.height = "0px";
12869  }
12870  if(needCollapse)
12871   this.ExpandControl();
12872 },
12873 ResetControlPercentMarkerSize: function() {
12874  this.percentSizeConfig.markerWidth = -1;
12875  this.percentSizeConfig.markerHeight = -1;
12876 },
12877 GetControlPercentMarkerSize: function(hideControl, force) {
12878  var needCalculateHeight = this.heightValueSetInPercentage && this.sizingConfig.supportPercentHeight;
12879  if(force || this.percentSizeConfig.markerWidth < 1 || (needCalculateHeight && this.percentSizeConfig.markerHeight < 1))
12880   this.KeepControlPercentSizeMarker(hideControl && !this.IsControlCollapsed(), needCalculateHeight);
12881  return {
12882   width: this.percentSizeConfig.markerWidth,
12883   height: this.percentSizeConfig.markerHeight
12884  };
12885 },
12886 AssignEllipsisTooltips: function() {
12887  if(this.RequireAssignTooltips())
12888   this.AssignEllipsisTooltipsCore();
12889 },
12890 AssignEllipsisTooltipsCore: function(rootElement, reassingExistingTooltips) {
12891  var requirePaddingManipulation = ASPx.Browser.Edge || ASPx.Browser.Firefox;
12892  rootElement = rootElement || this.GetMainElement();
12893  var nodes = this.GetEllipsisNodes(rootElement);
12894  var nodeInfos = [];
12895  var nodesCount = nodes.length;
12896  for(var i = 0; i < nodesCount; i++) {
12897   var node = nodes[i];
12898   var info = { node: node };
12899   if(requirePaddingManipulation) {
12900    var style = ASPx.GetCurrentStyle(node);
12901    info.paddingLeft = node.style.paddingLeft;
12902    info.totalPadding = ASPx.GetLeftRightPaddings(node, style);
12903   }
12904   nodeInfos.push(info);
12905  }
12906  if(requirePaddingManipulation) {
12907   for(var i = 0; i < nodesCount; i++) {
12908    var info = nodeInfos[i];
12909    ASPx.SetStyles(info.node, { paddingLeft: info.totalPadding }, true);
12910   }
12911  }
12912  for(var i = 0; i < nodesCount; i++) {
12913   var info = nodeInfos[i];
12914   var node = info.node;
12915   info.isTextShortened = node.scrollWidth > node.clientWidth;
12916   info.hasTitle = ASPx.Attr.GetAttribute(node, "title") !== null;
12917   if(!info.hasTitle || reassingExistingTooltips)
12918    info.title = ASPx.GetEllipsisTooltipText(node);
12919  }
12920  for(var i = 0; i < nodesCount; i++) {
12921   var info = nodeInfos[i];
12922   var node = info.node;
12923   if(info.isTextShortened && info.title) {
12924    ASPx.Attr.SetAttribute(node, "title", info.title);
12925    ASPx.Attr.SetAttribute(node, ELLIPSIS_TOOLTIP_MARKER_ATTR, true);
12926   }
12927   if(!info.isTextShortened && info.hasTitle)
12928    ASPx.Attr.RemoveAttribute(node, "title");
12929  }
12930  if(requirePaddingManipulation) {
12931   for(var i = 0; i < nodesCount; i++) {
12932    var info = nodeInfos[i];
12933    var node = info.node;
12934    node.style.paddingLeft = info.paddingLeft;
12935   }
12936  }
12937 },
12938 GetEllipsisNodes: function(element) {
12939  var ellipsibleNodes = ASPx.Data.CollectionToArray(ASPx.GetNodesByClassName(element, ELLIPSIS_MARKER_CLASS));
12940  if(ASPx.ElementHasCssClass(element, ELLIPSIS_MARKER_CLASS))
12941   ellipsibleNodes.push(element);
12942  return ellipsibleNodes.filter(function(node) {
12943   return !ASPx.Attr.IsExistsAttribute(node, "title") || ASPx.Attr.IsExistsAttribute(node, ELLIPSIS_TOOLTIP_MARKER_ATTR);
12944  });
12945 },
12946 RequireAssignTooltips: function() {
12947  return this.enableEllipsis && !ASPx.Browser.MobileUI;
12948 },
12949 RemoveEllipsisFromNode: function(node) {
12950  ASPx.RemoveClassNameFromElement(node, ELLIPSIS_MARKER_CLASS);
12951  this.RemoveEllipsisTooltip(node);
12952 },
12953 RemoveEllipsisTooltip: function(node) {
12954  if(ASPx.Attr.IsExistsAttribute(node, ELLIPSIS_TOOLTIP_MARKER_ATTR)) {
12955   ASPx.Attr.RemoveAttribute(node, "title");
12956   ASPx.Attr.RemoveAttribute(node, ELLIPSIS_TOOLTIP_MARKER_ATTR);
12957  }
12958 },
12959 OnBrowserWindowResize: function(e) {
12960 },
12961 OnBrowserWindowResizeInternal: function(e){

12962  if(this.BrowserWindowResizeSubscriber()) 
12963   this.OnBrowserWindowResize(e);
12964 },
12965 BrowserWindowResizeSubscriber: function() {
12966  return this.widthValueSetInPercentage || !this.IsAdjusted();
12967 },
12968 ShrinkWrappedText: function(getElements, key, reCorrect) {
12969  if(!ASPx.Browser.Safari) return;
12970  var elements = ASPx.CacheHelper.GetCachedElements(this, key, getElements, this.wrappedTextContainers);
12971  for(var i = 0; i < elements.length; i++)
12972   this.ShrinkWrappedTextInContainer(elements[i], reCorrect);
12973 },
12974 ShrinkWrappedTextInContainer: function(container, reCorrect) {
12975  if(!ASPx.Browser.Safari || !container || (container.dxWrappedTextShrinked && !reCorrect) || container.offsetWidth === 0) return;
12976  ASPx.ShrinkWrappedTextInContainer(container);
12977  container.dxWrappedTextShrinked = true;
12978 },
12979 CorrectWrappedText: function(getElements, key, reCorrect) {
12980  var elements = ASPx.CacheHelper.GetCachedElements(this, key, getElements, this.wrappedTextContainers);
12981  for(var i = 0; i < elements.length; i++)
12982   this.CorrectWrappedTextInContainer(elements[i], reCorrect);
12983 },
12984 CorrectWrappedTextInContainer: function(container, reCorrect) {
12985  if(!container || (container.dxWrappedTextCorrected && !reCorrect) || container.offsetWidth === 0) return;
12986  ASPx.AdjustWrappedTextInContainer(container);
12987  container.dxWrappedTextCorrected = true;
12988 },
12989 CorrectVerticalAlignment: function(alignMethod, getElements, key, reAlign) {
12990  var elements = ASPx.CacheHelper.GetCachedElements(this, key, getElements, this.verticalAlignedElements);
12991  for(var i = 0; i < elements.length; i++)
12992   this.CorrectElementVerticalAlignment(alignMethod, elements[i], reAlign);
12993 },
12994 CorrectElementVerticalAlignment: function(alignMethod, element, reAlign) {
12995  if(!element || (element.dxVerticalAligned && !reAlign) || element.offsetHeight === 0) return;
12996  alignMethod(element);
12997  element.dxVerticalAligned = true;
12998 },
12999 ClearVerticalAlignedElementsCache: function() {
13000  ASPx.CacheHelper.DropCache(this.verticalAlignedElements);
13001 },
13002 ClearWrappedTextContainersCache: function() {
13003  ASPx.CacheHelper.DropCache(this.wrappedTextContainers);
13004 },
13005 AdjustPagerControls: function() {
13006  if(typeof(ASPx.GetPagersCollection) != "undefined")
13007   ASPx.GetPagersCollection().AdjustControls(this.GetMainElement());
13008 },
13009 RegisterInControlTree: function(tree) {
13010  var mainElement = this.GetMainElement();
13011  if(mainElement && mainElement.id)
13012   tree.createNode(mainElement.id, this);
13013 },
13014 GetItemElementName: function(element) {
13015  var name = "";
13016  if(element.id)
13017   name = element.id.substring(this.name.length + 1);
13018  return name;
13019 },
13020 GetLinkElement: function(element) {
13021  if(element == null) return null;
13022  return (element.tagName == "A") ? element : ASPx.GetNodeByTagName(element, "A", 0);
13023 },
13024 GetInternalHyperlinkElement: function(parentElement, index) {
13025  var element = ASPx.GetNodeByTagName(parentElement, "A", index);
13026  if(element == null) 
13027   element = ASPx.GetNodeByTagName(parentElement, "SPAN", index);
13028  return element;
13029 },
13030 OnControlClick: function(clickedElement, htmlEvent) {
13031 }
13032});
13033ASPxClientControl.Cast = function(obj) {
13034 if(typeof obj == "string")
13035  return window[obj];
13036 return obj;
13037};
13038ASPxClientControl.AdjustControls = function(container, collapseControls){
13039 aspxGetControlCollection().AdjustControls(container, collapseControls);
13040};
13041ASPxClientControl.GetControlCollection = function(){
13042 return aspxGetControlCollection();
13043};
13044ASPxClientControl.LeadingAfterInitCallConsts = {
13045 None: 0,
13046 Direct: 1,
13047 Reverse: 2
13048};
13049var ASPxClientComponent = ASPx.CreateClass(ASPxClientControl, {
13050 constructor: function (name) {
13051  this.constructor.prototype.constructor.call(this, name);
13052 },
13053 IsDOMDisposed: function() { 
13054  return false;
13055 }
13056});
13057var ASPxClientControlCollection = ASPx.CreateClass(ASPx.CollectionBase, {
13058 constructor: function(){
13059  this.constructor.prototype.constructor.call(this);
13060  this.prevWndWidth = "";
13061  this.prevWndHeight = "";
13062  this.requestCountInternal = 0; 
13063  this.BeforeInitCallback = new ASPxClientEvent();
13064  this.ControlsInitialized = new ASPxClientEvent();
13065  this.BrowserWindowResized = new ASPxClientEvent();
13066  this.BrowserWindowResizedInternal = new ASPxClientEvent();
13067  this.BeginCallback = new ASPxClientEvent();
13068  this.EndCallback = new ASPxClientEvent();
13069  this.CallbackError = new ASPxClientEvent();
13070  this.ValidationCompleted = new ASPxClientEvent();
13071  aspxGetControlCollectionCollection().Add(this);
13072 },
13073 Add: function(element) {
13074  var existsElement = this.Get(element.name);
13075  if(existsElement && existsElement !== element) 
13076   this.Remove(existsElement);

13077  ASPx.CollectionBase.prototype.Add.call(this, element.name, element);
13078 },
13079 Remove: function(element) {
13080  if(element && element instanceof ASPxClientControl && !element.IsDisposed())
13081   element.OnDispose();
13082  ASPx.CollectionBase.prototype.Remove.call(this, element.name);
13083 },
13084 GetGlobal: function(name) {
13085  var result = window[name];
13086  return result && Ident.IsASPxClientControl(result)
13087   ? result
13088   : null;
13089 },
13090 GetByName: function(name){
13091  return this.Get(name) || this.GetGlobal(name);
13092 },
13093 GetCollectionType: function(){
13094  return ASPxClientControlCollection.BaseCollectionType;
13095 },
13096 GetControlsByPredicate: function(predicate) {
13097  var result = [];
13098  this.ForEachControl(function(control) {
13099   if(!predicate || predicate(control))
13100    result.push(control);
13101  });
13102  return result;
13103 },
13104 GetControlsByType: function(type) {
13105  return this.GetControlsByPredicate(function(control) { 
13106   return type && (control instanceof type);
13107  });
13108 },
13109 ForEachControl: function(action, context) {
13110  context = context || this;
13111  this.elementsMap.forEachEntry(function(name, control) {
13112   if(Ident.IsASPxClientControl(control) && (!this.filterPredicate || this.filterPredicate(control)))
13113    return action.call(context, control);
13114  }, context);
13115 },
13116 ProcessActionByPredicate: function(action, predicate) {
13117  try {
13118   this.filterPredicate = predicate;
13119   action(this);
13120  }
13121  finally {
13122   this.filterPredicate = null;
13123  }
13124 },
13125 adjustControlsInternal: function(container, context, collapseControls, adjustFunc) {
13126  context = context || this;
13127  var func = function(control) {
13128   adjustFunc.call(context, control);
13129  };
13130  ASPx.GetControlAdjuster().adjustControlsInHierarchy(this, func, container, collapseControls);
13131 },
13132 AdjustControls: function(container, collapseControls) {
13133  container = container || null;
13134  window.setTimeout(function() {
13135   this.AdjustControlsCore(container, collapseControls);
13136  }.aspxBind(this), 0);
13137 },
13138 AdjustControlsCore: function(container, collapseControls) {
13139  var adjustFunction = function(control) { control.AdjustControl(); };
13140  this.adjustControlsInternal(container, this, collapseControls, adjustFunction);
13141 },
13142 CollapseControls: function(container) {
13143  this.ProcessControlsInContainer(container, function(control) {
13144   if(control.isASPxClientEdit)
13145    control.CollapseEditor();
13146   else if(!!window.ASPxClientRibbon && control instanceof ASPxClientRibbon)
13147    control.CollapseControl();
13148  });
13149 },
13150 AtlasInitialize: function(isCallback) {
13151  this.ForEachControl(function(control) {
13152   control.AtlasPreInitialize();
13153  });
13154  ASPx.ProcessScriptsAndLinks("", isCallback);
13155  this.ForEachControl(function(control) {
13156   control.AtlasInitialize();
13157  });
13158 },
13159 DOMContentLoaded: function() {
13160  this.ForEachControl(function(control){
13161    control.DOMContentLoaded();
13162  });
13163 },
13164 OnDocumentUnload: function() {
13165  this.ForEachControl(function(control) {
13166   control.RaiseUnload();
13167  });
13168 },
13169 Initialize: function() {
13170  ASPx.GetPostHandler().Post.AddHandler(
13171   function(s, e) { this.OnPost(e); }.aspxBind(this)
13172  );
13173  ASPx.GetPostHandler().PostFinalization.AddHandler(
13174   function(s, e) { this.OnPostFinalization(e); }.aspxBind(this)
13175  );
13176  this.InitializeElements(false );
13177  if(typeof(Sys) != "undefined" && typeof(Sys.Application) != "undefined") {
13178   var checkIsInitialized = function() {
13179    if(Sys.Application.get_isInitialized())
13180     Sys.Application.add_load(aspxCAInit);
13181    else
13182     setTimeout(checkIsInitialized, 0);
13183   };
13184   checkIsInitialized();
13185  }
13186  this.InitWindowSizeCache();
13187 },
13188 FinalizeInitialization: function() {
13189  this.ForEachControl(function(control) {
13190   control.FinalizeInitialization();
13191  });
13192 },
13193 InitializeElements: function(isCallback) {
13194  this.ForEachControl(function(control){
13195   if(!control.isInitialized)
13196    control.Initialize();
13197  });
13198  this.AfterInitializeElementsLeadingCall();
13199  this.AfterInitializeElements();
13200  this.RaiseControlsInitialized(isCallback);
13201 },
13202 AfterInitializeElementsLeadingCall: function() {
13203  var controls = {};
13204  controls[ASPxClientControl.LeadingAfterInitCallConsts.Direct] = [];

13205  controls[ASPxClientControl.LeadingAfterInitCallConsts.Reverse] = [];
13206  this.ForEachControl(function(control) {
13207   if(control.leadingAfterInitCall != ASPxClientControl.LeadingAfterInitCallConsts.None && !control.isInitialized)
13208    controls[control.leadingAfterInitCall].push(control);
13209  });
13210  var directInitControls = controls[ASPxClientControl.LeadingAfterInitCallConsts.Direct],
13211   reverseInitControls = controls[ASPxClientControl.LeadingAfterInitCallConsts.Reverse];
13212  for(var i = 0, control; control = directInitControls[i]; i++)
13213   control.AfterInitialize();
13214  for(var i = reverseInitControls.length - 1, control; control = reverseInitControls[i]; i--)
13215   control.AfterInitialize();
13216 },
13217 AfterInitializeElements: function() {
13218  this.ForEachControl(function(control) {
13219   if(control.leadingAfterInitCall == ASPxClientControl.LeadingAfterInitCallConsts.None && !control.isInitialized)
13220    control.AfterInitialize();
13221  });
13222  ASPx.RippleHelper.Init();
13223 },
13224 DoFinalizeCallback: function() {
13225  this.ForEachControl(function(control){
13226   control.DoFinalizeCallback();
13227  });
13228 },
13229 ProcessControlsInContainer: function(container, processFunc, filterFunc) {
13230  this.ForEachControl(function(control){
13231   if((!filterFunc || filterFunc(control)) && (!container || this.IsControlInContainer(container, control)))
13232    processFunc(control);
13233  });
13234 },
13235 IsControlInContainer: function(container, control) {
13236  if(control.GetMainElement) {
13237   var mainElement = control.GetMainElement();
13238   if(mainElement && (mainElement != container)) {
13239    if(ASPx.GetIsParent(container, mainElement))
13240     return true;
13241   }
13242  }
13243  return false;
13244 },
13245 RaiseControlsInitialized: function(isCallback) {
13246  if(typeof(isCallback) == "undefined")
13247   isCallback = true;
13248  var args = new ASPxClientControlsInitializedEventArgs(isCallback);
13249  if(!this.ControlsInitialized.IsEmpty())  
13250   this.ControlsInitialized.FireEvent(this, args);
13251  this.ForEachControl(function(control){
13252   control.OnGlobalControlsInitialized(args);
13253  });
13254 },
13255 RaiseBrowserWindowResized: function() {
13256  var args = new ASPxClientEventArgs();
13257  if(!this.BrowserWindowResized.IsEmpty())
13258   this.BrowserWindowResized.FireEvent(this, args);
13259  this.ForEachControl(function(control){
13260   control.OnGlobalBrowserWindowResized(args);
13261  });
13262 },
13263 RaiseBrowserWindowResizedInternal: function(eventInfo) {
13264  var args = new ASPxClientBrowserWindowResizedInternalEventArgs(eventInfo);
13265  if(!this.BrowserWindowResizedInternal.IsEmpty())
13266   this.BrowserWindowResizedInternal.FireEvent(this, args);
13267 },
13268 RaiseBeginCallback: function (control, command) {
13269  var args = new ASPxClientGlobalBeginCallbackEventArgs(control, command);
13270  if(!this.BeginCallback.IsEmpty())
13271   this.BeginCallback.FireEvent(this, args);
13272  this.ForEachControl(function(control){
13273   control.OnGlobalBeginCallback(args);
13274  });
13275  this.IncrementRequestCount();
13276 },
13277 RaiseEndCallback: function (control) {
13278  var args = new ASPxClientGlobalEndCallbackEventArgs(control);
13279  if (!this.EndCallback.IsEmpty()) 
13280   this.EndCallback.FireEvent(this, args);
13281  this.ForEachControl(function(control){
13282   control.OnGlobalEndCallback(args);
13283  });
13284  this.DecrementRequestCount();
13285 },
13286 InCallback: function() {
13287  return this.requestCountInternal > 0;
13288 },
13289 RaiseCallbackError: function (control, message, callbackId) {
13290  var args = new ASPxClientGlobalCallbackErrorEventArgs(control, message, callbackId);
13291  if (!this.CallbackError.IsEmpty()) 
13292   this.CallbackError.FireEvent(this, args);
13293  this.ForEachControl(function(control){
13294   control.OnGlobalCallbackError(args);
13295  });
13296  if(args.handled)
13297   return { isHandled: true, errorMessage: args.message };  
13298  return { isHandled: false, errorMessage: message };
13299 },
13300 RaiseValidationCompleted: function (container, validationGroup, invisibleControlsValidated, isValid, firstInvalidControl, firstVisibleInvalidControl) {
13301  var args = new ASPxClientValidationCompletedEventArgs(container, validationGroup, invisibleControlsValidated, isValid, firstInvalidControl, firstVisibleInvalidControl);
13302  if (!this.ValidationCompleted.IsEmpty()) 
13303   this.ValidationCompleted.FireEvent(this, args);
13304  this.ForEachControl(function(control){
13305   control.OnGlobalValidationCompleted(args);
13306  });
13307  return args.isValid;
13308 },
13309 Before_WebForm_InitCallback: function(callbackOwnerID){
13310  var args = new BeforeInitCallbackEventArgs(callbackOwnerID);
13311  this.BeforeInitCallback.FireEvent(this, args);
13312 },
13313 InitWindowSizeCache: function(){
13314  this.prevWndWidth = ASPx.GetDocumentClientWidth();
13315  this.prevWndHeight = ASPx.GetDocumentClientHeight();
13316 },
13317 OnBrowserWindowResize: function(evt){
13318  this.OnBrowserWindowResizeCore(evt);
13319 },
13320 OnBrowserWindowResizeCore: function(htmlEvent){
13321  var args = this.CreateOnBrowserWindowResizeEventArgs(htmlEvent);
13322  if(this.CalculateIsBrowserWindowSizeChanged()) {
13323   this.RaiseBrowserWindowResizedInternal(args);
13324   this.adjustControlsInternal(null, this, true, function(control) {
13325    if(control.IsDOMInitialized())
13326     control.OnBrowserWindowResizeInternal(args);
13327   });
13328   this.RaiseBrowserWindowResized();
13329  }
13330 },
13331 CreateOnBrowserWindowResizeEventArgs: function(htmlEvent) {
13332  return {
13333   htmlEvent: htmlEvent,
13334   wndWidth: ASPx.GetDocumentClientWidth(),
13335   wndHeight: ASPx.GetDocumentClientHeight(),
13336   prevWndWidth: this.prevWndWidth,
13337   prevWndHeight: this.prevWndHeight,
13338   virtualKeyboardShownOnAndroid: this.IsVirtualKeyboardShownOnAndroid()
13339  };
13340 },
13341 IsVirtualKeyboardShownOnAndroid: function() {
13342  if(!ASPx.Browser.AndroidMobilePlatform)
13343   return false;
13344  var documentClientWidth = ASPx.GetDocumentClientWidth();
13345  var documentClientHeight = ASPx.GetDocumentClientHeight();
13346  var isDocumentClientHeightChangedOnly = documentClientWidth === this.prevWndWidth && documentClientHeight !== this.prevWndHeight;
13347  return isDocumentClientHeightChangedOnly && this.IsElementSupportKeyboardInput(document.activeElement);
13348 },

13349 IsElementSupportKeyboardInput: function(element) {
13350  if(!element || !element.tagName)
13351   return false;
13352  var supportedKeyboardInputTagNames = ["INPUT", "TEXTAREA"];
13353  return supportedKeyboardInputTagNames.indexOf(element.tagName) !== -1;
13354 },
13355 CalculateIsBrowserWindowSizeChanged: function(){
13356  var wndWidth = ASPx.GetDocumentClientWidth();
13357  var wndHeight = ASPx.GetDocumentClientHeight();
13358  var isBrowserWindowSizeChanged = (this.prevWndWidth != wndWidth) || (this.prevWndHeight != wndHeight);
13359  if(isBrowserWindowSizeChanged){
13360   this.prevWndWidth = wndWidth;
13361   this.prevWndHeight = wndHeight;
13362   return true;
13363  }
13364  return false;
13365 },
13366 OnPost: function(args){
13367  this.ForEachControl(function(control) {
13368   control.OnPost(args);
13369  }, null);
13370 },
13371 OnPostFinalization: function(args){
13372  this.ForEachControl(function(control) {
13373   control.OnPostFinalization(args);
13374  }, null);
13375 },
13376 IncrementRequestCount: function() {
13377  this.requestCountInternal++;
13378 },
13379 DecrementRequestCount: function() {
13380  this.requestCountInternal--;
13381 },
13382 ResetRequestCount: function() {
13383  this.requestCountInternal = 0;
13384 }
13385});
13386ASPxClientControlCollection.BaseCollectionType = "Control";
13387var controlCollection = null;
13388function aspxGetControlCollection(){
13389 if(controlCollection == null) {
13390  controlCollection = new ASPxClientControlCollection();
13391  if(ASPx.loadControlCollectionPreloadHandlers)
13392   ASPx.loadControlCollectionPreloadHandlers(controlCollection);
13393 }
13394 return controlCollection;
13395}
13396var ControlCollectionCollection = ASPx.CreateClass(ASPx.CollectionBase, {
13397 constructor: function(){
13398  this.constructor.prototype.constructor.call(this);
13399 },
13400 Add: function(element) {
13401  var key = element.GetCollectionType();
13402  if(!key) throw "The collection type isn't specified.";
13403  if(this.Get(key)) throw "The collection with type='" + key + "' already exists.";
13404  ASPx.CollectionBase.prototype.Add.call(this, key, element);
13405 },
13406 RemoveDisposedControls: function(){
13407  var baseCollection = this.Get(ASPxClientControlCollection.BaseCollectionType);
13408  var disposedControls = [];
13409  baseCollection.elementsMap.forEachEntry(function(name, control) {
13410   if(!ASPx.Ident.IsASPxClientControl(control)) return;
13411   if(control.IsDOMDisposed())
13412    disposedControls.push(control);
13413  });
13414  this.RemoveControls(disposedControls);
13415 },
13416 RemoveControls: function(controls){
13417  for(var i = 0; i < controls.length; i++) {
13418   this.elementsMap.forEachEntry(function(key, collection) {
13419    if(ASPx.Ident.IsASPxClientCollection(collection))
13420     collection.Remove(controls[i]);
13421   });
13422  }
13423 }
13424});
13425var controlCollectionCollection = null;
13426function aspxGetControlCollectionCollection(){
13427 if(controlCollectionCollection == null)
13428  controlCollectionCollection = new ControlCollectionCollection();
13429 return controlCollectionCollection;
13430}
13431var AriaDescriptionAttributes = {
13432 Role: "0",
13433 AriaLabel: "1",
13434 TabIndex: "2",
13435 AriaOwns: "3",
13436 AriaDescribedBy: "4",
13437 AriaDisabled: "5",
13438 AriaHasPopup: "6",
13439 AriaLevel: "7"
13440};
13441var AriaDescriptor = ASPx.CreateClass(null, {
13442 constructor: function(ownerControl, description) {
13443  this.ownerControl = ownerControl;
13444  this.rootElement = ownerControl.GetMainElement();
13445  this.description = description;
13446 },
13447 setDescription: function(name, argList) {
13448  var description = this.findChildDescription(name);
13449  if(description) {
13450   var elements = name ? this.rootElement.querySelectorAll(this.getDescriptionSelector(description)) : [this.rootElement];
13451   for(var i = 0; i < elements.length; i++)
13452    this.applyDescriptionToElement(elements[i], description, argList[i] || argList[0]);
13453  }
13454 },
13455 getDescriptionName: function(description) {
13456  return description.n;
13457 },
13458 getDescriptionSelector: function(description) {
13459  return description.s;
13460 },
13461 findChildDescription: function(name) {
13462  if(name === this.getDescriptionName(this.description))
13463   return this.description;
13464  var childCollection = this.description.c || [];
13465  for(var i = 0; i < childCollection.length; i++) {
13466   var childDescription = childCollection[i];
13467   if(this.getDescriptionName(childDescription) === name)
13468    return childDescription;
13469  }
13470  return null;
13471 },
13472 applyDescriptionToElement: function(element, description, args) {
13473  if(!description || !element)
13474   return;
13475  this.trySetAriaOwnsAttribute(element, description);
13476  this.trySetAriaDescribedByAttribute(element, description);
13477  this.trySetAttribute(element, description, AriaDescriptionAttributes.Role, "role");
13478  this.trySetAttribute(element, description, AriaDescriptionAttributes.TabIndex, "tabindex");
13479  this.trySetAttribute(element, description, AriaDescriptionAttributes.AriaLevel, "aria-level");
13480  this.executeOnDescription(description, AriaDescriptionAttributes.AriaLabel, function(value) {
13481   ASPx.Attr.SetAttribute(element, "aria-label", ASPx.Str.ApplyReplacement(value, args

13481));
13482  });
13483  this.executeOnDescription(description, AriaDescriptionAttributes.AriaDisabled, function(value) {
13484   ASPx.Attr.SetAttribute(element, "aria-disabled", !!value); 
13485  });
13486  this.executeOnDescription(description, AriaDescriptionAttributes.AriaHasPopup, function(value) {
13487   ASPx.Attr.SetAttribute(element, "aria-haspopup", !!value);
13488  });
13489 },
13490 trySetAriaDescribedByAttribute: function(element, description) {
13491  this.executeOnDescription(description, AriaDescriptionAttributes.AriaDescribedBy, function(selectorInfo) {
13492   var descriptor = this.getNodesBySelector(element, selectorInfo.descriptorSelector)[0];
13493   var target = this.getNodesBySelector(element, selectorInfo.targetSelector)[0];
13494   if(!target || !descriptor)
13495    return;
13496   ASPx.Attr.SetAttribute(target, "aria-describedby", this.getNodeId(descriptor));
13497  });
13498 },
13499 trySetAriaOwnsAttribute: function(element, description) {
13500  this.executeOnDescription(description, AriaDescriptionAttributes.AriaOwns, function(selector) {
13501   var ownedNodes = this.getNodesBySelector(element, selector);
13502   var ariaOwnsAttributeValue = "";
13503   for(var i = 0; i < ownedNodes.length; i++)
13504    ariaOwnsAttributeValue += (this.getNodeId(ownedNodes[i]) + (i != ownedNodes.length - 1 ? " " : ""));
13505   ASPx.Attr.SetAttribute(element, "aria-owns", ariaOwnsAttributeValue);
13506  });
13507 },
13508 trySetAttribute: function(element, description, ariaAttribute, attributeName) {
13509  this.executeOnDescription(description, ariaAttribute, function(value) { 
13510   ASPx.Attr.SetAttribute(element, attributeName, description[ariaAttribute]); 
13511  });
13512 },
13513 executeOnDescription: function(description, ariaDescAttr, callback) {
13514  var descInfo = description[ariaDescAttr];
13515  if(ASPx.IsExists(descInfo))
13516   callback.aspxBind(this)(descInfo);
13517 },
13518 getNodesBySelector: function(element, selector) {
13519  var id = element.id || "";
13520  var childNodes = element.querySelectorAll("#" + this.getNodeId(element) + " > " + selector);
13521  ASPx.Attr.SetOrRemoveAttribute(element, "id", id);
13522  return childNodes;
13523 },
13524 getNodeId: function(node) {
13525  if(!node.id)
13526   node.id = this.createRandomId();
13527  return node.id; 
13528 },
13529 createRandomId: function() {
13530  return "r" + ASPx.CreateGuid();
13531 }
13532});
13533PagerCommands = {
13534 Next : "PBN",
13535 Prev : "PBP",
13536 Last : "PBL",
13537 First : "PBF",
13538 PageNumber : "PN",
13539 PageSize : "PSP"
13540};
13541ASPx.callbackProcessed = false;
13542ASPx.Callback = function(result, context){ 
13543 var collection = aspxGetControlCollection();
13544 collection.DoFinalizeCallback();
13545 var control = collection.Get(context);
13546 if(control != null)
13547  control.DoCallback(result);
13548 ASPx.RippleHelper.ReInit();
13549 ASPx.callbackProcessed = true;
13550};
13551ASPx.CallbackError = function(result, context){
13552 var control = aspxGetControlCollection().Get(context);
13553 if(control != null)
13554  control.DoCallbackError(result, false);
13555 ASPx.callbackProcessed = true;
13556};
13557ASPx.CClick = function(name, evt) {
13558 var control = aspxGetControlCollection().Get(name);
13559 if(control != null) control.DoControlClick(evt);
13560};
13561function aspxCAInit() {
13562 var isAppInit = typeof(Sys$_Application$initialize) != "undefined" &&
13563  ASPx.FunctionIsInCallstack(arguments.callee, Sys$_Application$initialize, 10 );
13564 aspxGetControlCollection().AtlasInitialize(!isAppInit);
13565}
13566ASPx.Evt.AttachEventToElement(window, "resize", aspxGlobalWindowResize);
13567function aspxGlobalWindowResize(evt){
13568 aspxGetControlCollection().OnBrowserWindowResize(evt); 
13569}
13570ASPx.Evt.AttachEventToElement(window, "unload", aspxClassesUnload);
13571function aspxClassesUnload(evt) {
13572 aspxGetControlCollection().OnDocumentUnload();
13573}
13574ASPx.attachToLoad(aspxClassesDOMContentLoaded);
13575function aspxClassesDOMContentLoaded(evt){
13576 aspxGetControlCollection().DOMContentLoaded();
13577}
13578ASPx.GetControlCollection = aspxGetControlCollection;
13579ASPx.GetControlCollectionCollection = aspxGetControlCollectionCollection;
13580ASPx.GetPersistentControlPropertiesStorage = _aspxGetPersistentControlPropertiesStorage;
13581ASPx.PagerCommands = PagerCommands;
13582ASPx.ELLIPSIS_MARKER_CLASS = ELLIPSIS_MARKER_CLASS;
13583window.ASPxClientBeginCallbackEventArgs = ASPxClientBeginCallbackEventArgs;
13584window.ASPxClientGlobalBeginCallbackEventArgs = ASPxClientGlobalBeginCallbackEventArgs;
13585window.ASPxClientEndCallbackEventArgs = ASPxClientEndCallbackEventArgs;
13586window.ASPxClientGlobalEndCallbackEventArgs = ASPxClientGlobalEndCallbackEventArgs;
13587window.ASPxClientCallbackErrorEventArgs = ASPxClientCallbackErrorEventArgs;
13588window.ASPxClientGlobalCallbackErrorEventArgs = ASPxClientGlobalCallbackErrorEventArgs;
13589window.ASPxClientCustomDataCallbackEventArgs = ASPxClientCustomDataCallbackEventArgs;
13590window.ASPxClientValidationCompletedEventArgs = ASPxClientValidationCompletedEventArgs;
13591window.ASPxClientControlsInitializedEventArgs = ASPxClientControlsInitializedEventArgs;
13592window.ASPxClientControlBeforePronounceEventArgs = ASPxClientControlBeforePronounceEventArgs;
13593window.ASPxClientControlUnloadEventArgs = ASPxClientControlUnloadEventArgs;
13594window.ASPxClientEndFocusEventArgs = ASPxClientEndFocusEventArgs;
13595window.ASPxClientItemFocusedEventArgs = ASPxClientItemFocusedEventArgs;
13596window.ASPxClientControlCollection = ASPxClientControlCollection;
13597window.ASPxClientControlBase = ASPxClientControlBase;
13598window.ASPxClientControl = ASPxClientControl;
13599window.ASPxClientComponent = ASPxClientComponent;
13600})(ASPx);
13601
13602(function () {
13603 var PositionAnimationTransition = ASPx.CreateClass(ASPx.AnimationTransitionBase, {
13604  constructor: function (element, options) {
13605   this.constructor.prototype.constructor.call(this, element, options);
13606   this.direction = options.direction;
13607   this.animationTransition = this.createAnimationTransition();
13608   AnimationHelper.appendWKAnimationClassNameIfRequired(this.element);
13609  },
13610  Start: function (to) {
13611   var from = this.GetValue();
13612   if(ASPx.AnimationUtils.CanUseCssTransform()) {
13613    from = this.convertPosToCssTransformPos(from);
13614    to = this.convertPosToCssTransformPos(to);
13615   }
13616   this.animationTransition.Start(from, to);
13617  },
13618  SetValue: function (value) {
13619   ASPx.AnimationUtils.SetTransformValue(this.element, value, this.direction == AnimationHelper.SLIDE_VERTICAL_DIRECTION);
13620  },
13621  GetValue: function () {
13622   return ASPx.AnimationUtils.GetTransformValue(this.element, this.direction == AnimationHelper.SLIDE_VERTICAL_DIRECTION);
13623  },
13624  createAnimationTransition: function () {
13625   var transition = ASPx.AnimationUtils.CanUseCssTransform() ? this.createTransformAnimationTransition() : this.createPositionAnimationTransition();
13626   transition.transition = ASPx.AnimationConstants.Transitions.POW_EASE_OUT;
13627   return transition;
13628  },
13629  createTransformAnimationTransition: function () {
13630   return ASPx.AnimationUtils.createCssAnimationTransition(this.element, {
13631    property: ASPx.AnimationUtils.CanUseCssTransform(),
13632    duration: this.duration,
13633    onComplete: this.onComplete
13634   });
13635  },
13636  createPositionAnimationTransition: function () {
13637   return AnimationHelper.createAnimationTransition(this.element, {
13638    property: this.direction == AnimationHelper.SLIDE_VERTICAL_DIRECTION ? "top" : "left",
13639    unit: "px",
13640    duration: this.duration,
13641    onComplete: this.onComplete
13642   });
13643  },
13644  convertPosToCssTransformPos: function (position) {
13645   return ASPx.AnimationUtils.GetTransformCssText(position, this.direction == AnimationHelper.SLIDE_VERTICAL_DIRECTION);
13646  }
13647 });
13648 var AnimationHelper = {
13649  SLIDE_HORIZONTAL_DIRECTION: 0,
13650  SLIDE_VERTICAL_DIRECTION: 1,
13651  SLIDE_TOP_DIRECTION: 0,
13652  SLIDE_RIGHT_DIRECTION: 1,
13653  SLIDE_BOTTOM_DIRECTION: 2,
13654  SLIDE_LEFT_DIRECTION: 3,
13655  SLIDE_CONTAINER_CLASS: "dxAC",
13656  MAXIMUM_DEPTH: 3,
13657  createAnimationTransition: function (element, options) {
13658   if(options.onStep)
13659    options.animationEngineType = AnimationEngineType.JS;
13660   switch(options.animationEngineType) {
13661    case AnimationEngineType.JS:
13662     return ASPx.AnimationUtils.createJsAnimationTransition(element, options);
13663    case AnimationEngineType.CSS:
13664     return ASPx.AnimationUtils.createCssAnimationTransition(element, options);
13665    default:
13666     return ASPx.AnimationUtils.CanUseCssTransition() ? ASPx.AnimationUtils.createCssAnimationTransition(element, options) :
13667      ASPx.AnimationUtils.createJsAnimationTransition(element, options);
13668   }
13669  },
13670  createMultipleAnimationTransition: function (element, options) {
13671   return ASPx.AnimationUtils.createMultipleAnimationTransition(element, options);
13672  },
13673  createSimpleAnimationTransition: function (options) {
13674   return ASPx.AnimationUtils.createSimpleAnimationTransition(options);
13675  },
13676  cancelAnimation: function (element) {
13677   ASPx.AnimationTransitionBase.Cancel(element);
13678  },
13679  fadeIn: function(element, onComplete, duration, animationEngineType) {
13680   AnimationHelper.fadeTo(element, {
13681    from: 0, to: 1,
13682    onComplete: onComplete,
13683    animationEngineType: animationEngineType || AnimationEngineType.DEFAULT,
13684    duration: duration || ASPx.AnimationConstants.Durations.DEFAULT
13685   });
13686  },
13687  fadeOut: function(element, onComplete, duration, animationEngineType) {
13688   AnimationHelper.fadeTo(element, {
13689    from: ASPx.GetElementOpacity(element), to: 0,
13690    onComplete: onComplete,
13691    animationEngineType: animationEngineType || AnimationEngineType.DEFAULT,
13692    duration: duration || ASPx.AnimationConstants.Durations.DEFAULT
13693   });
13694  },
13695  fadeTo: function (element, options) {
13696   options.property = "opacity";
13697   if(!options.duration)
13698    options.duration = ASPx.AnimationConstants.Durations.SHORT;
13699   var transition = AnimationHelper.createAnimationTransition(element, options);
13700   if(!ASPx.IsExists(options.from))
13701    options.from = transition.GetValue();
13702   transition.Start(options.from, options.to);
13703  },
13704  slideIn: function (element, direction, onComplete, animationEngineType, rtl) {
13705   AnimationHelper.setOpacity(element, 1);
13706   var animationContainer = AnimationHelper.getSlideAnimationContainer(element, true, true);
13707   var pos = AnimationHelper.getSlideInStartPos(animationContainer, direction, rtl);
13708   var transition = AnimationHelper.createSlideTransition(animationContainer, direction,
13709    function (el) {
13710     AnimationHelper.resetSlideAnimationContainerSize(animationContainer);
13711     if(onComplete)
13712      onComplete(el);
13713    }, animationEngineType, rtl);
13714   transition.Start(pos, 0);
13715  },
13716  slideOut: function (element, direction, onComplete, animationEngineType, rtl) {
13717   var animationContainer = AnimationHelper.getSlideAnimationContainer(element, true, true);

13718   var pos = AnimationHelper.getSlideOutFinishPos(animationContainer, direction, rtl);
13719   var transition = AnimationHelper.createSlideTransition(animationContainer, direction,
13720    function (el) {
13721     AnimationHelper.setOpacity(el.firstChild, 0);
13722     if(onComplete)
13723      onComplete(el);
13724    }, animationEngineType, rtl);
13725   transition.Start(pos);
13726  },
13727  slideTo: function (element, options) {
13728   if(!ASPx.IsExists(options.direction))
13729    options.direction = AnimationHelper.SLIDE_HORIZONTAL_DIRECTION;
13730   var transition = new PositionAnimationTransition(element, options);
13731   transition.Start(options.to);
13732  },
13733  setOpacity: function (element, value) {
13734   ASPx.AnimationUtils.setOpacity(element, value);
13735  },
13736  appendWKAnimationClassNameIfRequired: function (element) {
13737   if(ASPx.AnimationUtils.CanUseCssTransform() && ASPx.Browser.WebKitFamily && !ASPx.ElementHasCssClass(element, "dx-wbv"))
13738    element.className += " dx-wbv";
13739  },
13740  findSlideAnimationContainer: function (element) {
13741   var container = element;
13742   for(var i = 0; i < AnimationHelper.MAXIMUM_DEPTH; i++) {
13743    if(container.tagName == "BODY")
13744     return null;
13745    if(ASPx.ElementHasCssClass(container, AnimationHelper.SLIDE_CONTAINER_CLASS))
13746     return container;
13747    container = container.parentNode;
13748   }
13749   return null;
13750  },
13751  createSlideAnimationContainer: function (element) {
13752   var rootContainer = document.createElement("DIV");
13753   ASPx.SetStyles(rootContainer, {
13754    className: AnimationHelper.SLIDE_CONTAINER_CLASS,
13755    overflow: "hidden"
13756   });
13757   var elementContainer = document.createElement("DIV");
13758   rootContainer.appendChild(elementContainer);
13759   var parentNode = element.parentNode;
13760   parentNode.insertBefore(rootContainer, element);
13761   elementContainer.appendChild(element);
13762   return rootContainer;
13763  },
13764  getSlideAnimationContainer: function (element, create, fixSize) {
13765   if(!element) return;
13766   var width = element.offsetWidth;
13767   var height = element.offsetHeight;
13768   var container;
13769   if(element.className == AnimationHelper.SLIDE_CONTAINER_CLASS)
13770    container = element;
13771   if(!container)
13772    container = AnimationHelper.findSlideAnimationContainer(element);
13773   if(!container && create)
13774    container = AnimationHelper.createSlideAnimationContainer(element);
13775   if(container && fixSize) {
13776    ASPx.SetStyles(container, {
13777     width: width, height: height
13778    });
13779    ASPx.SetStyles(container.firstChild, {
13780     width: width, height: height
13781    });
13782   }
13783   return container;
13784  },
13785  resetSlideAnimationContainerSize: function (container) {
13786   ASPx.SetStyles(container, {
13787    width: "", height: ""
13788   });
13789   ASPx.SetStyles(container.firstChild, {
13790    width: "", height: ""
13791   });
13792  },
13793  getModifyProperty: function (direction, rtl) {
13794   if(direction == AnimationHelper.SLIDE_TOP_DIRECTION || direction == AnimationHelper.SLIDE_BOTTOM_DIRECTION)
13795    return "marginTop";
13796   return rtl ? "margin-right" : "margin-left";
13797  },
13798  createSlideTransition: function (animationContainer, direction, complete, animationEngineType, rtl) {
13799   if(rtl == undefined)
13800    rtl = false;
13801   return AnimationHelper.createAnimationTransition(animationContainer.firstChild, {
13802    unit: "px",
13803    property: AnimationHelper.getModifyProperty(direction, rtl),
13804    onComplete: complete,
13805    animationEngineType: animationEngineType
13806   });
13807  },
13808  getSlideInStartPos: function (animationContainer, direction, rtl) {
13809   var dir = rtl ? -1 : 1;
13810   switch (direction) {
13811    case AnimationHelper.SLIDE_TOP_DIRECTION:
13812     return animationContainer.offsetHeight;
13813    case AnimationHelper.SLIDE_LEFT_DIRECTION:
13814     return animationContainer.offsetWidth * dir;
13815    case AnimationHelper.SLIDE_RIGHT_DIRECTION:
13816     return -animationContainer.offsetWidth * dir;
13817    case AnimationHelper.SLIDE_BOTTOM_DIRECTION:
13818     return -animationContainer.offsetHeight;
13819   }
13820  },
13821  getSlideOutFinishPos: function (animationContainer, direction, rtl) {
13822   var dir = rtl ? -1 : 1;
13823   switch (direction) {
13824    case AnimationHelper.SLIDE_TOP_DIRECTION:
13825     return -animationContainer.offsetHeight;
13826    case AnimationHelper.SLIDE_LEFT_DIRECTION:
13827     return -animationContainer.offsetWidth * dir;
13828    case AnimationHelper.SLIDE_RIGHT_DIRECTION:
13829     return animationContainer.offsetWidth * dir;
13830    case AnimationHelper.SLIDE_BOTTOM_DIRECTION:
13831     return animationContainer.offsetHeight;
13832   }
13833  }
13834 };
13835 var GestureHandler = ASPx.CreateClass(null, {
13836  constructor: function (getAnimationElement, canHandle, allowStart) {
13837   this.getAnimationElement = getAnimationElement;
13838   this.canHandle = canHandle;
13839   this.allowStart = allowStart;
13840   this.startMousePosX = 0;
13841   this.startMousePosY = 0;
13842   this.startTime = null;
13843   this.isEventsPrevented = false;
13844   this.savedElements = [];
13845  },
13846  OnSelectStart: function(evt) {
13847   ASPx.Evt.PreventEvent(evt); 
13848  },
13849  OnDragStart: function(evt) {
13850   ASPx.Evt.PreventEvent(evt);  
13851  },
13852  OnMouseDown: function (evt) {
13853   this.startMousePosX = ASPx.Evt.GetEventX(evt);
13854   this.startMousePosY = ASPx.Evt.GetEventY(evt);
13855   this.startTime = new Date();
13856  },
13857  OnMouseMove: function(evt) {
13858   if(!ASPx.Browser.MobileUI)
13859    ASPx.Selection.Clear();
13860   if(Math.abs(this.GetCurrentDistanceX(evt)) < GestureHandler.SLIDER_MIN_START_DISTANCE && Math.abs(this.GetCurrentDistanceY(evt)) < GestureHandler.SLIDER_MIN_START_DISTANCE)
13861    GesturesHelper.isExecutedGesture = false;
13862  },
13863  OnMouseUp: function (evt) {
13864  },
13865  CanHandleEvent: function (evt) {
13866   return !this.canHandle || this.canHandle(evt);
13867  },
13868  IsStartAllowed: function(value) {
13869   return !this.allowStart || this.allowStart(value);
13870  },
13871  RollbackGesture: function () {
13872  },
13873  GetRubberPosition: function (position) {
13874   return position / GestureHandler.FACTOR_RUBBER;
13875  },
13876  GetCurrentDistanceX: function (evt) {
13877   return ASPx.Evt.GetEventX(evt) - this.startMousePosX;
13878  },
13879  GetCurrentDistanceY: function (evt) {
13880   return ASPx.Evt.GetEventY(evt) - this.startMousePosY;
13881  },
13882  GetDistanceLimit: function () {
13883   return (new Date() - this.startTime) < GestureHandler.MAX_TIME_SPAN ? GestureHandler.MIN_DISTANCE_LIMIT : GestureHandler.MAX_DISTANCE_LIMIT;
13884  },
13885  GetContainerElement: function () {
13886  },
13887  AttachPreventEvents: function (evt) {
13888   if(!this.isEventsPrevented) {
13889    var element = ASPx.Evt.GetEventSource(evt);
13890    var container = this.GetContainerElement();
13891    while(element && element != container) {
13892     ASPx.Evt.AttachEventToElement(element, "mouseup", ASPx.Evt.PreventEvent);
13893     ASPx.Evt.AttachEventToElement(element, "click", ASPx.Evt.PreventEvent);
13894     this.savedElements.push(element);
13895     element = element.parentNode;
13896    }
13897    this.isEventsPrevented = true;
13898   }
13899  },
13900  DetachPreventEvents: function () {
13901   if(this.isEventsPrevented) {
13902    window.setTimeout(function () {
13903     while(this.savedElements.length > 0) {
13904      var element = this.savedElements.pop();
13905      ASPx.Evt.DetachEventFromElement(element, "mouseup", ASPx.Evt.PreventEvent);
13906      ASPx.Evt.DetachEventFromElement(element, "click", ASPx.Evt.PreventEvent);
13907     }
13908    }.aspxBind(this), 0);
13909    this.isEventsPrevented = false;
13910   }
13911  }
13912 });
13913 GestureHandler.MAX_DISTANCE_LIMIT = 70;
13914 GestureHandler.MIN_DISTANCE_LIMIT = 10;
13915 GestureHandler.MIN_START_DISTANCE = 0;
13916 GestureHandler.SLIDER_MIN_START_DISTANCE = 5;
13917 GestureHandler.MAX_TIME_SPAN = 300;
13918 GestureHandler.FACTOR_RUBBER = 4;
13919 GestureHandler.RETURN_ANIMATION_DURATION = 150;
13920 var SwipeSlideGestureHandler = ASPx.CreateClass(GestureHandler, {
13921  constructor: function (getAnimationElement, direction, canHandle, backward, forward, rollback, move) {
13922   this.constructor.prototype.constructor.call(this, getAnimationElement, canHandle);
13923   this.slideElement = this.getAnimationElement();
13924   this.container = this.slideElement.parentNode;
13925   this.direction = direction;
13926   this.backward = backward;
13927   this.forward = forward;
13928   this.rollback = rollback;
13929   this.slideElementSize = 0;
13930   this.containerElementSize = 0;
13931   this.startSliderElementPosition = 0;
13932   this.centeredSlideElementPosition = 0;
13933  },
13934  OnMouseDown: function (evt) {
13935   GestureHandler.prototype.OnMouseDown.call(this, evt);
13936   this.slideElementSize = this.GetElementSize();
13937   this.startSliderElementPosition = this.GetElementPosition();
13938   this.containerElementSize = this.GetContainerElementSize();
13939   if(this.slideElementSize <= this.containerElementSize)
13940    this.centeredSlideElementPosition = (this.containerElementSize - this.slideElementSize) / 2;
13941  },
13942  OnMouseMove: function (evt) {
13943   GestureHandler.prototype.OnMouseMove.call(this, evt);
13944   if(!ASPx.Browser.TouchUI && !ASPx.GetIsParent(this.container, ASPx.Evt.GetEventSource(evt))) {
13945    GesturesHelper.OnDocumentMouseUp(evt);
13946    return;
13947   }
13948   var distance = this.GetCurrentDistance(evt);
13949   if(Math.abs(distance) < GestureHandler.SLIDER_MIN_START_DISTANCE || ASPx.TouchUIHelper.isGesture)
13950    return;
13951   this.SetElementPosition(this.GetCalculatedPosition(distance));
13952   this.AttachPreventEvents(evt);
13953   ASPx.Evt.PreventEvent(evt);
13954  },
13955  GetCalculatedPosition: function (distance) {
13956   ASPx.AnimationTransitionBase.Cancel(this.slideElement);
13957   var position = this.startSliderElementPosition + distance,
13958    maxPosition = -(this.slideElementSize - this.containerElementSize),
13959    minPosition = 0;
13960   if(this.centeredSlideElementPosition > 0)
13961    position = this.GetRubberPosition(distance) + this.centeredSlideElementPosition;
13962   else if(position > minPosition)
13963    position = this.GetRubberPosition(distance);
13964   else if(position < maxPosition)
13965    position = this.GetRubberPosition(distance) + maxPosition;
13966   return position;
13967  },
13968  OnMouseUp: function (evt) {
13969   this.DetachPreventEvents();
13970   if(this.GetCurrentDistance(evt) != 0)
13971    this.OnMouseUpCore(evt);
13972  },
13973  OnMouseUpCore: function (evt) {
13974   var distance = this.GetCurrentDistance(evt);
13975   if(this.centeredSlideElementPosition > 0 || this.CheckSlidePanelIsOutOfBounds())
13976    this.PerformRollback();
13977   else
13978    this.PerformAction(distance);
13979  },
13980  PerformAction: function (distance) {
13981   if(Math.abs(distance) < this.GetDistanceLimit())
13982    this.PerformRollback();
13983   else if(distance < 0)
13984    this.PerformForward();
13985   else
13986    this.PerformBackward();
13987  },
13988  PerformBackward: function () {
13989   this.backward();
13990  },
13991  PerformForward: function () {
13992   this.forward();
13993  },
13994  PerformRollback: function () {
13995   this.rollback();
13996  },
13997  CheckSlidePanelIsOutOfBounds: function () {
13998   var minOffset = -(this.slideElementSize - this.containerElementSize), maxOffset = 0;
13999   var slideElementPos = this.GetElementPosition();
14000   if(slideElementPos > maxOffset || slideElementPos < minOffset)
14001    return true;
14002   return false;
14003  },
14004  GetContainerElement: function () {
14005   return this.container;
14006  },
14007  GetElementSize: function () {
14008   return this.IsHorizontalDirection() ? this.slideElement.offsetWidth : this.slideElement.offsetHeight;
14009  },
14010  GetContainerElementSize: function () {
14011   return this.IsHorizontalDirection() ? ASPx.GetClearClientWidth(this.container) : ASPx.GetClearClientHeight(this.container);
14012  },
14013  GetCurrentDistance: function (evt) {
14014   return this.IsHorizontalDirection() ? this.GetCurrentDistanceX(evt) : this.GetCurrentDistanceY(evt);
14015  },
14016  GetElementPosition: function () {
14017   return ASPx.AnimationUtils.GetTransformValue(this.slideElement, !this.IsHorizontalDirection());
14018  },
14019  SetElementPosition: function (position) {
14020   ASPx.AnimationUtils.SetTransformValue(this.slideElement, position, !this.IsHorizontalDirection());
14021  },
14022  IsHorizontalDirection: function () {
14023   return this.direction == AnimationHelper.SLIDE_HORIZONTAL_DIRECTION;
14024  }
14025 });
14026 var SwipeSimpleSlideGestureHandler = ASPx.CreateClass(SwipeSlideGestureHandler, {
14027  constructor: function (getAnimationElement, direction, canHandle, backward, forward, rollback, updatePosition) {
14028   this.constructor.prototype.constructor.call(this, getAnimationElement, direction, canHandle, backward, forward, rollback);
14029   this.container = this.slideElement;
14030   this.updatePosition = updatePosition;
14031   this.prevDistance = 0;
14032  },
14033  OnMouseDown: function (evt) {
14034   GestureHandler.prototype.OnMouseDown.call(this, evt);
14035   this.prevDistance = 0;
14036  },
14037  OnMouseUpCore: function (evt) {
14038   this.PerformAction(this.GetCurrentDistance(evt));
14039  },
14040  PerformAction: function (distance) {
14041   if(Math.abs(distance) < this.GetDistanceLimit())
14042    this.PerformRollback();
14043   else if(distance < 0)
14044    this.PerformForward();
14045   else
14046    this.PerformBackward();
14047  },
14048  GetCalculatedPosition: function (distance) {
14049   var position = distance - this.prevDistance;
14050   this.prevDistance = distance;
14051   return position;
14052  },
14053  SetElementPosition: function (position) {
14054   this.updatePosition(position);
14055  }
14056 });
14057 var SwipeGestureHandler = ASPx.CreateClass(GestureHandler, {
14058  constructor: function (getAnimationElement, canHandle, allowStart, start, allowComplete, complete, cancel, animationEngineType, rtl) {
14059   this.constructor.prototype.constructor.call(this, getAnimationElement, canHandle, allowStart);
14060   this.start = start;
14061   this.allowComplete = allowComplete;
14062   this.complete = complete;
14063   this.cancel = cancel;
14064   this.animationTween = null;
14065   this.currentDistanceX = 0;
14066   this.currentDistanceY = 0;
14067   this.tryStartGesture = false;
14068   this.tryStartScrolling = false;
14069   this.animationEngineType = animationEngineType;
14070   this.rtl = rtl;
14071   this.UpdateAnimationContainer();
14072  },
14073  UpdateAnimationContainer: function () {
14074   this.animationContainer = AnimationHelper.getSlideAnimationContainer(this.getAnimationElement(), true, false);
14075  },
14076  CanHandleEvent: function (evt) {
14077   if(GestureHandler.prototype.CanHandleEvent.call(this, evt))
14078    return true;
14079   return this.animationTween && this.animationContainer && ASPx.GetIsParent(this.animationContainer, ASPx.Evt.GetEventSource(evt));
14080  },
14081  OnMouseDown: function (evt) {
14082   GestureHandler.prototype.OnMouseDown.call(this, evt);
14083   if(this.animationTween)
14084    this.animationTween.Cancel();
14085   this.currentDistanceX = 0;
14086   this.currentDistanceY = 0;
14087   this.tryStartGesture = false;
14088   this.tryStartScrolling = false;
14089  },
14090  OnMouseMove: function (evt) {
14091   GestureHandler.prototype.OnMouseMove.call(this, evt);

14092   var isZoomGestureConflict = evt.touches && evt.touches.length > 1;
14093   if (isZoomGestureConflict)
14094    return false;
14095   this.currentDistanceX = this.GetCurrentDistanceX(evt);
14096   this.currentDistanceY = this.GetCurrentDistanceY(evt);
14097   if(this.rtl)
14098    this.currentDistanceX = -this.currentDistanceX;
14099   if(!this.animationTween && !this.tryStartScrolling && (Math.abs(this.currentDistanceX) >
14100    GestureHandler.MIN_START_DISTANCE || Math.abs(this.currentDistanceY) > GestureHandler.MIN_START_DISTANCE)) {
14101    if(Math.abs(this.currentDistanceY) < Math.abs(this.currentDistanceX)) {
14102     this.tryStartGesture = true;
14103     if(this.IsStartAllowed(this.currentDistanceX)) {
14104      this.animationContainer = AnimationHelper.getSlideAnimationContainer(this.getAnimationElement(), true, true);
14105      this.animationTween = AnimationHelper.createSlideTransition(this.animationContainer, AnimationHelper.SLIDE_LEFT_DIRECTION,
14106       function () {
14107        AnimationHelper.resetSlideAnimationContainerSize(this.animationContainer);
14108        this.animationContainer = null;
14109        this.animationTween = null;
14110       }.aspxBind(this), this.animationEngineType, this.rtl);
14111      this.PerformStart(this.currentDistanceX);
14112      this.AttachPreventEvents(evt);
14113     }
14114    }
14115    else
14116     this.tryStartScrolling = true;
14117   }
14118   if(this.animationTween) {
14119    if(this.allowComplete && !this.allowComplete(this.currentDistanceX))
14120     this.currentDistanceX = this.GetRubberPosition(this.currentDistanceX);
14121    this.animationTween.SetValue(this.currentDistanceX);
14122   }
14123   if(!this.tryStartScrolling && !ASPx.TouchUIHelper.isGesture && evt.touches && evt.touches.length < 2)
14124    ASPx.Evt.PreventEvent(evt);
14125  },
14126  OnMouseUp: function (evt) {
14127   if(!this.animationTween) {
14128    if(this.tryStartGesture)
14129     this.PerformCancel(this.currentDistanceX);
14130   }
14131   else {
14132    if(Math.abs(this.currentDistanceX) < this.GetDistanceLimit())
14133     this.RollbackGesture();
14134    else {
14135     if(this.IsCompleteAllowed(this.currentDistanceX)) {
14136      this.PerformComplete(this.currentDistanceX);
14137      this.animationContainer = null;
14138      this.animationTween = null;
14139     }
14140     else
14141      this.RollbackGesture();
14142    }
14143   }
14144   this.DetachPreventEvents();
14145   this.tryStartGesture = false;
14146   this.tryStartScrolling = false;
14147  },
14148  PerformStart: function (value) {
14149   if(this.start)
14150    this.start(value);
14151  },
14152  IsCompleteAllowed: function (value) {
14153   return !this.allowComplete || this.allowComplete(value);
14154  },
14155  PerformComplete: function (value) {
14156   if(this.complete)
14157    this.complete(value);
14158  },
14159  PerformCancel: function (value) {
14160   if(this.cancel)
14161    this.cancel(value);
14162  },
14163  RollbackGesture: function () {
14164   this.animationTween.Start(this.currentDistanceX, 0);
14165  },
14166  ResetGestureElementPosition: function () {
14167   if (this.currentDistanceX === 0) return;
14168   var container = AnimationHelper.getSlideAnimationContainer(this.getAnimationElement());
14169   var onComplete = function () { AnimationHelper.resetSlideAnimationContainerSize(container); };
14170   var animation = AnimationHelper.createSlideTransition(container, AnimationHelper.SLIDE_LEFT_DIRECTION, onComplete, this.animationEngineType, this.rtl);
14171   animation.Start(this.currentDistanceX, 0);
14172  },
14173  GetContainerElement: function () {
14174   return this.animationContainer;
14175  }
14176 });
14177 var GesturesHelper = {
14178  handlers: {},
14179  activeHandler: null,
14180  isAttachedEvents: false,
14181  isExecutedGesture: false,
14182  AddSwipeGestureHandler: function (id, getAnimationElement, canHandle, allowStart, start, allowComplete, complete, cancel, animationEngineType, rtl) {
14183   this.handlers[id] = new SwipeGestureHandler(getAnimationElement, canHandle, allowStart, start, allowComplete, complete, cancel, animationEngineType, rtl);
14184  },
14185  UpdateSwipeAnimationContainer: function (id) {
14186   if(this.handlers[id])
14187    this.handlers[id].UpdateAnimationContainer();
14188  },
14189  AddSwipeSlideGestureHandler: function (id, getAnimationElement, direction, canHandle, backward, forward, rollback, updatePosition) {
14190   if(updatePosition)
14191    this.handlers[id] = new SwipeSimpleSlideGestureHandler(getAnimationElement, direction, canHandle, backward, forward, rollback, updatePosition);
14192   else
14193    this.handlers[id] = new SwipeSlideGestureHandler(getAnimationElement, direction, canHandle, backward, forward, rollback);
14194  },
14195  getParentDXEditorWithSwipeGestures: function(element) {
14196     return ASPx.GetParent(element, function(parent) {

14197      var parentObj = ASPx.GetControlCollection().Get(parent.id);
14198      return parentObj && parentObj.supportGestures && parentObj.isSwipeGesturesEnabled();
14199   });
14200  },
14201  canHandleMouseDown: function(evt) {
14202   if(!ASPx.Evt.IsLeftButtonPressed(evt))
14203    return false;
14204   var element = ASPx.Evt.GetEventSource(evt);
14205   var dxFocusedEditor = ASPx.Ident.scripts.ASPxClientEdit && ASPx.GetFocusedEditor();
14206   if(dxFocusedEditor && dxFocusedEditor.IsEditorElement(element)) {
14207    var elementParentDXEditorWithSwipeGestures = GesturesHelper.getParentDXEditorWithSwipeGestures(element);
14208    if(!elementParentDXEditorWithSwipeGestures || !dxFocusedEditor.IsEditorElement(elementParentDXEditorWithSwipeGestures))
14209     return false;
14210   }
14211   var isTextEditor = element.tagName == "TEXTAREA" || element.tagName == "INPUT" && ASPx.Attr.GetAttribute(element, "type") == "text";
14212   if(isTextEditor && document.activeElement == element)
14213    return false;
14214   return true;  
14215  },
14216  OnDocumentDragStart: function(evt) {
14217   if(GesturesHelper.activeHandler)
14218    GesturesHelper.activeHandler.OnDragStart(evt);
14219  },
14220  OnDocumentMouseDown: function (evt) {
14221   if(!GesturesHelper.canHandleMouseDown(evt))
14222    return;
14223   GesturesHelper.activeHandler = GesturesHelper.FindHandler(evt);
14224   if(GesturesHelper.activeHandler)
14225    GesturesHelper.activeHandler.OnMouseDown(evt);
14226  },
14227  OnDocumentMouseMove: function (evt) {
14228   if(GesturesHelper.activeHandler) {
14229    GesturesHelper.isExecutedGesture = true;
14230    GesturesHelper.activeHandler.OnMouseMove(evt);
14231   }
14232  },
14233  OnDocumentMouseUp: function (evt) {
14234   if(GesturesHelper.activeHandler) {
14235    GesturesHelper.activeHandler.OnMouseUp(evt);
14236    GesturesHelper.activeHandler = null;
14237    window.setTimeout(function () { GesturesHelper.isExecutedGesture = false; }, 0);
14238   }
14239  },
14240  AttachEvents: function () {
14241   if(!GesturesHelper.isAttachedEvents) {
14242    GesturesHelper.Attach(ASPx.Evt.AttachEventToElement);
14243    GesturesHelper.isAttachedEvents = true;
14244   }
14245  },
14246  DetachEvents: function () {
14247   if(GesturesHelper.isAttachedEvents) {
14248    GesturesHelper.Attach(ASPx.Evt.DetachEventFromElement);
14249    GesturesHelper.isAttachedEvents = false;
14250   }
14251  },
14252  Attach: function (changeEventsMethod) {
14253   var doc = window.document;
14254   changeEventsMethod(doc, ASPx.TouchUIHelper.touchMouseDownEventName, GesturesHelper.OnDocumentMouseDown);
14255   changeEventsMethod(doc, ASPx.TouchUIHelper.touchMouseMoveEventName, GesturesHelper.OnDocumentMouseMove);
14256   changeEventsMethod(doc, ASPx.TouchUIHelper.touchMouseUpEventName, GesturesHelper.OnDocumentMouseUp);
14257   if(!ASPx.Browser.MobileUI) {
14258    changeEventsMethod(doc, "dragstart", GesturesHelper.OnDocumentDragStart);
14259   }
14260  },
14261  FindHandler: function (evt) {
14262   var handlers = [];
14263   for(var id in GesturesHelper.handlers) {
14264    if(GesturesHelper.handlers.hasOwnProperty(id)) {
14265     var handler = GesturesHelper.handlers[id];
14266     if(handler.CanHandleEvent && handler.CanHandleEvent(evt))
14267      handlers.push(handler);
14268    }
14269   }
14270   if(!handlers.length)
14271    return null;
14272   handlers.sort(function (a, b) {
14273    return ASPx.GetIsParent(a.getAnimationElement(), b.getAnimationElement()) ? 1 : -1;
14274   });
14275   return handlers[0];
14276  },
14277  IsExecutedGesture: function () {
14278   return GesturesHelper.isExecutedGesture;
14279  }
14280 };
14281 GesturesHelper.AttachEvents();
14282 var AnimationEngineType = {
14283  "DEFAULT": 0,
14284  "CSS": 1,
14285  "JS": 2
14286 };
14287 ASPx.AnimationEngineType = AnimationEngineType;
14288 ASPx.AnimationHelper = AnimationHelper;
14289 ASPx.GesturesHelper = GesturesHelper;
14290})();
14291
14292(function() {
14293var ASPxClientButton = ASPx.CreateClass(ASPxClientControl, {
14294 constructor: function(name) {
14295  this.constructor.prototype.constructor.call(this, name);
14296  this.isASPxClientButton = true;
14297  this.allowFocus = true;
14298  this.autoPostBackFunction = null;
14299  this.causesValidation = true;
14300  this.checked = false;
14301  this.clickLocked = false;
14302  this.groupName = "";
14303  this.focusElementSelected = false;
14304  this.pressed = false;
14305  this.useSubmitBehavior = true;
14306  this.validationGroup = "";
14307  this.validationContainerID = null;
14308  this.validateInvisibleEditors = false;
14309  this.originalWidth = null;
14310  this.originalHeight = null;
14311  this.needUpdateBounds = true;
14312  this.isTextEmpty = false;
14313  this.isImage = false;
14314  this.CheckedChanged = new ASPxClientEvent();
14315  this.GotFocus = new ASPxClientEvent();
14316  this.LostFocus = new ASPxClientEvent();
14317  this.Click = new ASPxClientEvent();
14318 },
14319 InlineInitialize: function() {
14320  var mainElement = this.GetMainElement();
14321  this.originalWidth = mainElement.style.width;
14322  this.originalHeight = mainElement.style.height;
14323  ASPxClientControl.prototype.InlineInitialize.call(this);
14324  this.InitializeElementIDs();
14325  this.InitializeEvents();
14326  this.InitializeEnabled();
14327  this.InitializeChecked();
14328  if(this.IsLink())
14329   this.InitializeLink();
14330  this.PreventButtonImageDragging();
14331  this.EnsureBoundsAdjusted();
14332 },
14333 InitializeElementIDs: function(){
14334  var mainElement = this.GetMainElement();
14335  var contentElement = ASPx.GetNodeByTagName(mainElement, "DIV", 0);
14336  if(contentElement) contentElement.id = this.name + "_CD";
14337  var imageElement = ASPx.GetNodeByTagName(mainElement, "IMG", 0);
14338  if(imageElement) imageElement.id = this.name + "Img";
14339 },
14340 InitializeEnabled: function(){
14341  this.SetEnabledInternal(this.clientEnabled, true);
14342 },
14343 InitializeChecked: function(){
14344  this.SetCheckedInternal(this.checked, true);
14345 },
14346 InitializeLink: function(){
14347  var mainElement = this.GetMainElement();
14348  if(this.enabled)
14349   mainElement.href = "javascript:;";
14350  if(!this.allowFocus)
14351   mainElement.style.outline = 0;
14352  if(!this.isImage && !this.GetTextContainer())
14353   mainElement.style.fontSize = "0pt";
14354 },
14355 InitializeEvents: function(){
14356  if(!this.isNative && !this.IsLink()) {
14357   var element = this.GetInternalButton();
14358   if(element)
14359    element.onfocus = null;
14360   var textControl = this.GetTextControl();
14361   if(textControl)
14362    ASPx.Evt.PreventElementDragAndSelect(textControl, false);
14363  }
14364  this.onClick = function(evt) {
14365   var processOnServer = ASPx.BClick(this.name, evt);
14366   if(!processOnServer)
14367    ASPx.Evt.PreventEvent(evt);
14368   return processOnServer;
14369  }.aspxBind(this);
14370  this.onImageMoseDown = function() { var el = ASPx.GetFocusedElement(); if(el) el.blur(); };
14371  this.onGotFocus = function() { this.OnFocus(); }.aspxBind(this);
14372  this.onLostFocus = function() { this.OnLostFocus(); }.aspxBind(this);
14373  this.onKeyUp = function(evt) { this.OnKeyUp(evt); }.aspxBind(this);
14374  this.onKeyDown = function(evt) { this.OnKeyDown(evt); }.aspxBind(this); 
14375  if(!this.isNative && !this.IsLink())
14376   this.InitializeNativeHandlers();
14377 },
14378 InitializeNativeHandlers: function() {
14379  this.AttachNativeHandlerToMainElement("focus", "SetFocus");
14380  this.AttachNativeHandlerToMainElement("click", "DoClick");
14381 },
14382 EnsureBoundsAdjusted: function() {
14383  var mainElement = this.GetMainElement();
14384  this.needUpdateBounds = ASPx.GetCurrentStyle(mainElement).display === "block";
14385  if(this.needUpdateBounds) 
14386   mainElement.className = mainElement.className.replace("dxbTSys", "");
14387 },
14388 AdjustControlCore: function () {
14389  if(this.isNative || this.IsLink()) return;
14390  var buttonImage = this.GetButtonImage();  
14391  if(buttonImage && buttonImage.offsetHeight === 0 && buttonImage.offsetWidth === 0)
14392   buttonImage.onload = function() { this.UpdateSize(); }.aspxBind(this);
14393  else
14394   this.UpdateSize();
14395  this.UpdateVerticalAlign();
14396 },
14397 UpdateSize: function() {
14398  if(this.needUpdateBounds) {
14399   this.UpdateWidth();
14400   this.UpdateHeight();
14401  } else
14402   this.CorrectWrappedText(this.GetContentDiv, "Text", true);
14403 },
14404 UpdateVerticalAlign: function() {
14405  var contentElement = this.GetContentDiv();
14406  var verticalAlign = this.GetMainElement().style.verticalAlign;
14407  if(ASPx.IsExistsElement(contentElement) && verticalAlign)
14408   contentElement.style.verticalAlign = verticalAlign;
14409 },
14410 UpdateHeight: function(){
14411  if(this.isNative || this.IsLink() || this.originalHeight === null || ASPx.IsPercentageSize(this.originalHeight)) return;
14412  var height;
14413  var mainElement = this.GetMainElement();
14414  var contentDiv = this.GetContentDiv();
14415  var borderAndPadding = ASPx.GetTopBottomBordersAndPaddingsSummaryValue(mainElement);
14416  var contentHasExcessiveHeight = contentDiv.offsetHeight > mainElement.offsetHeight - borderAndPadding;

14417  var needSetAutoHeight = !this.originalHeight || (ASPx.Browser.Safari && contentHasExcessiveHeight);
14418  if(needSetAutoHeight) {
14419   mainElement.style.height = "";
14420   height = mainElement.offsetHeight - borderAndPadding;
14421  }
14422  else
14423   height = (ASPx.PxToInt(this.originalHeight) - borderAndPadding);
14424  if(height){
14425   mainElement.style.height = height + "px";
14426   if(contentDiv && contentDiv.offsetHeight > 0){
14427    var contentDivCurrentStyle = ASPx.GetCurrentStyle(contentDiv);
14428    var paddingTop = parseInt(contentDivCurrentStyle.paddingTop) || 0;
14429    var paddingBottom = parseInt(contentDivCurrentStyle.paddingBottom) || 0;
14430    var clientHeightDiff = height - contentDiv.offsetHeight;
14431    var verticalAlign = ASPx.GetCurrentStyle(mainElement).verticalAlign;
14432    if(verticalAlign == "top")
14433     paddingBottom = paddingBottom + clientHeightDiff;
14434    else if(verticalAlign == "bottom")
14435     paddingTop = paddingTop + clientHeightDiff;
14436    else {
14437     var halfClientHeightDiff = Math.floor(clientHeightDiff / 2);
14438     paddingTop = paddingTop + halfClientHeightDiff;
14439     paddingBottom = paddingBottom + (clientHeightDiff - halfClientHeightDiff);
14440    }
14441    contentDiv.style.paddingTop = (paddingTop > 0 ? paddingTop : 0) + "px";
14442    contentDiv.style.paddingBottom = (paddingBottom > 0 ? paddingBottom : 0) + "px";
14443   }
14444  }
14445 },
14446 UpdateWidth: function(){
14447  if(this.isNative || this.IsLink() || this.originalWidth === null) return;
14448  if(!ASPx.IsPercentageSize(this.originalWidth)) {
14449   var mainElement = this.GetMainElement();
14450   var borderAndPadding = ASPx.GetLeftRightBordersAndPaddingsSummaryValue(mainElement);
14451   if(this.originalWidth && ASPx.IsTextWrapped(this.GetTextContainer()))
14452    mainElement.style.width = (ASPx.PxToInt(this.originalWidth) - borderAndPadding) + "px";
14453   else
14454    mainElement.style.width = "auto";
14455   var width = mainElement.offsetWidth - borderAndPadding;
14456   if(this.originalWidth && width < ASPx.PxToInt(this.originalWidth) - borderAndPadding) 
14457    width = ASPx.PxToInt(this.originalWidth) - borderAndPadding;
14458   if(width)
14459    mainElement.style.width = (width > 0 ? width : 0)  + "px";
14460  }
14461  this.CorrectWrappedText(this.GetContentDiv, "Text", true);
14462 },
14463 GetAdjustedSizes: function() {
14464  var sizes = ASPxClientControl.prototype.GetAdjustedSizes.call(this);
14465  var image = this.GetButtonImage();
14466  if(image) {
14467   sizes.imageWidth = image.offsetWidth;
14468   sizes.imageHeight = image.offsetHeight;
14469  }
14470  return sizes;
14471 },
14472 PreventButtonImageDragging: function() {
14473  ASPx.Evt.PreventImageDragging(this.GetButtonImage());
14474 },
14475 AttachNativeHandlerToMainElement: function(handlerName, correspondingMethodName) {
14476  var mainElement = this.GetMainElement();
14477  if(!ASPx.IsExistsElement(mainElement))
14478   return;
14479  mainElement[handlerName] = function() { _aspxBCallButtonMethod(this.name, correspondingMethodName); }.aspxBind(this);
14480 },
14481 GetContentDiv: function(){
14482  return this.GetChildElement("CD");
14483 },       
14484 GetButtonImage: function(){
14485  return ASPx.CacheHelper.GetCachedElement(this, "buttonImage", 
14486   function() { 
14487    return ASPx.GetNodeByTagName(this.GetMainElement(), "IMG", 0); 
14488   });
14489 },
14490 GetInternalButton: function() {
14491  return ASPx.CacheHelper.GetCachedElement(this, "internalButton", 
14492   function() { 
14493    return this.isNative || this.IsLink() ? this.GetMainElement() : ASPx.GetNodeByTagName(this.GetMainElement(), "INPUT", 0);
14494   });
14495 },
14496 GetTextContainer: function() {
14497  return ASPx.CacheHelper.GetCachedElement(this, "textContainer", 
14498   function() { 
14499    if(this.isNative)
14500     return this.GetMainElement();
14501    else{
14502     var textElement = this.IsLink() ? this.GetMainElement() : this.GetContentDiv();
14503     return this.accessibilityCompliant ? ASPx.GetElementById(this.name + "_BTC") : ASPx.GetNodeByTagName(textElement, "SPAN", 0);
14504    }
14505   });
14506 },
14507 GetTextControl: function(){
14508  return ASPx.CacheHelper.GetCachedElement(this, "textControl", 
14509   function() { 
14510    var element = ASPx.GetParentByTagName(this.GetContentDiv(), "DIV");

14511    if(!ASPx.IsExistsElement(element) || (element.id == this.name))
14512     element = this.GetContentDiv();
14513    return element;
14514   });
14515 },
14516 IsLink: function(){
14517  if (this.GetMainElement())
14518   return this.GetMainElement().tagName === "A";
14519  return false;
14520 },   
14521 IsHovered: function(){
14522  var hoverElement = this.GetMainElement();
14523  return ASPx.GetStateController().currentHoverItemName == hoverElement.id;
14524 },   
14525 SetEnabledInternal: function(enabled, initialization) {
14526  if(!this.enabled)
14527   return;
14528  if(!initialization || !enabled)
14529   this.ChangeEnabledStateItems(enabled);
14530  this.ChangeEnabledAttributes(enabled);
14531 },
14532 ChangeEnabledAttributes: function(enabled) {
14533  var element = this.GetInternalButton();
14534  if(element) {
14535   if(this.IsLink()){
14536    var method = ASPx.Attr.ChangeAttributesMethod(enabled);
14537    var link = this.GetMainElement();
14538    method(link, "href");
14539    if(this.accessibilityCompliant)
14540     ASPx.Attr.SetOrRemoveAttribute(link, ASPx.Attr.GetTabIndexAttributeName(), enabled ? null : "0");
14541   } else {
14542    if(this.accessibilityCompliant)
14543     ASPx.Attr.Aria.SetOrRemoveDisabled(element, !enabled);
14544    else
14545     element.disabled = !enabled;
14546   }
14547  }
14548  this.ChangeEnabledEventsAttributes(ASPx.Attr.ChangeEventsMethod(enabled));
14549  var isFocusable = enabled || this.accessibilityCompliant;
14550  this.ChangeEnabledFocusEvents(ASPx.Attr.ChangeEventsMethod(isFocusable));
14551 },
14552 ChangeEnabledEventsAttributes: function(method) {
14553  var element = this.GetMainElement();
14554  method(element, "click", this.onClick);
14555  if(this.allowFocus){
14556   if(!this.isNative && !this.IsLink()) {
14557    element = this.GetInternalButton();
14558    if(element) {
14559     method(element, "keyup", this.onKeyUp);
14560     method(element, "blur", this.onKeyUp);
14561     method(element, "keydown", this.onKeyDown);
14562    }
14563   }
14564   if(ASPx.Browser.Firefox){
14565    var image = this.GetButtonImage();
14566    if(image)
14567     method(image, "mousedown", this.onImageMoseDown); 
14568   }
14569  }
14570 },
14571 ChangeEnabledFocusEvents: function(method) {
14572  if(!this.allowFocus)
14573   return;
14574  var element = !this.isNative && !this.IsLink() ? this.GetInternalButton() : this.GetMainElement();
14575  if(element) {
14576   method(element, "focus", this.onGotFocus);
14577   method(element, "blur", this.onLostFocus);
14578  }
14579 },
14580 ChangeEnabledStateItems: function(enabled){
14581  if(this.isNative) return;
14582  ASPx.GetStateController().SetElementEnabled(this.GetMainElement(), enabled);
14583  this.UpdateFocusedStyle();
14584 },
14585 RequiredPreventDoublePostback: function(){
14586  return ASPx.Browser.Firefox && !this.isNative; 
14587 },
14588 OnFocus: function() {
14589  if(!this.allowFocus)
14590   return false;
14591  this.focused = true;
14592  if(this.isInitialized)
14593   this.RaiseFocus();
14594  this.UpdateFocusedStyle();
14595 },  
14596 OnLostFocus: function() {
14597  if(!this.allowFocus)
14598   return false;
14599  this.focused = false;
14600  if(this.isInitialized)
14601   this.RaiseLostFocus();
14602  this.UpdateFocusedStyle();
14603 },
14604 CauseValidation: function() {
14605  if(this.causesValidation && ASPx.Ident.scripts.ASPxClientEdit)
14606   return this.validationContainerID != null ?
14607    ASPxClientEdit.ValidateEditorsInContainerById(this.validationContainerID, this.validationGroup, this.validateInvisibleEditors) :
14608    ASPxClientEdit.ValidateGroup(this.validationGroup, this.validateInvisibleEditors);
14609  else
14610   return true;
14611 },
14612 OnClick: function(evt) {
14613  if(this.clickLocked) return true;
14614  if(this.checked && this.groupName != "" && this.GetCheckedGroupList().length > 1) return;
14615  this.SetFocus();
14616  var isValid = this.CauseValidation();
14617  var processOnServer = this.autoPostBack;
14618  if(this.groupName != "") {
14619   if(this.GetCheckedGroupList().length == 1)
14620    this.SetCheckedInternal(!this.checked, false);
14621   else {
14622    this.SetCheckedInternal(true, false);
14623    this.ClearButtonGroupChecked(true);
14624   }
14625   processOnServer = this.RaiseCheckedChanged();
14626   if(processOnServer && isValid)
14627    this.SendPostBack("CheckedChanged");
14628  }
14629  var params = this.RaiseClick();
14630  if(evt && params.cancelEventAndBubble)
14631   ASPx.Evt.PreventEventAndBubble(evt);
14632  if(params.processOnServer && isValid)
14633   return this.ProcessClick();
14634  return false;
14635 },
14636 ProcessClick: function() {
14637  var requiredPreventDoublePostback = this.RequiredPreventDoublePostback();
14638  var postponePostback = ASPx.Browser.AndroidMobilePlatform; 
14639  if(requiredPreventDoublePostback || postponePostback)
14640   window.setTimeout(function() { _aspxBCallButtonMethod(this.name, "SendPostBack", "Click"); }.aspxBind(this), 0); 
14641  else
14642   this.SendPostBack("Click");
14643  return !requiredPreventDoublePostback;
14644 },
14645 OnKeyUp: function(evt) {
14646  if(!this.pressed)
14647   return;
14648  this.pressed = false;
14649  ASPx.GetStateController().OnKeyUpOnElement(evt);
14650 },
14651 OnKeyDown: function(evt) {
14652  if(evt.keyCode == ASPx.Key.Enter || evt.keyCode == ASPx.Key.Space)
14653   this.SetPressed();
14654 },
14655 GetCheckedGroupList: function(){
14656  var result = [ ];
14657  ASPx.GetControlCollection().ForEachControl(function(control) {
14658   if(ASPx.Ident.IsASPxClientButton(control) && (control.groupName == this.groupName) && !control.IsDOMDisposed())
14659    result.push(control);
14660  }, this);
14661  return result;
14662 },
14663 ClearButtonGroupChecked: function(raiseCheckedChanged){
14664  var list = this.GetCheckedGroupList();
14665  for(var i = 0; i < list.length; i ++){
14666   if(list[i] != this && list[i].checked) {
14667    list[i].SetCheckedInternal(false, false);
14668    if(raiseCheckedChanged)
14669     list[i].RaiseCheckedChanged();
14670   }
14671  }
14672 },
14673 ApplyCheckedStyle: function(){
14674  var stateController = ASPx.GetStateController();
14675  if(this.IsHovered()) 
14676   stateController.SetCurrentHoverElement(null);  
14677  stateController.SelectElementBySrcElement(this.GetMainElement());
14678 }, 
14679 ApplyUncheckedStyle: function(){
14680  var stateController = ASPx.GetStateController();
14681  if(this.IsHovered()) 
14682   stateController.SetCurrentHoverElement(null);
14683  stateController.DeselectElementBySrcElement(this.GetMainElement());
14684 },  
14685 SetCheckedInternal: function(checked, initialization){
14686  if(initialization && checked || (this.checked != checked)){
14687   this.checked = checked;
14688   if(checked)

14689    this.ApplyCheckedStyle();
14690   else
14691    this.ApplyUncheckedStyle();
14692  }
14693 },
14694 UpdateStateObject: function(){
14695  if(this.groupName != "")
14696   this.UpdateStateObjectWithObject({ checked: this.checked });
14697 },
14698 GetStateHiddenFieldName: function() {
14699  return this.uniqueID + "$State";
14700 },
14701 ApplyPressedStyle: function(){
14702  ASPx.GetStateController().OnMouseDownOnElement(this.GetMainElement());
14703 },
14704 ApplyUnpressedStyle: function(){ 
14705  ASPx.GetStateController().OnMouseUpOnElement(this.GetMainElement());
14706 },
14707 SetPressed: function(){
14708  this.pressed = true;
14709  this.ApplyPressedStyle();
14710 }, 
14711 SetUnpressed: function(){
14712  this.pressed = false;
14713  this.ApplyUnpressedStyle();
14714 },
14715 SetFocus: function(){
14716  if(!this.allowFocus || this.focused)
14717   return;
14718  var element = this.GetInternalButton();
14719  if(element) {
14720   var hiddenInternalButtonRequiresVisibilityToGetFocused = ASPx.Browser.WebKitFamily  && !this.isNative  && !this.IsLink();
14721   if(hiddenInternalButtonRequiresVisibilityToGetFocused)
14722    ASPxClientButton.MakeHiddenElementFocusable(element);
14723   if(ASPx.IsFocusable(element) && ASPx.GetActiveElement() != element)
14724    element.focus();
14725   if(hiddenInternalButtonRequiresVisibilityToGetFocused)
14726    ASPxClientButton.RestoreHiddenElementAppearance(element);
14727  }
14728 },
14729 ApplyFocusedStyle: function(){
14730  if(this.focusElementSelected) return;
14731  if(typeof(ASPx.GetStateController) != "undefined")
14732   ASPx.GetStateController().SelectElementBySrcElement(this.GetContentDiv());
14733  this.focusElementSelected = true;
14734 },
14735 ApplyUnfocusedStyle: function(){ 
14736  if(!this.focusElementSelected) return;
14737  if(typeof(ASPx.GetStateController) != "undefined")
14738   ASPx.GetStateController().DeselectElementBySrcElement(this.GetContentDiv());
14739  this.focusElementSelected = false;
14740 },
14741 UpdateFocusedStyle: function(){
14742  if(this.isNative || this.IsLink()) return;
14743  var isFocusable = this.enabled && this.allowFocus && this.focused && (this.clientEnabled || this.accessibilityCompliant);
14744  if(isFocusable)
14745   this.ApplyFocusedStyle();
14746  else
14747   this.ApplyUnfocusedStyle();
14748 },
14749 SendPostBack: function(postBackArg){
14750  if(!this.enabled || !this.clientEnabled)
14751   return;
14752  var arg = postBackArg || "";
14753  if(this.autoPostBackFunction)
14754   this.autoPostBackFunction(arg);
14755  else if(!this.useSubmitBehavior || this.IsLink())
14756   ASPxClientControl.prototype.SendPostBack.call(this, arg);
14757  if(this.useSubmitBehavior && !this.isNative) 
14758   this.ClickInternalButton();
14759 },
14760 ClickInternalButton: function(){
14761  var element = this.GetInternalButton();
14762  if(element) {
14763   this.clickLocked = true;
14764   if(ASPx.Browser.NetscapeFamily)
14765    this.CreateUniqueIDCarrier(); 
14766   var postHandler = ASPx.GetPostHandler();
14767   postHandler.SetLastSubmitElementName(element.name);
14768   ASPx.Evt.DoElementClick(element);
14769   postHandler.SetLastSubmitElementName(null);
14770   if(ASPx.Browser.NetscapeFamily)
14771    this.RemoveUniqueIDCarrier(); 
14772   this.clickLocked = false;
14773  }
14774 },
14775 CreateUniqueIDCarrier: function() {
14776  var name = this.uniqueID;
14777  var id = this.GetUniqueIDCarrierID();
14778  var field = ASPx.CreateHiddenField(name, id);

14779  var form = this.GetParentForm();
14780  if(form) form.appendChild(field);
14781 },
14782 RemoveUniqueIDCarrier: function() {
14783  var field = document.getElementById(this.GetUniqueIDCarrierID());
14784  if(field)
14785   field.parentNode.removeChild(field);
14786 },
14787 GetUniqueIDCarrierID: function() {
14788  return this.uniqueID + "_UIDC";
14789 },
14790 DoClick: function(){
14791  if(!this.enabled || !this.clientEnabled)
14792   return;
14793  var button = (this.isNative || this.IsLink()) ? this.GetMainElement() : this.GetInternalButton();
14794  if(button)
14795   ASPx.Evt.DoElementClick(button);
14796  else 
14797   this.OnClick();   
14798 },
14799 GetChecked: function(){
14800  return this.checked;
14801 },
14802 SetChecked: function(checked){
14803  this.SetCheckedInternal(checked, false);
14804  this.ClearButtonGroupChecked(false);
14805 },
14806 GetText: function(){
14807  if(!this.isTextEmpty)
14808   return this.isNative ? this.GetTextContainer().value : this.GetTextContainer().innerHTML;
14809  return "";
14810 },
14811 SetText: function(text){
14812  this.isTextEmpty = (text == null || text == "");
14813  var textContainer = this.GetTextContainer();
14814  if(textContainer){
14815   if(this.isNative)
14816    textContainer.value = (text != null) ? text : "";
14817   else {
14818    var value = this.isTextEmpty ? " " : text;
14819      textContainer.innerHTML = value;
14820    var element = this.GetInternalButton();
14821    if(element)
14822     element.value = value;
14823   }
14824   this.UpdateSize();
14825  }
14826 },
14827 GetImageUrl: function(){
14828  var img = this.GetButtonImage();
14829  return img ?  img.src : "";
14830 },
14831 SetImageUrl: function(url){
14832  var img = this.GetButtonImage();
14833  if(img) {
14834   img.src = url;
14835   this.UpdateSize();
14836  }
14837 },
14838 SetEnabled: function(enabled){
14839  if(this.clientEnabled != enabled) {
14840   if(!enabled && this.focused)
14841    this.OnLostFocus();
14842   this.clientEnabled = enabled;
14843   this.SetEnabledInternal(enabled, false);
14844  }
14845 },
14846 GetEnabled: function(){
14847  return this.enabled && this.clientEnabled;
14848 },
14849 Focus: function(){
14850  this.SetFocus();
14851 },
14852 RaiseCheckedChanged: function(){
14853  var processOnServer = this.autoPostBack || this.IsServerEventAssigned("CheckedChanged");
14854  if(!this.CheckedChanged.IsEmpty()){
14855   var args = new ASPxClientProcessingModeEventArgs(processOnServer);
14856   this.CheckedChanged.FireEvent(this, args);
14857   processOnServer = args.processOnServer;
14858  }
14859  return processOnServer;
14860 },
14861 RaiseFocus: function(){
14862  if(!this.GotFocus.IsEmpty()){
14863   var args = new ASPxClientEventArgs();
14864   this.GotFocus.FireEvent(this, args);
14865  }
14866 },
14867 RaiseLostFocus: function(){
14868  if(!this.LostFocus.IsEmpty()){
14869   var args = new ASPxClientEventArgs();
14870   this.LostFocus.FireEvent(this, args);
14871  }
14872 },
14873 RaiseClick: function() {
14874  var processOnServer = this.autoPostBack || this.IsServerEventAssigned("Click");
14875  var cancelEventAndBubble = false;
14876  if(!this.Click.IsEmpty()) {
14877   var args = new ASPxClientButtonClickEventArgs(processOnServer, cancelEventAndBubble);
14878   this.Click.FireEvent(this, args);
14879   cancelEventAndBubble = args.cancelEventAndBubble;
14880   processOnServer = args.processOnServer;
14881  }
14882  return {
14883   processOnServer: processOnServer,
14884   cancelEventAndBubble: cancelEventAndBubble
14885  };
14886 }
14887});
14888ASPxClientButton.Cast = ASPxClientControl.Cast;
14889var ASPxClientButtonClickEventArgs = ASPx.CreateClass(ASPxClientProcessingModeEventArgs, {
14890 constructor: function(processOnServer, cancelEventAndBubble) {
14891  this.constructor.prototype.constructor.call(this, processOnServer);
14892  this.cancelEventAndBubble = cancelEventAndBubble;
14893 }
14894});
14895ASPxClientButton.MakeHiddenElementFocusable = function(element) {
14896 element.__dxHiddenElementState = {
14897  parentDisplay: element.parentNode.style.display,
14898  height: element.style.height,
14899  width: element.style.width
14900 };
14901 element.parentNode.style.display = "block";
14902 element.style.height = "1px";
14903 element.style.width = "1px";
14904};
14905ASPxClientButton.RestoreHiddenElementAppearance = function(element) {
14906 var state = element.__dxHiddenElementState;
14907 element.parentNode.style.display = state.parentDisplay;
14908 element.style.height = state.height;
14909 element.style.width = state.width;
14910 delete element.__dxHiddenElementState;
14911};
14912ASPx.Ident.IsASPxClientButton = function(obj) {
14913 return !!obj.isASPxClientButton;
14914};

14915function _aspxBCallButtonMethod(name, methodName, arg) {
14916 var button = ASPx.GetControlCollection().Get(name); 
14917 if(button != null)
14918  button[methodName](arg);
14919}
14920ASPx.BClick = function(name, evt) {
14921 var button = ASPx.GetControlCollection().Get(name); 
14922 if(button != null)
14923  return button.OnClick(evt);
14924};
14925window.ASPxClientButton = ASPxClientButton;
14926})();
14927