https://masoncontractors.org/DXR.axd?r=1_211-V3vLw&order=18

1ASPx.IS(function(ASPx, dx, DevExpress){
2(function() {
3var GridDragHelperBase = ASPx.CreateClass(null, {
4 maxRepeatScrollTimeout : 30,
5 updateTargetPositionTimeout: 50,
6 scrollingStep: 1,
7 constructor: function() {
8  this.isHorzDrag = false;
9  this.savedPositions = { };
10  this.rect = null;
11 },
12 GetActiveTargets: function() { return [ ]; },
13 GetScrollHelper: function() { return null; },
14 GetExtraCellWidth: function() { return 0; },
15 GetCustomizationWindowElement: function() { return null; },
16 GetScrollableControl: function() { 
17  var helper = this.GetScrollHelper();
18  return this.isHorzDrag ? helper.GetHorzScrollableControl() : helper.GetVertScrollableControl();
19 },
20 OnDragCreated: function(isHorzDrag) {
21  if(this.NeedScrollOnDrag(isHorzDrag))
22   this.InitializeDragScrolling(isHorzDrag);
23 },
24 InitializeDragScrolling: function(isHorzDrag) {
25  this.isHorzDrag = isHorzDrag;
26  this.SaveControlDimensions();
27  this.mouseMoveHandler = function(e) { this.OnMouseMove(e); }.aspxBind(this);
28  ASPx.Evt.AttachEventToDocument("mousemove", this.mouseMoveHandler);
29 },
30 SaveControlDimensions: function() {
31  var scrollableControl = this.GetScrollableControl();
32  var visibility = ASPx.GetElementDisplay(scrollableControl);
33  ASPx.SetElementDisplay(scrollableControl, true);
34  var scrollDivX = ASPx.GetAbsoluteX(scrollableControl);
35  var scrollDivY = ASPx.GetAbsoluteY(scrollableControl);
36  var width = scrollableControl.offsetWidth;
37  var height = scrollableControl.offsetHeight;
38  ASPx.SetElementDisplay(scrollableControl, visibility);
39  this.SaveControlDimensionsCore(scrollDivX, width, scrollDivY, height);
40 },
41 SaveControlDimensionsCore: function(scrollDivX, width, scrollDivY, height) {
42  this.rect = { 
43   left: scrollDivX, 
44   right: scrollDivX + width - this.GetExtraCellWidth(),
45   top: scrollDivY,
46   bottom: scrollDivY + height
47  };
48 },
49 NeedScrollOnDrag: function(isHorzDrag) {
50  var helper = this.GetScrollHelper();
51  if(!helper || (isHorzDrag && !helper.HasHorzScroll()) || !isHorzDrag && !helper.HasVertScroll())
52   return false;
53  return ASPx.Browser.Firefox || helper.HasVertScroll();
54 },
55 OnMouseMove: function(e) {
56  var pos = this.isHorzDrag ? ASPx.Evt.GetEventX(e) : ASPx.Evt.GetEventY(e);
57  if(pos === this.savedPositions[this.isHorzDrag])
58   return;
59  var line = { 
60   start:  this.isHorzDrag ? this.rect.left  : this.rect.top,
61   end: this.isHorzDrag ? this.rect.right : this.rect.bottom
62  };
63  var isLeft = pos < line.start;
64  var diff = isLeft ? line.start - pos : pos - line.end;
65  if(diff <= 0) {
66   this.CancelScrolling();
67   return;
68  }
69  this.repeatScrollTimeout = diff < this.maxRepeatScrollTimeout ? this.maxRepeatScrollTimeout - diff : 1;
70  this.scrollInc = this.scrollingStep * (isLeft ? -1 : 1);
71  this.savedPositions[this.isHorzDrag] = pos;
72  this.StartScrolling(this.isHorzDrag);
73 },
74 StartScrolling: function() {
75  if(this.scrollingProcessing)
76   return;
77  this.scrollingProcessing = true;
78  this.scrollHandler = this.RepeatScrolling();
79 },
80 CancelDrag: function() {
81  if(this.mouseMoveHandler)
82   ASPx.Evt.DetachEventFromDocument("mousemove", this.mouseMoveHandler);
83  this.CancelScrolling();
84 },
85 CancelScrolling: function() {
86  this.scrollingProcessing = false;
87  this.scrollHandler = ASPx.Timer.ClearTimer(this.scrollHandler);
88 },
89 RepeatScrolling: function() {
90  var scrollableControl = this.GetScrollableControl();
91  if(this.isHorzDrag)
92   scrollableControl.scrollLeft += this.scrollInc;
93  else
94   scrollableControl.scrollTop += this.scrollInc;
95  return window.setTimeout(function() { this.scrollHandler = this.RepeatScrolling(); }.aspxBind(this), this.repeatScrollTimeout);
96 },
97 UpdateTargetPositionPostponed: function() {
98  if(!this.GetActiveTargets().length)
99   return;
100  this.updateTargetPositionTimerID = ASPx.Timer.ClearTimer(this.updateTargetPositionTimerID);
101  this.updateTargetPositionTimerID = window.setTimeout(function() { this.UpdateTargetPosition(); }.aspxBind(this), this.updateTargetPositionTimeout);
102 },
103 UpdateTargetPosition: function() { 
104  var targets = this.GetActiveTargets();
105  for(var i = 0; i < targets.length; i++)
106   targets[i].UpdatePosition();
107 },
108 OnHeaderTargetAllowed: function(targetElement, x, y) {
109  if(!this.rect)
110   return true;
111  var custWin = this.GetCustomizationWindowElement();
112  var inRect = x >= this.rect.left && x <= this.rect.right;
113  return inRect || custWin === targetElement;
114 },
115 UpdateScrollableControlsOnDrag: function(src) {
116  this.UpdateTargetPositionPostponed();
117  var helper = this.GetScrollHelper();
118  var contentScrollDiv = helper.GetScrollDiv(helper.GetContentTable());
119  if(contentScrollDiv === src && helper.HasVertScroll()) {
120   var scrollDivs = [ helper.GetScrollDiv(helper.GetHeaderTable()), helper.GetScrollDiv(helper.GetFooterTable()) ];
121   for(var i = 0; i < scrollDivs.length; i++)
122    if(scrollDivs[i])
123     scrollDivs[i].scrollLeft = src.scrollLeft;
124  }
125 }
126});

127var BatchEditApi = ASPx.CreateClass(null, {
128 constructor: function(owner) {
129  this.owner = owner;
130 },
131 GetHelper: function() { return this.owner.GetBatchEditHelper(); },
132 GetColumnIndex: function(column) {  },
133 CreateControlCellInfo: function(key, column) { },
134 SetCellValueCore: function(key, column, value, displayText, cancelCellHighlighting) {
135  var helper = this.GetHelper();
136  var columnIndex = this.GetColumnIndex(column);
137  if(!helper || columnIndex === null) 
138   return;
139  if(!helper.IsValidRecord(key) || !helper.IsEditableColumn(columnIndex))
140   return;
141  if(helper.IsEditingCell(key, columnIndex))
142   return;
143  if(!ASPx.IsExists(displayText))
144   displayText = helper.GetColumnDisplayTextByEditor(value, columnIndex);
145  if(helper.IsCheckColumn(columnIndex))
146   displayText = helper.GetCheckColumnDisplayText(value, columnIndex);
147  if(helper.IsColorEditColumn(columnIndex))
148   displayText = helper.GetColorEditColumnDisplayText(value, columnIndex);
149  helper.SetCellValue(key, columnIndex, value, displayText, cancelCellHighlighting);
150  helper.ResetCellValidationState(key, columnIndex);
151  helper.UpdateSyncInput(); 
152  helper.UpdateItem(key, [columnIndex], false, false, true);
153  helper.UpdateCommandButtonsEnabled();
154  helper.RemoveRecordErrorIfHasNoChanges(key);
155 },
156 GetColumnDisplayText: function(column, value) {
157  var helper = this.GetHelper();
158  var columnIndex = this.GetColumnIndex(column);
159  if(!helper || columnIndex === null) 
160   return;
161  return helper.GetColumnDisplayTextByEditor(value, columnIndex);
162 },
163 GetCellValueCore: function(key, column, initial) {
164  var helper = this.GetHelper();
165  var columnIndex = this.GetColumnIndex(column);
166  if(!helper || columnIndex === null) return;
167  return helper.GetCellValue(key, columnIndex, initial);
168 },
169 GetCellTextContainerCore: function(key, column) {
170  var helper = this.GetHelper();
171  var columnIndex = this.GetColumnIndex(column);
172  if(!helper || columnIndex === null) return;
173  return helper.GetCellTextContainer(key, columnIndex);
174 },
175 HasChangesCore: function(key, column) {
176  var helper = this.GetHelper();
177  if(!helper) return false;
178  var columnIndex = this.GetColumnIndex(column);
179  return helper.HasChanges(key, columnIndex);
180 },
181 ResetChangesCore: function(key, columnIndex) {
182  var helper = this.GetHelper();
183  if(!helper) return;
184  helper.ResetChanges(key, columnIndex);
185  helper.UpdateCommandButtonsEnabled();
186 },
187 StartEditCore: function(key, columnIndex) {
188  var helper = this.GetHelper();
189  if(!helper) return;
190  helper.StartEdit(key, columnIndex);
191 },
192 EndEdit: function() {
193  var helper = this.GetHelper();
194  if(!helper || helper.GetFocusHelper().lockUserEndEdit) 
195   return;
196  helper.EndEdit();
197 },
198 MoveFocusBackward: function() {
199  var helper = this.GetHelper();
200  if(!helper) return;
201  return helper.GetFocusHelper().MoveFocusPrev();
202 },
203 MoveFocusForward: function() {
204  var helper = this.GetHelper();
205  if(!helper) return;
206  return helper.GetFocusHelper().MoveFocusNext();
207 },
208 IsColumnEdited: function(column) {
209  var helper = this.GetHelper();
210  if(!helper || !column) return false;
211  return helper.IsColumnEdited(this.GetColumIndex(column));
212 },
213 ValidateItems: function(validateOnlyModified, validateOnCurrentPageOnly) {
214  var helper = this.GetHelper();
215  if(!helper) return false;
216  return !!helper.UserValidateItems(null, validateOnlyModified, validateOnCurrentPageOnly).isValid;
217 },
218 ValidateRecordCore: function(key) {
219  var helper = this.GetHelper();
220  if(!helper) return false;
221  return !!helper.UserValidateItems(key).isValid;
222 }, 
223 IsDeletedRecordCore: function(key) {
224  var helper = this.GetHelper();
225  return helper ? helper.IsDeletedRecord(key) : false;
226 },
227 IsNewRecordCore: function(key) {
228  var helper = this.GetHelper();
229  if(!helper) return false;
230  return helper.IsNewRecord(key);
231 },
232 GetEditCellInfo: function() {
233  var helper = this.GetHelper();
234  if(!helper || !helper.IsEditing()) 
235   return null;
236  var column = helper.GetFocusedColumn();  
237  if(column && !helper.IsColumnEditing(column.index))
238   column = null;
239  return this.CreateControlCellInfo(helper.GetEditingRecordKey(), column);
240 },
241 AddNewRecordCore: function(parentRecordKey) {
242  var helper = this.GetHelper();
243  if(helper)

244   helper.AddNewRecord(parentRecordKey);
245 },
246 DeleteRecordCore: function(key) {
247  var helper = this.GetHelper();
248  if(helper)
249   helper.DeleteItem(key);
250 },
251 RecoverRecordCore: function(key) {
252  var helper = this.GetHelper();
253  if(helper)
254   helper.RecoverRecord(key);
255 },
256 GetRecordKeys: function(includeDeleted) {
257  var helper = this.GetHelper();
258  if(!helper) return [ ];
259  return helper.GetRecordKeys(!includeDeleted);
260 },
261 GetInsertedRecordKeys: function() {
262  var helper = this.GetHelper();
263  if(!helper) return [ ];
264  var indices = helper.GetInsertedRecordKeys();
265  if(helper.IsNewItemOnTop())
266   indices.reverse();
267  return indices;
268 },
269 GetDeletedRecordKeys: function() {
270  var helper = this.GetHelper();
271  if(!helper) return [ ];
272  return helper.deletedItemKeys.slice();
273 },
274 GetUpdatedRecordKeys: function() {
275  var helper = this.GetHelper();
276  if(!helper) return [ ];
277  return ASPx.GetObjectKeys(helper.updatedValues);
278 },
279 GetUnsavedChanges: function() {
280  var helper = this.GetHelper();
281  if(!helper) return { };
282  return helper.GetChangedValuesInfo();
283 }
284});
285var GridStyleHelperBase = ASPx.CreateClass(null, {
286 ClearItemStyleKey: "items",
287 ErrorItemHtmlKey: "ei",
288 BatchEditCellKey: "bec",
289 BatchEditModifiedCellKey: "bemc",
290 BatchEditMergedModifiedCellKey: "bemergmc",
291 BatchEditDeletedItemKey: "bedi",
292 FocusedCellKey: "fc",
293 SelectedCellKey: "sc",
294 InitCellStyleKey: "initial",
295 AppliedBatchEditCellStylKey: "batchEdit",
296 AppliedFocusedCellStyleKey: "focused",
297 AppliedSelectedCellStyleKey: "selected",
298 GetStyles: function() { return null; },
299 GetStyleInfo: function(styleKey, columnIndex) {
300  var info = this.GetStyleInfoCore(styleKey, columnIndex);
301  if(info)
302   info.styleKey = styleKey;
303  return info;
304 },
305 GetStyleInfoCore: function(styleKey, keyPostFix) {
306  var styles = this.GetStyles();
307  if(!styles)
308   return null;
309  if(ASPx.IsExists(keyPostFix)) {
310   var key = styleKey + keyPostFix;
311   if(styles.hasOwnProperty(key))
312    return styles[key];
313  }
314  return styles[styleKey];
315 },
316 GetCellStyleKeys: function() {
317  var result = [];
318  result.push(this.AppliedBatchEditCellStylKey);
319  result.push(this.AppliedFocusedCellStyleKey);
320  result.push(this.AppliedSelectedCellStyleKey);
321  return result;
322 },
323 UpdateCellBatchEditStyle: function(style, cell) { this.UpdateCellStyle(this.AppliedBatchEditCellStylKey, style, cell); },
324 UpdateCellFocusedStyle: function(style, cell) { this.UpdateCellStyle(this.AppliedFocusedCellStyleKey, style, cell); },
325 UpdateCellSelectedStyle: function(style, cell) { this.UpdateCellStyle(this.AppliedSelectedCellStyleKey, style, cell); },
326 UpdateCellStyle: function(styleKey, style, cell) {
327  if(!cell) return;
328  this.EnsureCellStyles(cell);
329  cell.appliedStyles[styleKey] = this.GetCellStyleToApply(style);
330  this.ApplyCellStyles(cell);
331 },
332 EnsureCellStyles: function(cell) {
333  if(cell.appliedStyles)
334   return;
335  cell.appliedStyles = { }; 
336  cell.appliedStyles[this.InitCellStyleKey] = this.CreateEmptyCellStyle(cell.className, cell.style.cssText);
337  var keys = this.GetCellStyleKeys();
338  for(var i = 0; i < keys.length; i++)
339   cell.appliedStyles[keys[i]] = this.CreateEmptyCellStyle();
340 },
341 CreateEmptyCellStyle: function(className, cssText) {  
342  className = className || "";
343  cssText = cssText || "";
344  return { className: className, cssText: cssText};
345 },
346 GetCellStyleToApply: function(style) {
347  var result = this.CreateEmptyCellStyle();
348  if(style) {
349   result.className = style.className || "";
350   result.cssText = style.cssText || "";
351  }
352  return result;
353 },
354 ApplyCellStyles: function(cell) {
355  var className = "";
356  var cssText = "";
357  for(var key in cell.appliedStyles) {
358   if(!cell.appliedStyles.hasOwnProperty(key)) continue;
359   var style = cell.appliedStyles[key];
360   if(!style) continue;
361   if(style.className)
362    className += " " + style.className;
363   if(style.cssText)
364    cssText += ";" + style.cssText;
365  }
366  cell.className = className;
367  cell.style.cssText = cssText;
368 },
369 AddToBatchEditStyle: function(cell, styles, classNames) { this.AddToCellStyleCore(cell, this.Ap

369pliedBatchEditCellStylKey, styles, classNames); },
370 AddToInitialStyle: function(cell, styles, classNames) { this.AddToCellStyleCore(cell, this.InitCellStyleKey, styles, classNames); },
371 AddToCellStyleCore: function(cell, styleKey, styles, classNames) {
372  if((!styles && !classNames) || !cell) return;
373  this.EnsureCellStyles(cell);
374  var style = cell.appliedStyles[styleKey];
375  if(!style) return;
376  if(classNames)
377   style.className += " " + classNames.join(' ');
378  if(styles) {
379   var fakeCell = document.createElement("TD");
380   fakeCell.style.cssText = style.cssText || "";
381   for(var property in styles) {
382    if(styles.hasOwnProperty(property)) {
383     var value = styles[property];
384     fakeCell.style[property] = value + (typeof (value) == "number" ? "px" : "");
385    }
386   }   
387   style.cssText = fakeCell.style.cssText;
388  }  
389  this.ApplyCellStyles(cell);
390 },
391 ChangeCellInitialClass: function(cell, className, add, preventApply) {
392  if(!cell || !cell.appliedStyles)
393   return;
394  var hasClass = cell.appliedStyles.initial.className.indexOf(className) > -1;
395  if(hasClass && !add)

396    cell.appliedStyles.initial.className =  cell.appliedStyles.initial.className.replace(className, "");
397  if(!hasClass && add)
398    cell.appliedStyles.initial.className += " " + className;
399  if(!preventApply)
400   this.ApplyCellStyles(cell);
401 },
402 GetEmptyCellStyle: function() { return this.CreateEmptyCellStyle(); },
403 GetBatchEditCellStyle: function() { return this.GetStyleInfo(this.BatchEditCellKey); },
404 GetBatchEditModifiedCellStyle: function(columnIndex) { return this.GetStyleInfo(this.BatchEditModifiedCellKey, columnIndex); },
405 GetBatchEditMergedModifiedCellStyle: function() { return this.GetStyleInfo(this.BatchEditMergedModifiedCellKey); },
406 GetFocusedCellStyle: function(style) { return this.GetStyleInfo(this.FocusedCellKey); },
407 GetSelectedCellStyle: function(style) { return this.GetStyleInfo(this.SelectedCellKey); },
408 IsBatchEditCellStyle: function(style) { return this.CheckStyleInfoByKey(style, this.BatchEditCellKey); },
409 IsBatchEditModifiedCellStyle: function(style) { return this.CheckStyleInfoByKey(style, this.BatchEditModifiedCellKey); },
410 IsBatchEditMergedModifiedCellStyle: function(style) { return this.CheckStyleInfoByKey(style, this.BatchEditMergedModifiedCellKey); },
411 IsFocusedCellStyle: function(style) { return this.CheckStyleInfoByKey(style, this.FocusedCellKey); },
412 GetClearItemStyle: function() { return this.GetStyleInfo(this.ClearItemStyleKey); },
413 GetBatchEditDeletedItemStyle: function() { return this.GetStyleInfo(this.BatchEditDeletedItemKey); },
414 IsClearItemStyle: function(style) { return this.CheckStyleInfoByKey(style, this.ClearItemStyleKey); },   
415 IsBatchEditDeletedItemStyle: function(style) { return this.CheckStyleInfoByKey(style, this.BatchEditDeletedItemKey); },   
416 CheckStyleInfoByKey: function(styleInfo, key) {
417  if(!styleInfo)
418   return false;
419  return styleInfo.styleKey == key;
420 },
421 ApplyElementStyle: function(element, styleInfo, skipInitialStyle){
422  if(!element) return;
423  if(!skipInitialStyle) {
424   if(!ASPx.IsExists(element.initialClassName))
425    element.initialClassName = element.className;
426   if(!ASPx.IsExists(element.initialCssText))
427    element.initialCssText = element.style.cssText;
428   element.className = element.initialClassName;
429   element.style.cssText = element.initialCssText;
430  }
431  if(styleInfo) {
432   element.className += " " + styleInfo.className;
433   element.style.cssText += " " + styleInfo.cssText;
434  }
435 },
436 AddClassToElement: function(element, className){
437  if(!element) return;
438  ASPx.AddClassNameToElement(element, className);
439  this.ChangeElementInitialClass(element, className, true);
440 },
441 RemoveClassFromElement: function(element, className){
442  if(!element) return;
443  ASPx.RemoveClassNameFromElement(element, className);
444  this.ChangeElementInitialClass(element, className);
445 },
446 ChangeElementInitialClass: function(element, className, add) {
447  if(!element) return;
448  if(!ASPx.IsExists(element.initialClassName))
449   element.initialClassName = element.className;  
450  var hasClass = element.initialClassName.indexOf(className) > -1;
451  if(hasClass && !add)
452    element.initialClassName =  element.initialClassName.replace(className, "");
453  if(!hasClass && add)
454    element.initialClassName += " " + className;
455 },
456 AddStyleToElementInitialCssText: function(element, style) {
457  this.EnsureElementInitialCssTextFromServer(element);
458  var fakeElement = document.createElement("DIV");
459  for(var property in style) {
460   if(!style.hasOwnProperty(property)) continue;
461   var value = style[property];
462   fakeElement.style[property] = value + (typeof (value) === "number" ? "px" : "");
463  }  
464  element.initialCssText = element.initialCssTextFromServer + ";" + fakeElement.style.cssText;
465 },
466 ResetElementInitialCssText: function(element) {
467  if(element.initialCssTextFromServer)
468   element.initialCssText = element.initialCssTextFromServer;
469 },
470 EnsureElementInitialCssTextFromServer: function(element) {
471  if(!element.initialCssTextFromServer)
472   element.initialCssTextFromServer = element.initialCssText;
473 },
474 GetErrorItemHtml: function() {
475  var styles = this.GetStyles();
476  if(!styles)
477   return null;
478  return styles[this.ErrorItemHtmlKey];
479 }
480});
481var GridCommonUtils = {
482 BacthEditLockFocusEventsTriggerTimeout: 50,
483 NeedSaveActiveElement: function (control) { return ASPx.Browser.WindowsPhonePlatform && ASPx.Browser.Edge; },
484 IsBatchEditMode: function (control) { return control.GetBatchEditHelper && !!control.GetBatchEditHelper(); },
485 IsInput: function (element) {
486  if (!element) return false;
487  return element.tagName == "INPUT" || element.tagName == "TEXTAREA";
488 },
489 SaveActiveElement: function (control) {
490  if (!this.NeedSaveActiveElement(control)) return;
491  var activeElement = ASPx.GetActiveElement();
492  var isBatchEditing = this.IsBatchEditMode(control);
493  var isInput = this.IsInput(activeElement);
494  if (!activeElement || !isInput && !isBatchEditing || !ASPx.GetIsParent(control.GetMainElement(), activeElement))
495   return;
496  control.activeElementSettings = { activeElement: activeElement };
497  if (isInput)
498   control.activeElementSettings.selInfo = ASPx.Selection.GetInfo(activeElement);
499  if (isBatchEditing)
500   this.LockBatchEditFocusEvents(control);
501 },
502 RestoreActiveElement: function (control) {
503  var settings = control.activeElementSettings;
504  if (!settings) return;
505  var oldElement = settings.activeElement;
506  if (ASPx.IsExistsElement(oldElement) && oldElement !== ASPx.GetActiveElement()) {
507   oldElement.focus();
508   if (settings.selInfo)
509    ASPx.Selection.Set(oldElement, settings.selInfo.startPos, settings.selInfo.endPos);
510  }
511  delete control.activeElementSettings;
512  this.UnLockBatchEditFocusEvents(control);
513 },
514 LockBatchEditFocusEvents: function (control) { control.BatchEditFocusEventsLocked = true; },
515 UnLockBatchEditFocusEvents: function (control) {
516  ASPx.Timer.ClearTimer(control.bacthEditLockFocusEventsTriggerID);
517  if (control.BatchEditFocusEventsLocked)
518   control.bacthEditLockFocusEventsTriggerID = window.setTimeout(function () { delete control.BatchEditFocusEventsLocked; }, this.BacthEditLockFocusEventsTriggerTimeout);
519 },
520 IsBatchEditFocusEventsLocked: function (control) { return !!control.BatchEditFocusEventsLocked; }
521};
522ASPx.GridDragHelperBase = GridDragHelperBase;

523ASPx.BatchEditApi = BatchEditApi;
524ASPx.GridStyleHelperBase = GridStyleHelperBase;
525ASPx.GridCommonUtils = GridCommonUtils;
526})();
527
528},18);