https://check-inn.hu/DXR.axd?r=1_55-Zslkq

1(function () {
2 var CssClassesConstants = {};
3 CssClassesConstants.Prefix = "dxis-";
4 CssClassesConstants.OverlayElementCssClass = CssClassesConstants.Prefix + "overlayElement";
5 CssClassesConstants.TextAreaCssClassName = CssClassesConstants.Prefix + "itemTextArea";
6 CssClassesConstants.ImageAreaSlidePanelCssClassName = CssClassesConstants.Prefix + "slidePanel";
7 CssClassesConstants.NavigationBarHoverStateElementCssClassName = CssClassesConstants.Prefix + "nbHoverItem";
8 CssClassesConstants.NavigationBarSelectedStateCssClassName = " " + CssClassesConstants.Prefix + "selected";
9 CssClassesConstants.NavigationBarHoverStateCssClassName = CssClassesConstants.Prefix + "hover";
10 CssClassesConstants.NavigationBarSlidePanelCssClassName = CssClassesConstants.Prefix + "nbSlidePanel";
11 CssClassesConstants.NavigationBarSlidePanelWrapperCssClassName = CssClassesConstants.Prefix + "nbSlidePanelWrapper";
12 CssClassesConstants.PassePartoutCssClassName = CssClassesConstants.Prefix + "passePartout";
13 CssClassesConstants.ItemHyperLinkCssClassName = CssClassesConstants.Prefix + "hl";
14 CssClassesConstants.PlayPauseWrapperCssClassName = CssClassesConstants.Prefix + "playPauseBtnWrapper";
15 CssClassesConstants.NavigationButtonUpWrapperCssClassName = CssClassesConstants.Prefix + "prevBtnVertWrapper";
16 CssClassesConstants.NavigationButtonDownWrapperCssClassName = CssClassesConstants.Prefix + "nextBtnVertWrapper";
17 CssClassesConstants.NavigationButtonBackwardWrapperCssClassName = CssClassesConstants.Prefix + "prevBtnHorWrapper";
18 CssClassesConstants.NavigationButtonForwardWrapperCssClassName = CssClassesConstants.Prefix + "nextBtnHorWrapper";
19 CssClassesConstants.NavigationButtonUpOutsideWrapperCssClassName = CssClassesConstants.Prefix + "prevBtnVertOutsideWrapper";
20 CssClassesConstants.NavigationButtonDownOutsideWrapperCssClassName = CssClassesConstants.Prefix + "nextBtnVertOutsideWrapper";
21 CssClassesConstants.NavigationButtonBackwardOutsideWrapperCssClassName = CssClassesConstants.Prefix + "prevBtnHorOutsideWrapper";
22 CssClassesConstants.NavigationButtonForwardOutsideWrapperCssClassName = CssClassesConstants.Prefix + "nextBtnHorOutsideWrapper";
23 CssClassesConstants.NavigationButtonWrapperHoverCssClassPostfix = "Hover";
24 CssClassesConstants.NavigationButtonWrapperPressedCssClassPostfix = "Pressed";
25 CssClassesConstants.NavigationButtonWrapperDisabledCssClassPostfix = "Disabled";
26 CssClassesConstants.ImageZoomNavigatorCssClassName = CssClassesConstants.Prefix + "zoomNavigator";
27 CssClassesConstants.LoadingElement = "dx-is-loading";
28 var LoadModeEnum = {
29  AllImages: 0,
30  DynamicLoadAndCache: 1,
31  DynamicLoad: 2
32 };
33 var AnimationTypeEnum = {
34  Slide: 0,
35  Fade: 1,
36  None: 2
37 };
38 var AnimationDirectionEnum = {
39  Horizontal: 0,
40  Vertical: 1
41 };
42 var NavigationBarPositionEnum = {
43  Bottom: 0,
44  Top: 1,
45  Left: 2,
46  Right: 3
47 };
48 var NavigationBarModeEnum = {
49  Thumbnails: 0,
50  Dots: 1
51 };
52 var ElementVisibilityModeEnum = {
53  None: 0,
54  Faded: 1,
55  OnMouseOver: 2,
56  Always: 3
57 };
58 var NavigationBarPagingModeEnum = {
59  Page: 0,
60  Single: 1
61 };
62 var ExtremeItemClickModeEnum = {
63  SelectAndSlide: 0,
64  Select: 1
65 };
66 var NavigationBarButtonPositionEnum = {
67  Inside: 0,
68  Outside: 1
69 };
70 var ActiveItemChangeActionEnum = {
71  Click: 0,
72  Hover: 1
73 };
74 var NavigationButtonVisibilityModeEnum = {
75  Auto: 0,
76  Always: 1
77 };
78 var FadedDefaultOpacity = 0.3;
79 var SizeUtils = {
80  GetClientWidth: function (element, clear) {
81   return clear ? ASPx.GetClearClientWidth(element) : element.offsetWidth;
82  },
83  GetClientHeight: function (element, clear) {
84   return clear ? ASPx.GetClearClientHeight(element) : element.offsetHeight;
85  }
86 };
87 var MouseEnterHelper = {
88  data: [],
89  AddHandler: function (element, mouseOver, mouseOut) {
90   var dataItem = this.GetDataItem(element);
91   if(!dataItem)
92    dataItem = this.CreateDataItem(element, mouseOver, mouseOut);
93   dataItem.mouseOverHandlers.push(mouseOver);
94   dataItem.mouseOutHandlers.push(mouseOut);
95  },
96  GetDataItem: function (element) {
97   for(var i = 0; i < this.data.length; i++) {
98    var dataItem = this.data[i];
99    if(dataItem && dataItem.element == element)
100     return dataItem;
101   }
102   return null;
103  },

104  CreateDataItem: function (element, mouseOver, mouseOut) {
105   var dataItem = { element: element, mouseOverHandlers: [mouseOver], mouseOutHandlers: [mouseOut] };
106   this.data.push(dataItem);
107   ASPx.Evt.AttachMouseEnterToElement(element, MouseEnterHelper.OnMouseOverHandler, MouseEnterHelper.OnMouseOutHandler);
108   return dataItem;
109  },
110  OnMouseOverHandler: function (element) {
111   MouseEnterHelper.PerformHandlers(MouseEnterHelper.GetDataItem(element).mouseOverHandlers);
112  },
113  OnMouseOutHandler: function (element) {
114   MouseEnterHelper.PerformHandlers(MouseEnterHelper.GetDataItem(element).mouseOutHandlers);
115  },
116  PerformHandlers: function (array) {
117   for(var i = 0; i < array.length; i++)
118    array[i]();
119  }
120 };
121 var ControlBase = ASPx.CreateClass(ASPxClientImageControlBase, {
122  constructor: function (imageSlider) {
123   this.constructor.prototype.constructor.call(this, imageSlider);
124  },
125  AdjustControl: function () {
126   this.CalculateSize();
127  },
128  ResetControlStyle: function () {
129  },
130  CalculateSize: function () {
131  },
132  InitializeHandlers: function () {
133  },
134  IsAdjustedSize: function () {
135   return this.GetImageSlider().IsAdjusted();
136  },
137  GetImageSlider: function () {
138   return this.control;
139  },
140  GetClientControlName: function () {
141   return this.GetImageSlider().name;
142  },
143  IsHorizontalNavigation: function () {
144   return this.GetImageSlider().navDirection == AnimationDirectionEnum.Horizontal;
145  },
146  GetAnimationType: function () {
147   return this.GetImageSlider().GetAnimationType();
148  },
149  IsRtl: function (withoutHorizontalNavigation) {
150   var value = !!this.GetImageSlider().rtl;
151   if(!withoutHorizontalNavigation)
152    value = value && this.IsHorizontalNavigation();
153   return value;
154  },
155  CreateDiv: function () {
156   return document.createElement("DIV");
157  },
158  GetStateController: function () {
159   return typeof (ASPx.GetStateController) != "undefined" ? ASPx.GetStateController() : null;
160  },
161  PatchElementForMSTouch: function (element) {
162   if(ASPx.Browser.MSTouchUI)
163    element.className += " " + ASPx.TouchUIHelper.msTouchDraggableClassName;
164  }
165 });
166 var ButtonBase = ASPx.CreateClass(ControlBase, {
167  constructor: function (itemsOwner) {
168   this.itemsOwner = itemsOwner;
169   this.defaultOpacity = 0;
170   this.isLeftButtonPressed = false;
171   this.visibility = true;
172   this.constructor.prototype.constructor.call(this, itemsOwner.GetImageSlider());
173  },
174  Initialize: function () {
175   if(this.GetVisibilityMode() == ElementVisibilityModeEnum.Faded)
176    this.defaultOpacity = FadedDefaultOpacity;
177  },
178  GetOwner: function () {
179   return this.itemsOwner;
180  },
181  GetContainer: function () {
182   return this.GetOwner().GetButtonsContainer();
183  },
184  GetMouseUpElement: function () {
185   return this.GetContainer();
186  },
187  GetVisibilityMode: function () {
188   return 0;
189  },
190  CanHandle: function () {
191   return this.GetOwner().CanHandleButtons();
192  },
193  PrepareControlHierarchy: function () {
194   if(this.GetVisibilityMode() == ElementVisibilityModeEnum.Always)
195    return;
196   var elements = this.GetAnimationElements();
197   for(var i = 0; i < elements.length; i++) {
198    ASPx.SetStyles(elements[i], { opacity: this.defaultOpacity });
199    this.PatchElementForMSTouch(elements[i]);
200   }
201  },
202  InitializeHandlers: function () {
203   ASPx.Evt.AttachEventToElement(this.GetMouseUpElement(), ASPx.TouchUIHelper.touchMouseDownEventName, function (evt) {
204    this.isLeftButtonPressed = ASPx.Evt.IsLeftButtonPressed(evt);
205   }.aspxBind(this));
206   ASPx.Evt.AttachEventToElement(this.GetMouseUpElement(), ASPx.Browser.TouchUI ? ASPx.TouchUIHelper.touchMouseUpEventName : "click", function (evt) {
207    if(this.visibility && this.isLeftButtonPressed && this.CanHandle())
208     this.OnMouseUp(evt);
209   }.aspxBind(this));
210   if(!ASPx.Browser.TouchUI && this.GetVisibilityMode() != ElementVisibilityModeEnum.Always)
211    MouseEnterHelper.AddHandler(this.GetContainer(), function () { this.Appear(); }.aspxBind(this), function () { this.Disappear(); }.aspxBind(this));
212  },
213  OnMouseUp: function (evt) {
214  },
215  Appear: function () {
216   this.Animate(1);
217  },
218  Disappear: function () {
219   this.Animate(this.defaultOpacity);
220  },
221  GetAnimationElements: function () {
222   return [];
223  },
224  Animate: function (value) {
225   var elements = this.GetAnimationElements();

226   var hasAnimation = this.GetAnimationType() != AnimationTypeEnum.None;
227   for(var i = 0; i < elements.length; i++) {
228    if(hasAnimation)
229     ASPx.AnimationHelper.fadeTo(elements[i], { to: value });
230    else
231     ASPx.SetStyles(elements[i], { opacity: value });
232   }
233  },
234  SetInnerHtml: function (element, html) {
235   element.innerHTML = html;
236  }
237 });
238 var SlideShowButton = ASPx.CreateClass(ButtonBase, {
239  constructor: function (itemsOwner) {
240   this.wrapperElement = null;
241   this.playButton = null;
242   this.pauseButton = null;
243   this.itemsOwner = itemsOwner;
244   this.constructor.prototype.constructor.call(this, itemsOwner);
245  },
246  GetMouseUpElement: function () {
247   return this.wrapperElement;
248  },
249  GetAnimationElements: function () {
250   return [this.wrapperElement];
251  },
252  GetVisibilityMode: function () {
253   return this.GetImageSlider().playPauseBtnVbl;
254  },
255  CreateControlHierarchy: function () {
256   var slider = this.GetImageSlider();
257   this.wrapperElement = this.CreateDiv();
258   this.wrapperElement.innerHTML = slider.playBH + slider.pauseBH;
259   this.playButton = this.wrapperElement.children[0];
260   this.pauseButton = this.wrapperElement.children[1];
261   this.GetContainer().appendChild(this.wrapperElement);
262  },
263  PrepareControlHierarchy: function () {
264   ButtonBase.prototype.PrepareControlHierarchy.call(this);
265   this.wrapperElement.className = CssClassesConstants.PlayPauseWrapperCssClassName;
266   this.SetButtonState(true);
267  },
268  IsPlaying: function () {
269   return this.GetImageSlider().IsSlideShowPlaying();
270  },
271  OnMouseUp: function (evt) {
272   var slider = this.GetImageSlider();
273   if(this.IsPlaying())
274    slider.Pause();
275   else
276    slider.Play();
277  },
278  SetButtonState: function (play) {
279   ASPx.SetElementDisplay(this.playButton, play);
280   ASPx.SetElementDisplay(this.pauseButton, !play);
281  }
282 });
283 var NavigationButtons = ASPx.CreateClass(ButtonBase, {
284  constructor: function (itemsOwner) {
285   this.prevButtonEnable = true;
286   this.nextButtonEnable = true;
287   this.prevButton = null;
288   this.nextButton = null;
289   this.prevButtonWrapper = null;
290   this.nextButtonWrapper = null;
291   this.constructor.prototype.constructor.call(this, itemsOwner);
292  },
293  GetUniqueId: function () {
294   return this.GetOwner().GetUniqueId();
295  },
296  IsEnablePagingByClick: function () {
297   return this.GetOwner().IsEnablePagingByClick();
298  },
299  IsHorizontal: function () {
300   return this.GetOwner().IsHorizontalNavigation();
301  },
302  GetVisibilityMode: function () {
303   return this.GetOwner().GetNavigationBtnsVisibilityMode();
304  },
305  OnPrevButtonMouseUp: function (evt) {
306   if(this.prevButtonEnable)
307    this.GetOwner().PerformBackward();
308   return ASPx.Evt.PreventEvent(evt);
309  },
310  OnNextButtonMouseUp: function (evt) {
311   if(this.nextButtonEnable)
312    this.GetOwner().PerformForward();
313   return ASPx.Evt.PreventEvent(evt);
314  },
315  CreateControlHierarchy: function () {
316   this.prevButtonWrapper = this.CreateDiv();
317   this.nextButtonWrapper = this.CreateDiv();
318   this.SetInnerHtml(this.prevButtonWrapper, this.GetOwner().GetPrevButtonHtml());
319   this.SetInnerHtml(this.nextButtonWrapper, this.GetOwner().GetNextButtonHtml());
320   this.prevButton = this.prevButtonWrapper.firstChild;
321   this.nextButton = this.nextButtonWrapper.firstChild;
322   var container = this.GetContainer();
323   container.appendChild(this.prevButtonWrapper);
324   container.appendChild(this.nextButtonWrapper);
325  },
326  PrepareControlHierarchy: function () {
327   ButtonBase.prototype.PrepareControlHierarchy.call(this);
328   this.SetId(this.prevButtonWrapper, "nbwb");
329   this.SetId(this.nextButtonWrapper, "nbwf");
330   this.PrepareButtonWrapper(this.prevButtonWrapper, this.GetPrevButtonWrapperCssClassName());
331   this.PrepareButtonWrapper(this.nextButtonWrapper, this.GetNextButtonWrapperCssClassName());
332  },
333  GetPrevButtonWrapperCssClassName: function () {
334   return this.IsHorizontal() ?
335    CssClassesConstants.NavigationButtonBackwardWrapperCssClassName : CssClassesConstants.NavigationButtonUpWrapperCssClassName;
336  },
337  GetNextButtonWrapperCssClassName: function () {
338   return this.IsHorizontal() ?

339     CssClassesConstants.NavigationButtonForwardWrapperCssClassName : CssClassesConstants.NavigationButtonDownWrapperCssClassName;
340  },
341  PrepareButtonWrapper: function (wrapper, className) {
342   wrapper.className = className;
343   var stateController = this.GetStateController();
344   if(stateController) {
345    if(this.IsEnabled()) {
346     stateController.AddHoverItem(wrapper.id, [className + CssClassesConstants.NavigationButtonWrapperHoverCssClassPostfix], [""], [""], null, null, false);
347     stateController.AddPressedItem(wrapper.id, [className + CssClassesConstants.NavigationButtonWrapperPressedCssClassPostfix], [""], [""], null, null, false);
348    }
349    stateController.AddDisabledItem(wrapper.id, [className + CssClassesConstants.NavigationButtonWrapperDisabledCssClassPostfix], [""], [""], null, null, false);
350   }
351  },
352  SetId: function (element, id) {
353   element.id = this.GetClientControlName() + this.GetOwner().GetUniqueId() + id;
354  },
355  OnMouseUp: function (evt) {
356   var value = true;
357   var container = this.GetContainer();
358   var source = ASPx.Evt.GetEventSource(evt);
359   if(this.IsEnablePagingByClick() && !this.IsSlideShowButton(source) && !ASPx.IsInteractiveControl(source)) {
360    var containerSize = this.IsHorizontal() ? container.offsetWidth : container.offsetHeight;
361    var leftLimitPos = containerSize * 0.35,
362     rightLimitPos = containerSize * 0.65;
363    var mousePosInElement = this.IsHorizontal() ? ASPx.Evt.GetEventX(evt) - ASPx.GetAbsolutePositionX(container) : ASPx.Evt.GetEventY(evt) - ASPx.GetAbsolutePositionY(container);
364    if(mousePosInElement < leftLimitPos)
365     value = this.OnPrevButtonMouseUp(evt);
366    else if(mousePosInElement > rightLimitPos)
367     value = this.OnNextButtonMouseUp(evt);
368   }
369   else {
370    if(source == this.prevButtonWrapper || source == this.prevButton)
371     value = this.OnPrevButtonMouseUp(evt);
372    else if(source == this.nextButtonWrapper || source == this.nextButton)
373     value = this.OnNextButtonMouseUp(evt);
374   }
375   return value;
376  },
377  IsSlideShowButton: function (element) {
378   var className = CssClassesConstants.PlayPauseWrapperCssClassName;
379   return element.className == className || element.parentNode.className == className;
380  },
381  SetEnablePrevButton: function (enable) {
382   this.prevButtonEnable = enable;
383   var stateController = this.GetStateController();
384   if(stateController) {
385    stateController.SetElementEnabled(this.prevButtonWrapper, enable);
386    stateController.SetElementEnabled(this.prevButton, enable);
387   }
388  },
389  SetEnableNextButton: function (enable) {
390   this.nextButtonEnable = enable;
391   var stateController = this.GetStateController();
392   if(stateController) {
393    stateController.SetElementEnabled(this.nextButtonWrapper, enable);
394    stateController.SetElementEnabled(this.nextButton, enable);
395   }
396  },
397  SetVisibilityButtons: function (visible) {
398   if(this.visibility == visible)
399    return;
400   this.visibility = visible;
401   ASPx.SetElementDisplay(this.prevButtonWrapper, this.visibility);
402   ASPx.SetElementDisplay(this.nextButtonWrapper, this.visibility);
403  },
404  GetVisibilityButtons: function () {
405   return this.visibility;
406  },
407  GetAnimationElements: function () {
408   return [this.prevButtonWrapper, this.nextButtonWrapper];
409  },
410  GetPrevButtonWrapperSize: function () {
411   return this.GetButtonSize(this.prevButtonWrapper);
412  },
413  GetNextButtonWrapperSize: function () {
414   return this.GetButtonSize(this.nextButtonWrapper);
415  },
416  GetButtonSize: function (element) {
417   return { width: element.offsetWidth, height: element.offsetHeight };
418  }
419 });
420 var OutsideNavigationButtons = ASPx.CreateClass(NavigationButtons, {
421  constructor: function (itemsOwner) {
422   this.constructor.prototype.constructor.call(this, itemsOwner);
423  },
424  GetAnimationElements: function () {
425   return [];
426  },
427  GetPrevButtonWrapperCssClassName: function () {
428   return this.IsHorizontal() ?
429    CssClassesConstants.NavigationButtonBackwardOutsideWrapperCssClassName : CssClassesConstants.NavigationButtonUpOutsideWrapperCssClassName;
430  },
431  GetNextButtonWrapperCssClassName: function () {
432   return this.IsHorizontal() ?

433     CssClassesConstants.NavigationButtonForwardOutsideWrapperCssClassName : CssClassesConstants.NavigationButtonDownOutsideWrapperCssClassName;
434  }
435 });
436 var ItemsOwnerBase = ASPx.CreateClass(ControlBase, {
437  constructor: function (imageSlider) {
438   this.activeItemIndex = 0;
439   this.prevItemIndex = -1;
440   this.fullItemWidth = 0;
441   this.fullItemHeight = 0;
442   this.clearItemWidth = 0;
443   this.clearItemHeight = 0;
444   this.itemElementsManager = null; 
445   this.navigationButtons = null; 
446   this.slidePanelElement = null;
447   this.constructor.prototype.constructor.call(this, imageSlider);
448  },
449  Initialize: function () {
450   this.activeItemIndex = this.GetRtlIndex(this.GetImageSlider().activeItemIndex);
451   if(this.IsRtl())
452    this.prevItemIndex = this.activeItemIndex + 1;
453  },
454  GetRtlIndex: function (index) {
455   if(this.IsRtl())
456    return this.GetItemCount() - 1 - index;
457   return index;
458  },
459  ForEachItem: function (func) {
460   var count = this.GetItemCount();
461   if(!this.IsRtl()) {
462    for(var i = 0; i < count ; i++)
463     func.call(this, i);
464   }
465   else {
466    for(var i = count - 1; i >= 0; i--)
467     func.call(this, i);
468   }
469  },
470  GetUniqueId: function () {
471   return "";
472  },
473  IsAccessibilityCompliant: function () {
474   return this.GetImageSlider().accessibilityCompliant;
475  },
476  GetItemElementsManager: function () {
477   if(!this.itemElementsManager)
478    this.itemElementsManager = this.CreateItemElementsManager();
479   return this.itemElementsManager;
480  },
481  CreateItemElementsManager: function () {
482   return new ItemElementsManagerBase(this);
483  },
484  GetTemplate: function (index) {
485   return this.IsValidItemIndex(index) ? this.GetItem(index).tpl : null;
486  },
487  GetNavigateUrl: function (index) {
488   return this.IsValidItemIndex(index) ? this.GetItem(index).u : null;
489  },
490  GetImageSrc: function (index) {
491   return this.IsValidItemIndex(index) ? this.GetItem(index).s : null;
492  },
493  GetItemAlternateText: function (index) {
494   if(this.IsValidItemIndex(index)) {
495    var item = this.GetItem(index);
496    return item.t || item.at || "";
497   }
498   return "";
499  },
500  GetItem: function (index) {
501   return this.GetImageSlider().GetItemInternal(this.GetRtlIndex(index));
502  },
503  GetItemCount: function () {
504   return this.GetImageSlider().GetItemCount();
505  },
506  SetActiveItemIndex: function (index, preventAnimation) {
507   if(!this.IsEnabled() || !this.IsValidItemIndex(index) || index == this.GetActiveItemIndex())
508    return;
509   this.prevItemIndex = this.GetActiveItemIndex();
510   this.activeItemIndex = index;

511   this.SetActiveItemIndexInternal(index, preventAnimation);
512   this.EnsureShownItemsLoaded();
513  },
514  SetActiveItemIndexInternal: function (index, preventAnimation) {
515   this.UpdateNavigationButtonsState();
516  },
517  GetActiveItemIndex: function () {
518   return this.activeItemIndex;
519  },
520  GetPrevItemIndex: function () {
521   return this.prevItemIndex;
522  },
523  EnsureShownItemsLoaded: function() {
524   this.GetImageSlider().EnsureShownItemsLoaded();
525  },
526  GetItemElement: function (index) {
527   return this.IsValidItemIndex(index) ? this.GetItemElementsManager().GetCollection()[index] : null;
528  },
529  GetImageElement: function (index) {
530   return ASPx.GetChildByTagName(this.GetItemElement(index), "IMG");
531  },
532  GetCanvasElement: function (index) {
533   return ASPx.GetChildByTagName(this.GetItemElement(index), "CANVAS");
534  },
535  GetHyperLinkElement: function (index) {
536   return ASPx.GetChildByClassName(this.GetItemElement(index), CssClassesConstants.ItemHyperLinkCssClassName);
537  },
538  GetImageContainerElement: function (index) {
539   return this.GetHyperLinkElement(index) || this.GetItemElement(index);
540  },
541  GetItemElementSize: function (clear) {
542   return this.IsHorizontalNavigation() ? this.GetItemElementWidth(clear) : this.GetItemElementHeight(clear);
543  },
544  GetItemElementWidth: function (clear) {
545   return clear ? this.clearItemWidth : this.fullItemWidth;
546  },
547  GetItemElementHeight: function (clear) {
548   return clear ? this.clearItemHeight : this.fullItemHeight;
549  },
550  GetSlidePanelElement: function () {
551   return this.slidePanelElement;
552  },
553  GetItemsContainer: function () {
554   return null;
555  },
556  StopPlayingWhenPaging: function () {
557   this.GetImageSlider().StopPlayingWhenPaging();
558  },
559  CanCreateNavigationButtons: function () {
560   return true;
561  },
562  CreateNavigationButtons: function () {
563   if(this.GetNavigationBtnsVisibilityMode() == ElementVisibilityModeEnum.None)
564    return null;
565   return new NavigationButtons(this);
566  },
567  GetNavigationBtnsVisibilityMode: function () {
568   return this.GetImageSlider().navBtnsVbl;
569  },
570  UpdateNavigationButtonsState: function () {
571   return false;
572  },
573  GetButtonsContainer: function () {
574   return null;
575  },
576  GetPrevButtonHtml: function () {
577   return "";
578  },
579  GetNextButtonHtml: function () {
580   return "";
581  },
582  CanHandleButtons: function () {
583   return !this.IsExecutedGesture();
584  },
585  IsExecutedGesture: function () {
586   return ASPx.GesturesHelper.IsExecutedGesture();
587  },
588  IsEnablePagingByClick: function () {
589   return false;
590  },
591  SetEnablePrevButton: function (enabled) {
592   if(this.navigationButtons)
593    this.navigationButtons.SetEnablePrevButton(enabled);
594  },
595  SetEnableNextButton: function (enabled) {
596   if(this.navigationButtons)
597    this.navigationButtons.SetEnableNextButton(enabled);
598  },
599  SetVisibilityButtons: function (visible) {
600   if(this.navigationButtons)
601    this.navigationButtons.SetVisibilityButtons(visible);
602  },
603  PerformBackward: function () {
604  },
605  PerformForward: function () {
606  },
607  PerformRollBack: function () {
608  },
609  GetEnableLoopNavigation: function () {
610   return false;
611  },
612  GetImageLoadMode: function () {
613   return this.GetImageSlider().imageLoadMode;
614  },
615  UpdateItemElementsIfRequired: function () {
616   this.GetItemElementsManager().UpdateHierarchyIfRequired();
617  },
618  UpdateItemElementsAfterDelayIfRequired: function () {
619   this.GetItemElementsManager().UpdateHierarchyAfterDelayIfRequired();
620  },
621  IsNeedCreateHyperLink: function () {
622   return true;
623  },
624  GetTarget: function () {
625   return this.GetImageSlider().target;
626  },
627  CreateTemplates: function () {
628   this.ForEachItem(function (i) {
629    this.CreateTemplate(i);
630   });
631  },
632  CreateTemplate: function(index) {
633   var template = this.GetTemplate(index);
634   if(template) {
635    var itemElement = this.GetItemElement(index);
636    if(!itemElement)
637     return;
638    var child = itemElement.firstChild ? itemElement.firstChild.cloneNode(true) : null;
639    itemElement.innerHTML = template;
640    if(child)
641     itemElement.appendChild(child);
642    ASPx.ImageControlUtils.RemoveLoadingGif(itemElement);
643   }
644  },
645  CreateControlHierarchy: function () {
646   this.CreateControlHierarchyInternal();
647   if(this.CanCreateNavigationButtons())
648    this.navigationButtons = this.CreateNavigationButtons();
649   this.GetItemElementsManager().CreateItemsIfRequired();
650  },
651  CreateControlHierarchyInternal: function () {
652  },
653  CreateItemElements: function () {
654   this.ForEachItem(function (i) {
655    this.GetItemsContainer().appendChild(this.CreateItemElement(i));
656   });
657  },
658  CreateItemElement: function (index) {
659   var itemElement = this.CreateDiv();
660   if(!this.GetTemplate(index)) {
661    var hyperLinkElement = this.CreateHyperLinkElement(index);
662    if(hyperLinkElement)
663     itemElement.appendChild(hyperLinkElement);
664   }
665   return itemElement;
666  },
667  CreateImageElement: function (index) {
668   var image = new Image();
669   ASPx.SetElementDisplay(image, false);
670   this.AttachLoadEvent(image);
671   this.GetImageContainerElement(index).appendChild(image);
672   image.dxIndex = index;
673   image.dxImageSlider = this;
674   image.src = this.GetImageSrc(index);
675   image.alt = this.IsAccessibilityCompliant() ? this.GetItemAlternateText(index) : "";
676   return image;
677  },
678  CreateHyperLinkElement: function (index) {
679   var url = this.GetNavigateUrl(index);
680   if(!this.IsNeedCreateHyperLink() || !url)
681    return null;
682   var element = document.createElement("A");
683   element.target = this.GetTarget();

684   element.className = CssClassesConstants.ItemHyperLinkCssClassName;
685   element.href = url;
686   return element;
687  },
688  PrepareControlHierarchy: function () {
689   this.GetItemElementsManager().PrepareItemsIfRequired();
690  },
691  PrepareItemElements: function () {
692   this.ForEachItem(function (i) {
693    this.PrepareItemElement(i);
694   });
695  },
696  PrepareItemElement: function (index) {
697   var itemElement = this.GetItemElement(index);
698   ASPx.SetStyles(itemElement, {
699    className: this.GetItemElementCssClass(),
700    cssText: this.GetItemElementStyle()
701   });
702   if(this.GetTemplate(index))
703    ASPx.ImageControlUtils.RemoveLoadingGif(itemElement);
704  },
705  AdjustControl: function () {
706   ControlBase.prototype.AdjustControl.call(this);
707   if(this.navigationButtons)
708    this.navigationButtons.AdjustControl();
709   this.AdjustControlInternal();
710   this.SetActiveItemIndexInternal(this.GetActiveItemIndex(), true);
711  },
712  AdjustControlInternal: function () {
713   this.AdjustItemElements();
714  },
715  AdjustItemElements: function () {
716   this.GetItemElementsManager().AdjustItemsIfRequired();
717  },
718  CalculateSize: function () {
719   var fakeElement = this.CreateDiv();
720   ASPx.SetStyles(fakeElement, {
721    className: this.GetItemElementCssClass(),
722    cssText: this.GetItemElementStyle()
723   });
724   this.CalculateItemElementSize(fakeElement);
725   ASPx.RemoveElement(fakeElement);
726  },
727  CalculateItemElementSize: function (element) {
728  },
729  AdjustItemElement: function (index) {
730   ASPx.SetStyles(this.GetItemElement(index), {
731    width: this.GetItemElementWidth(true),
732    height: this.GetItemElementHeight(true)
733   });
734  },
735  AdjustImageElement: function (index) {
736   if(this.GetTemplate(index) || !this.GetImageSrc(index))
737    return;
738   var image = this.GetImageElement(index);
739   if(!image)
740    image = this.CreateImageElement(index);
741   else if(ASPx.ImageControlUtils.IsImageLoaded(image))
742    this.ResizeImage(image, index);
743  },
744  UpdateItemElement: function(index) {
745   if(this.GetImageContainerElement(index))
746    this.AdjustImageElement(index);
747   if(this.GetImageSlider().HasTemplates())
748    this.CreateTemplate(index);
749  },
750  GetItemElementCssClass: function () {
751   return "";
752  },
753  GetItemElementStyle: function () {
754   return "";
755  },
756  ResizeImage: function (image, index) {
757   ASPx.ImageControlUtils.ResizeImage(image, {
758    width: this.GetItemElementWidth(true),
759    height: this.GetItemElementHeight(true),
760    sizeMode: this.GetImageSizeMode(),
761    rtl: this.IsRtl(true),
762    onEndResize: function(element, isCanvas) {
763     if(isCanvas)
764      this.PrepareCanvasElement(index);
765    }.aspxBind(this),
766    canUseCanvas: !this.IsAccessibilityCompliant()
767   });
768  },
769  PrepareCanvasElement: function (index) {
770  },
771  GetImageSizeMode: function () {
772   return this.GetImageSlider().imageSizeMode;
773  },
774  GetSwipeGestureElement: function () {
775   return this.GetSlidePanelElement();
776  },
777  CanCreateSwipeGestureHandler: function () {
778   return false;
779  },
780  CreateSwipeGestureHandler: function () {
781   ASPx.GesturesHelper.AddSwipeSlideGestureHandler(
782    this.GetClientControlName() + this.GetUniqueId(),
783    function () { return this.GetSwipeGestureElement(); }.aspxBind(this),
784    this.IsHorizontalNavigation() ? ASPx.AnimationHelper.SLIDE_HORIZONTAL_DIRECTION : ASPx.AnimationHelper.SLIDE_VERTICAL_DIRECTION,
785    function (evt) { return this.CanHandleSwipeGesture(evt); }.aspxBind(this),
786    function () { this.PerformBackward(); }.aspxBind(this),
787    function () { this.PerformForward(); }.aspxBind(this),
788    function () { this.PerformRollBack(); }.aspxBind(this)
789   );
790  },
791  CanHandleSwipeGesture: function (evt) {
792   return !!ASPx.GetIsParent(this.GetSwipeGestureElement(), ASPx.Evt.GetEventSource(evt));
793  },
794  InitializeHandlers: function () {
795   if(this.GetImageSlider().allowMouseWheel && !(ASPx.Browser.Edge && ASPx.Browser.MSTouchUI))
796    ASPx.Evt.AttachEventToElement(this.GetItemsContainer(), ASPx.Evt.GetMouseWheelEventName(), function (evt) { this.OnMouseWheel(evt); }.aspxBind(this));
797   if(this.CanCreateSwipeGestureHandler() && this.GetImageSlider().enablePagingGestures)
798    this.CreateSwipeGestureHandler();
799  },
800  AttachLoadEvent: function (image) {
801   ASPx.Evt.AttachEventToElement(image, "load", _onImageLoad);
802  },
803  DetachLoadEvents: function (image) {
804   ASPx.Evt.DetachEventFromElement(image, "load", _onImageLoad);
805  },
806  OnMouseWheel: function (evt) {
807   if(!this.IsFocused())
808    return;
809   if(ASPx.Evt.GetWheelDelta(evt) > 0)
810    this.PerformBackward();
811   else
812    this.PerformForward();
813   return ASPx.Evt.PreventEvent(evt);
814  },
815  OnImageLoad: function (image) {
816   this.InitializeImage(image);
817   this.ResizeImage(image, image.dxIndex);
818   ASPx.ImageControlUtils.RemoveLoadingGif(this.GetItemElement(image.dxIndex));
819  },
820  InitializeImage: function (image) {

821   if(image.naturalWidth && image.naturalHeight)
822    return;
823   image.naturalWidth = image.width;
824   image.naturalHeight = image.height;
825  },
826  GetElementTransformPosition: function (element) {
827   return ASPx.AnimationUtils.GetTransformValue(element, !this.IsHorizontalNavigation());
828  },
829  SetElementTransformPosition: function (element, position) {
830   ASPx.AnimationUtils.SetTransformValue(element, position, !this.IsHorizontalNavigation());
831  },
832  GetWidth: function () {
833   return 0;
834  },
835  GetHeight: function () {
836   return 0;
837  },
838  IsFocused: function () {
839   return this.GetImageSlider().IsFocused();
840  },
841  CreateDocumentFragment: function () {
842   var fragment = null;
843   if(document.createDocumentFragment)
844    fragment = document.createDocumentFragment();
845   return fragment;
846  },
847  IsValidItemIndex: function (index) {
848   if(index >= 0 && index < this.GetItemCount())
849    return true;
850   return false;
851  }
852 });
853 function _onImageLoad(evt) {
854  var image = evt.srcElement || this;
855  if(!image.dxImageSlider)
856   return;
857  var imageSlider = image.dxImageSlider;
858  imageSlider.DetachLoadEvents(image);
859  if(!image.parentNode) return;
860  imageSlider.OnImageLoad(image);
861 }
862 var ImageAreaStrategy = ASPx.CreateClass(ItemsOwnerBase, {
863  constructor: function (imageSlider) {
864   this.currentItemTextElementOpacity = 0;
865   this.defaultItemTextElementOpacity = 0;
866   this.touchDeviceElementsVisible = false;
867   this.imageAreaStyleSize = { width: "", height: "" };
868   this.imageAreaElement = null;
869   this.slideShowButton = null; 
870   this.overlayLinkElement = null;
871   this.overlayImageElement = null;
872   this.constructor.prototype.constructor.call(this, imageSlider);
873  },
874  Initialize: function () {
875   ItemsOwnerBase.prototype.Initialize.call(this);
876   if(this.GetItemTextVisibilityMode() == ElementVisibilityModeEnum.Faded)
877    this.defaultItemTextElementOpacity = FadedDefaultOpacity;
878   else if(ASPx.Browser.Firefox)
879    this.defaultItemTextElementOpacity = 0.01; 
880   this.currentItemTextElementOpacity = this.defaultItemTextElementOpacity;
881  },
882  GetUniqueId: function () {
883   return "_ia_";
884  },
885  CreateItemElementsManager: function () {
886   return new ImageAreaItemElementsManager(this);
887  },
888  GetTextTemplate: function (index) {
889   return this.IsValidItemIndex(index) ? this.GetItem(index).ttpl : null;
890  },
891  GetItemText: function (index) {
892   return this.IsValidItemIndex(index) ? this.GetItem(index).t : null;
893  },
894  SetSlideShowButtonState: function (play) {
895   if(this.slideShowButton)
896    this.slideShowButton.SetButtonState(play);
897  },
898  IsEnablePagingByClick: function () {
899   return this.GetImageSlider().enablePagingByClick;
900  },
901  GetButtonsContainer: function () {
902   return this.GetImageSlider().GetPassePartoutElement();
903  },
904  GetPrevButtonHtml: function () {
905   return this.GetImageSlider().pbh;
906  },
907  GetNextButtonHtml: function () {
908   return this.GetImageSlider().nbh;
909  },
910  UpdateNavigationButtonsState: function () {
911   if(this.navigationButtons) {
912    if(this.GetItemCount() == 1)
913     this.SetVisibilityButtons(false);
914    else {
915     var currentItemIndex = this.GetActiveItemIndex();
916     this.SetEnablePrevButton(currentItemIndex != 0);
917     this.SetEnableNextButton(currentItemIndex != this.GetItemCount() - 1);
918    }
919   }
920   return false;
921  },
922  PerformBackward: function () {
923   this.StopPlayingWhenPaging();
924   var index = this.GetActiveItemIndex();
925   index--;
926   if(index < 0 && this.GetEnableLoopNavigation())
927    index = this.GetItemCount() - 1;
928   this.GetImageSlider().SetActiveItemIndexInternal(index);
929  },
930  PerformForward: function () {
931   this.StopPlayingWhenPaging();
932   var index = this.GetActiveItemIndex();
933   index++;
934   if(index == this.GetItemCount() && this.GetEnableLoopNavigation())
935    index = 0;
936   this.GetImageSlider().SetActiveItemIndexInternal(index);
937  },
938  PerformRollBack: function () {

939   this.SetActiveItemIndexInternal(this.GetActiveItemIndex(), false);
940  },
941  CreateControlHierarchy: function () {
942   ItemsOwnerBase.prototype.CreateControlHierarchy.call(this);
943   this.CreateOverlayElements();
944  },
945  CreateTemplate: function(index) {
946   ItemsOwnerBase.prototype.CreateTemplate.call(this, index);
947   var template = this.GetTextTemplate(index);
948   if(template) {
949    var itemTextElement = this.GetItemTextElement(index);
950    if(itemTextElement)
951     itemTextElement.innerHTML = template;
952   }
953  },
954  CreateControlHierarchyInternal: function () {
955   ItemsOwnerBase.prototype.CreateControlHierarchyInternal.call(this);
956   this.CreateImageAreaElement();
957   this.CreateSlideShowButton();
958  },
959  CreateImageAreaElement: function () {
960   this.imageAreaElement = document.createElement("DIV");
961   this.GetImageSlider().GetPassePartoutElement().appendChild(this.imageAreaElement);
962  },
963  CreateSlideShowButton: function () {
964   if(this.GetImageSlider().playPauseBtnVbl != ElementVisibilityModeEnum.None)
965    this.slideShowButton = new SlideShowButton(this);
966  },
967  CreateOverlayElements: function () {
968   var itemsContainer = this.GetItemsContainer();
969   if(!itemsContainer)
970    return;
971   if(this.GetImageSlider().HasNavigateUrls()) {
972    this.overlayLinkElement = document.createElement("A");
973    itemsContainer.insertBefore(this.overlayLinkElement, itemsContainer.firstChild);
974    this.overlayLinkElement.className = CssClassesConstants.OverlayElementCssClass;
975    this.overlayLinkElement.target = this.GetTarget();
976   }
977   this.overlayImageElement = document.createElement("IMG");
978   this.overlayImageElement.src = ASPx.EmptyImageUrl;
979   this.overlayImageElement.alt = "";
980   if(this.overlayLinkElement)
981    this.overlayLinkElement.appendChild(this.overlayImageElement);
982   else {
983    this.overlayImageElement.className = CssClassesConstants.OverlayElementCssClass;
984    itemsContainer.insertBefore(this.overlayImageElement, itemsContainer.firstChild);
985   }
986  },
987  UpdateOverlayParameters: function () {
988   var activeItemIndex = this.GetActiveItemIndex();
989   var currentItem = this.GetItem(activeItemIndex);
990   if(this.overlayLinkElement) {
991    if(!currentItem.u)
992     this.overlayLinkElement.removeAttribute("href");
993    else if(this.overlayLinkElement.href != currentItem.u)
994     this.overlayLinkElement.href = currentItem.u;
995   }
996   if(this.overlayImageElement) {
997    if(currentItem.s)
998     this.overlayImageElement.src = currentItem.s;
999    if(currentItem.tpl)
1000     this.overlayImageElement.style.display = "none";
1001    else {
1002     this.overlayImageElement.style.display = "";
1003     this.overlayImageElement.alt = this.IsAccessibilityCompliant() ? this.GetItemAlternateText(activeItemIndex) : "";
1004    }
1005   }
1006  },
1007  PrepareControlHierarchy: function () {
1008   ItemsOwnerBase.prototype.PrepareControlHierarchy.call(this);
1009   this.UpdateOverlayParameters();
1010   var imageAreaElement = this.GetImageAreaElement();
1011   ASPx.SetStyles(imageAreaElement, {
1012    className: this.GetImageSlider().imgAreaCssCl,
1013    cssText: this.GetImageSlider().imgAreaStyle
1014   });
1015   this.imageAreaStyleSize = {
1016    width: imageAreaElement.style.width,
1017    height: imageAreaElement.style.height
1018   };
1019   this.GetItemsContainer().style.zIndex = "0";
1020  },
1021  AdjustControl: function (width, height) {
1022   this.AdjustImageAreaElement(width, height);
1023   ItemsOwnerBase.prototype.AdjustControl.call(this);
1024  },
1025  AdjustImageAreaElement: function (width, height) {
1026   var imageAreaElement = this.GetImageAreaElement();
1027   if(!imageAreaElement.style.width) {
1028    ASPx.SetStyles(imageAreaElement, { width: width });
1029    if(imageAreaElement.offsetWidth > width)
1030     ASPx.SetStyles(imageAreaElement, { width: width - (imageAreaElement.offsetWidth - width) });
1031   }
1032   if(!imageAreaElement.style.height) {
1033    ASPx.SetStyles(imageAreaElement, { height: height });
1034    if(imageAreaElement.offsetHeight > height)
1035     ASPx.SetStyles(imageAreaElement, { height: height - (imageAreaElement.offsetHeight - height) });
1036   }
1037   if(imageAreaElement.offsetHeight < height)
1038    ASPx.SetStyles(imageAreaElement, { top: (height - imageAreaElement.offsetHeight) / 2 });
1039  },
1040  ResetControlStyle: function () {
1041   var imageAreaElement = this.GetImageAreaElement();
1042   ASPx.SetStyles(imageAreaElement, this.imageAreaStyleSize);
1043   ASPx.SetStyles(imageAreaElement, { top: 0 });
1044  },
1045  IsNeedCreateHyperLink: function () {
1046   return false;
1047  },
1048  SetActiveItemIndexInternal: function (index, preventAnimation) {
1049   ItemsOwnerBase.prototype.SetActiveItemIndexInternal.call(this, index, preventAnimation);
1050   this.UpdateOverlayParameters();
1051  },
1052  CalculateItemElementSize: function (fakeElement) {
1053   var imageArea = this.GetImageAreaElement();
1054   imageArea.appendChild(fakeElement);
1055   this.fullItemWidth = SizeUtils.GetClientWidth(imageArea, true);
1056   this.fullItemHeight = SizeUtils.GetClientHeight(imageArea, true);
1057   ASPx.SetStyles(fakeElement, {
1058    width: this.fullItemWidth,
1059    height: this.fullItemHeight
1060   });
1061   this.clearItemWidth = this.fullItemWidth - (SizeUtils.GetClientWidth(fakeElement) - this.fullItemWidth);

1062   this.clearItemHeight = this.fullItemHeight - (SizeUtils.GetClientHeight(fakeElement) - this.fullItemHeight);
1063  },
1064  CreateItemElement: function (index) {
1065   var itemElement = ItemsOwnerBase.prototype.CreateItemElement.call(this, index);
1066   var textElement = this.CreateItemTextElement(index);
1067   if(!textElement)
1068    return itemElement;
1069   itemElement.appendChild(textElement);
1070   return itemElement;
1071  },
1072  CreateItemTextElement: function (index) {
1073   var text = this.GetItemText(index);
1074   var textTemplate = this.GetTextTemplate(index);
1075   if(this.GetItemTextVisibilityMode() == ElementVisibilityModeEnum.None || (!text && !textTemplate))
1076    return null;
1077   var itemTextElement = this.CreateDiv();
1078   if(!textTemplate)
1079    itemTextElement.innerHTML = text;
1080   ASPx.SetStyles(itemTextElement, { className: this.GetImageSlider().itemTxtCssCl });
1081   return itemTextElement;
1082  },
1083  PrepareItemTextElement: function (index) {
1084   var itemTextElement = this.GetItemTextElement(index);
1085   if(itemTextElement) {
1086    var style = { cssText: this.GetImageSlider().itemTxtStyle, zIndex: 2, className: itemTextElement.className + " dx-wbv" };
1087    if(this.GetItemTextVisibilityMode() != ElementVisibilityModeEnum.Always)
1088     style.opacity = this.currentItemTextElementOpacity;
1089    ASPx.SetStyles(itemTextElement, style);
1090   }
1091  },
1092  PrepareItemElement: function (index) {
1093   ItemsOwnerBase.prototype.PrepareItemElement.call(this, index);
1094   this.PrepareItemTextElement(index);
1095  },
1096  UpdateItemElement: function(index) {
1097   var textElement = this.CreateItemTextElement(index);
1098   var imageContainer = this.GetImageContainerElement(index);
1099   if(textElement && imageContainer) {
1100    imageContainer.appendChild(textElement);
1101    this.PrepareItemTextElement(index);
1102   }
1103   ItemsOwnerBase.prototype.UpdateItemElement.call(this, index);
1104   if(this.GetActiveItemIndex() == index)
1105    this.UpdateOverlayParameters();
1106  },
1107  GetItemElementCssClass: function () {
1108   return this.GetImageSlider().itemCssCl;
1109  },
1110  GetItemElementStyle: function () {
1111   return this.GetImageSlider().itemStyle;
1112  },
1113  PrepareCanvasElement: function (index) {
1114   var canvas = this.GetCanvasElement(index);
1115   canvas.style.position = "absolute";
1116   canvas.style.zIndex = "0";
1117  },
1118  GetItemTextElement: function (index) {
1119   var itemElement = this.GetItemElement(index);
1120   return itemElement ? ASPx.GetChildByClassName(itemElement, CssClasse

1120sConstants.TextAreaCssClassName) : null;
1121  },
1122  GetImageAreaElement: function () {
1123   return this.imageAreaElement;
1124  },
1125  GetItemTextVisibilityMode: function () {
1126   return this.GetImageSlider().itemTxtVbl;
1127  },
1128  GetNavigationBarStrategy: function () {
1129   return this.GetImageSlider().GetNavigationBarStrategy();
1130  },
1131  HasMouseOverForTouchDevice: function () {
1132   if(!ASPx.Browser.TouchUI)
1133    return false;
1134   return this.HasMouseOverImageAreaNavigationButtons() || this.HasMouseOverNavigationBarNavigationButtons() || this.HasMouseOverTextArea() || this.HasMouseOverSlideShowButton();
1135  },
1136  HasMouseOverImageAreaNavigationButtons: function () {
1137   return this.IsMouseOverOrFaded(this.GetNavigationBtnsVisibilityMode());
1138  },
1139  HasMouseOverNavigationBarNavigationButtons: function () {
1140   var navigationBar = this.GetNavigationBarStrategy();
1141   if(!navigationBar)
1142    return false;
1143   return this.IsMouseOverOrFaded(navigationBar.GetNavigationBtnsVisibilityMode());
1144  },
1145  HasMouseOverTextArea: function () {
1146   return this.IsMouseOverOrFaded(this.GetItemTextVisibilityMode());
1147  },
1148  HasMouseOverSlideShowButton: function () {
1149   return this.IsMouseOverOrFaded(this.GetImageSlider().playPauseBtnVbl);
1150  },
1151  IsMouseOverOrFaded: function (visibility) {
1152   return visibility == ElementVisibilityModeEnum.Faded || visibility == ElementVisibilityModeEnum.OnMouseOver;
1153  },
1154  InitializeHandlers: function () {
1155   ItemsOwnerBase.prototype.InitializeHandlers.call(this);
1156   var imageSlider = this.GetImageSlider();
1157   imageSlider.StrategiesCreated.AddHandler(function () {
1158    if(this.CanHandleClickEvent())
1159     ASPx.Evt.AttachEventToElement(this.GetImageAreaElement(), ASPx.Browser.TouchUI ? ASPx.TouchUIHelper.touchMouseUpEventName : "click", function (evt) { this.OnImageAreaClick(evt); }.aspxBind(this));
1160   }.aspxBind(this));
1161   if(!ASPx.Browser.TouchUI && this.IsMouseOverOrFaded(this.GetItemTextVisibilityMode()))
1162    MouseEnterHelper.AddHandler(
1163     imageSlider.GetPassePartoutElement(),
1164     function () { this.AppearTextElements(); }.aspxBind(this),
1165     function () { this.DisappearTextElements(); }.aspxBind(this)
1166    );
1167  },
1168  CanHandleClickEvent: function () {
1169   var imageSlider = this.GetImageSlider();
1170   return !imageSlider.ItemClick.IsEmpty() || imageSlider.HasNavigateUrls() || this.HasMouseOverForTouchDevice();
1171  },
1172  OnImageAreaClick: function (evt) {
1173   this.GetImageSlider().RaiseItemClick();
1174   if(!this.HasMouseOverForTouchDevice())
1175    return;
1176   if(this.touchDeviceElementsVisible) {
1177    if(this.HasMouseOverTextArea())
1178     this.DisappearTextElements();
1179    if(this.HasMouseOverImageAreaNavigationButtons())
1180     this.navigationButtons.Disappear();
1181    if(this.HasMouseOverNavigationBarNavigationButtons())
1182     this.GetNavigationBarStrategy().navigationButtons.Disappear();
1183    if(this.HasMouseOverSlideShowButton())
1184     this.slideShowButton.Disappear();
1185   }
1186   else {
1187    if(this.HasMouseOverTextArea())
1188     this.AppearTextElements();
1189    if(this.HasMouseOverImageAreaNavigationButtons())
1190     this.navigationButtons.Appear();
1191    if(this.HasMouseOverNavigationBarNavigationButtons())
1192     this.GetNavigationBarStrategy().navigationButtons.Appear();
1193    if(this.HasMouseOverSlideShowButton())
1194     this.slideShowButton.Appear();
1195   }
1196   this.touchDeviceElementsVisible = !this.touchDeviceElementsVisible;
1197  },
1198  AppearTextElements: function () {
1199   this.FadeItemTextElements(1);
1200  },
1201  DisappearTextElements: function () {
1202   this.FadeItemTextElements(this.defaultItemTextElementOpacity);
1203  },
1204  FadeItemTextElements: function (value) {
1205   this.currentItemTextElementOpacity = value;
1206   var activeItemIndex = this.GetActiveItemIndex();
1207   this.ForEachItem(function (i) {
1208    var preventAnimation = true;
1209    if(i == activeItemIndex && this.GetAnimationType() != AnimationTypeEnum.None)
1210     preventAnimation = false;
1211    this.FadeItemTextElement(i, preventAnimation);
1212   });
1213  },
1214  FadeItemTextElement: function (index, preventAnimation) {
1215   var textElement = this.GetItemTextElement(index);
1216   if(!textElement) 
1217    return;
1218   if(preventAnimation)
1219    ASPx.SetStyles(textElement, { opacity: this.currentItemTextElementOpacity });
1220   else
1221    ASPx.AnimationHelper.fadeTo(textElement, { to: this.currentItemTextElementOpacity });
1222  },
1223  GetWidth: function () {
1224   return SizeUtils.GetClientWidth(this.GetImageAreaElement());
1225  },
1226  GetHeight: function () {
1227   return SizeUtils.GetClientHeight(this.GetImageAreaElement());
1228  }
1229 });
1230 var SlideImageAreaStrategy = ASPx.CreateClass(ImageAreaStrategy, {
1231  constructor: function (imageSlider) {
1232   this.constructor.prototype.constructor.call(this, imageSlider);
1233  },
1234  SetActiveItemIndexInternal: function (index, preventAnimation) {
1235   ImageAreaStrategy.prototype.SetActiveItemIndexInternal.call(this, index, preventAnimation);
1236   this.UpdateItemElementsAfterDelayIfRequired();
1237   var position = this.GetItemElementPosition(index);
1238   if(preventAnimation) {
1239    this.SetElementTransformPosition(this.GetSlidePanelElement(), position);
1240    this.UpdateItemElementsIfRequired();
1241   }
1242   else
1243    ASPx.AnimationHelper.slideTo(this.GetSlidePanelElement(), {
1244     to: position, duration: this.GetImageSlider().animationDuration,
1245     direction: this.IsHorizontalNavigation() ? ASPx.AnimationHelper.SLIDE_HORIZONTAL_DIRECTION : ASPx.AnimationHelper.SLIDE_VERTICAL_DIRECTION,
1246     onComplete: function () { this.UpdateItemElementsIfRequired(); }.aspxBind(this)
1247    });

1248  },
1249  PerformRollBack: function () {
1250   this.SetActiveItemIndexInternal(this.GetActiveItemIndex(), false);
1251  },
1252  CreateControlHierarchyInternal: function () {
1253   ImageAreaStrategy.prototype.CreateControlHierarchyInternal.call(this);
1254   this.slidePanelElement = this.CreateDiv();
1255   this.GetImageAreaElement().appendChild(this.slidePanelElement);
1256  },
1257  PrepareControlHierarchy: function () {
1258   ImageAreaStrategy.prototype.PrepareControlHierarchy.call(this);
1259   var slideElement = this.GetSlidePanelElement();
1260   slideElement.className = CssClassesConstants.ImageAreaSlidePanelCssClassName;
1261   this.PatchElementForMSTouch(slideElement);
1262  },
1263  AdjustControlInternal: function () {
1264   ImageAreaStrategy.prototype.AdjustControlInternal.call(this);
1265   var horizontal = this.IsHorizontalNavigation();
1266   var width = horizontal ? this.GetItemCount() * this.GetItemElementWidth() : this.GetItemElementWidth();
1267   var height = !horizontal ? this.GetItemCount() * this.GetItemElementHeight() : this.GetItemElementHeight();
1268   ASPx.SetStyles(this.GetSlidePanelElement(), {
1269    width: width,
1270    height: height
1271   });
1272  },
1273  AdjustItemElement: function (index) {
1274   ImageAreaStrategy.prototype.AdjustItemElement.call(this, index);
1275   var itemElement = this.GetItemElement(index);
1276   var position = this.IsHorizontalNavigation() ? this.GetItemElementWidth() * index : this.GetItemElementHeight() * index;
1277   if(this.IsHorizontalNavigation())
1278    ASPx.SetStyles(itemElement, { left: position });
1279   else
1280    ASPx.SetStyles(itemElement, { top: position });
1281  },
1282  GetItemsContainer: function () {
1283   return this.GetSlidePanelElement();
1284  },
1285  CanCreateSwipeGestureHandler: function () {
1286   return true;
1287  },
1288  IsEnablePagingByClick: function () {
1289   var imageSlider = this.GetImageSlider();
1290   return imageSlider.ItemClick.IsEmpty() && !imageSlider.HasNavigateUrls() && ImageAreaStrategy.prototype.IsEnablePagingByClick.call(this);
1291  },
1292  OnImageAreaClick: function (evt) {
1293   if(this.IsExecutedGesture())
1294    return ASPx.Evt.PreventEventAndBubble(evt);
1295   else
1296    ImageAreaStrategy.prototype.OnImageAreaClick.call(this, evt);
1297  },
1298  GetItemElementPosition: function (index) {
1299   return this.IsHorizontalNavigation() ? -(index * this.GetItemElementWidth()) : -(index * this.GetItemElementHeight());
1300  }
1301 });
1302 var SlideLoopNavigationImageAreaStrategy = ASPx.CreateClass(SlideImageAreaStrategy, {
1303  constructor: function (imageSlider) {
1304   this.simpleTransition = null;
1305   this.constructor.prototype.constructor.call(this, imageSlider);
1306  },
1307  CreateItemElementsManager: function () {
1308   return new LoopImageAreaItemElementsManager(this);
1309  },
1310  GetEnableLoopNavigation: function () {
1311   return true;
1312  },
1313  StartSlideSimpleTransition: function (from, to, preventAnimation) {
1314   this.UpdateItemsPosition(to - from, preventAnimation);
1315   if(!preventAnimation) {
1316    this.simpleTransition = ASPx.AnimationHelper.createSimpleAnimationTransition({
1317     duration: this.GetImageSlider().animationDuration,
1318     onUpdate: function (value) {
1319      this.UpdateItemsPosition(value, true);
1320     }.aspxBind(this)
1321    });
1322    this.simpleTransition.Start(from, to);
1323   }
1324  },
1325  StopSimpleTransition: function () {
1326   if(this.simpleTransition) {
1327    this.simpleTransition.Cancel();
1328    this.simpleTransition = null;
1329   }
1330  },
1331  UpdateItemsPosition: function (value, needApplyPositions) {
1332   this.ForEachItem(function (i) {
1333    var element = this.GetItemElement(i);
1334    if(element) {
1335     element.dxPosition = element.dxPosition + value;
1336     if(needApplyPositions)
1337      this.SetItemPosition(element);
1338    }
1339   });
1340  },
1341  OnMouseMoveUpdatePosition: function (position) {
1342   this.StopSimpleTransition();
1343   var itemSize = this.GetItemElementSize();
1344   this.ForEachItem(function (i) {
1345    var element = this.GetItemElement(i);
1346    if(element)
1347     element.dxPosition = element.dxPosition + position;
1348   });
1349   this.ForEachItem(function (i) {
1350    var element = this.GetItemElement(i);
1351    if(!element)
1352     return;
1353    this.SetItemPosition(element);
1354    if(element.dxPosition < 0 && ((element.dxPosition + itemSize) > 0)) {
1355     var index = i + 1;
1356     if(index == this.GetItemCount())
1357      index = 0;
1358     var nextItem = this.GetItemElement(index);
1359     if(nextItem) {
1360      nextItem.dxPosition = element.dxPosition + itemSize;
1361      this.SetItemPosition(nextItem);
1362     }
1363    }
1364    if(element.dxPosition < itemSize && ((element.dxPosition + itemSize) > itemSize)) {
1365     var index = i - 1;
1366     if(index < 0)
1367      index = this.GetItemCount() - 1;
1368     var nextItem = this.GetItemElement(index);
1369     if(nextItem) {
1370      nextItem.dxPosition = element.dxPosition - itemSize;
1371      this.SetItemPosition(nextItem);
1372     }
1373    }
1374   });
1375  },
1376  SetItemPosition: function (itemElement) {
1377   this.SetElementTransformPosition(itemElement, itemElement.dxPosition);
1378  },
1379  SetActiveItemIndexInternal: function (index, preventAnimation, isRollback) {
1380   ImageAreaStrategy.prototype.SetActiveItemIndexInternal.call(this, index, preventAnimation);
1381   this.StopSimpleTransition();
1382   this.UpdateItemElementsIfRequired();
1383   var currentIndex = this.GetPrevItemIndex();
1384   if(currentIndex == -1 || this.IsRtl() && currentIndex == this.GetItemCount())
1385    currentIndex = index;
1386   if(!isRollback) {
1387    var isLeft = currentIndex > index;
1388    if(currentIndex == 0 && index == this.GetItemCount() - 1)
1389     isLeft = true;
1390    if(currentIndex == this.GetItemCount() - 1 && index == 0)
1391     isLeft = false;
1392    var prevItem = this.GetItemElement(currentIndex);
1393    var nextIndex = isLeft ? currentIndex - 1 : currentIndex + 1;
1394    for(var i = 1; i < this.GetItemCount() ; i++) {
1395     if(isLeft && nextIndex < 0)
1396      nextIndex = this.GetItemCount() - 1;
1397     else if(nextIndex == this.GetItemCount())
1398      nextIndex = 0;
1399     var nextItem = this.GetItemElement(nextIndex);
1400     if(nextItem) {
1401      nextItem.dxPosition = (isLeft ? -1 : 1) * (this.GetItemElementSize() * i) + prevItem.dxPosition;
1402      this.SetItemPosition(nextItem);
1403     }
1404     nextIndex = isLeft ? nextIndex - 1 : nextIndex + 1;
1405    }
1406   }
1407   var offset = this.GetItemElement(index).dxPosition;
1408   this.StartSlideSimpleTransition(offset, 0, preventAnimation);
1409  },
1410  PerformRollBack: function () {

1411   this.SetActiveItemIndexInternal(this.GetActiveItemIndex(), false, true);
1412  },
1413  CreateControlHierarchyInternal: function () {
1414   ImageAreaStrategy.prototype.CreateControlHierarchyInternal.call(this);
1415  },
1416  PrepareControlHierarchy: function () {
1417   ImageAreaStrategy.prototype.PrepareControlHierarchy.call(this);
1418   this.PatchElementForMSTouch(this.GetImageAreaElement());
1419  },
1420  AdjustControlInternal: function () {
1421   ImageAreaStrategy.prototype.AdjustControlInternal.call(this);
1422  },
1423  AdjustItemElement: function (index) {
1424   ImageAreaStrategy.prototype.AdjustItemElement.call(this, index);
1425   var itemElement = this.GetItemElement(index);
1426   itemElement.dxPosition = this.IsHorizontalNavigation() ? this.GetItemElementWidth() * index : this.GetItemElementHeight() * index;
1427   this.SetItemPosition(itemElement);
1428  },
1429  CreateSwipeGestureHandler: function () {
1430   ASPx.GesturesHelper.AddSwipeSlideGestureHandler(
1431    this.GetClientControlName() + this.GetUniqueId(),
1432    function () { return this.GetSwipeGestureElement(); }.aspxBind(this),
1433    this.IsHorizontalNavigation() ? ASPx.AnimationHelper.SLIDE_HORIZONTAL_DIRECTION : ASPx.AnimationHelper.SLIDE_VERTICAL_DIRECTION,
1434    function (evt) { return this.CanHandleSwipeGesture(evt); }.aspxBind(this),
1435    function () { this.PerformBackward(); }.aspxBind(this),
1436    function () { this.PerformForward(); }.aspxBind(this),
1437    function () { this.PerformRollBack(); }.aspxBind(this),
1438    function (position) { this.OnMouseMoveUpdatePosition(position); }.aspxBind(this)
1439   );
1440  },
1441  UpdateOverlayParameters: function () {
1442   SlideImageAreaStrategy.prototype.UpdateOverlayParameters.call(this);
1443   if(this.overlayImageElement) {
1444    var textElement = this.GetItemTextElement(this.GetActiveItemIndex());
1445    if(textElement)
1446     this.overlayImageElement.style.height = (this.GetImageAreaElement().offsetHeight - textElement.offsetHeight) + "px";
1447   }
1448  },
1449  GetSwipeGestureElement: function () {
1450   return this.GetImageAreaElement();
1451  },
1452  GetItemsContainer: function () {
1453   return this.GetImageAreaElement();
1454  },
1455  UpdateNavigationButtonsState: function () {
1456   return false;
1457  }
1458 });
1459 FadeImageAreaStrategy = ASPx.CreateClass(ImageAreaStrategy, {
1460  constructor: function (imageSlider) {
1461   this.constructor.prototype.constructor.call(this, imageSlider);
1462  },
1463  SetActiveItemIndexInternal: function (index, preventAnimation) {
1464   ImageAreaStrategy.prototype.SetActiveItemIndexInternal.call(this, index, preventAnimation);
1465   this.UpdateItemElementsIfRequired();
1466   var appearItem = this.GetItemElement(index);
1467   var disapperItem = this.GetItemElement(this.GetPrevItemIndex());
1468   if(preventAnimation) {
1469    this.SetVisible(appearItem);
1470    if(disapperItem)
1471     this.SetInvisible(disapperItem);
1472   }
1473   else {
1474    var duration = this.GetImageSlider().animationDuration;
1475    ASPx.SetElementDisplay(appearItem, true);
1476    ASPx.AnimationHelper.fadeTo(disapperItem, {
1477     to: 0, duration: duration,
1478     onComplete: function (el) { ASPx.SetElementDisplay(el, false); }
1479    });
1480    ASPx.AnimationHelper.fadeTo(appearItem, {
1481     to: 1, duration: duration
1482    });
1483   }
1484  },
1485  UpdateNavigationButtonsState: function () {
1486   if(!this.GetEnableLoopNavigation())
1487    return ImageAreaStrategy.prototype.UpdateNavigationButtonsState.call(this);
1488   return false;
1489  },
1490  AdjustItemElement: function (index) {
1491   ImageAreaStrategy.prototype.AdjustItemElement.call(this, index);
1492   this.SetInvisible(this.GetItemElement(index));
1493  },
1494  GetEnableLoopNavigation: function () {
1495   return this.GetImageSlider().enableLoopNavigation;
1496  },
1497  CanCreateSwipeGestureHandler: function () {
1498   return true;
1499  },
1500  GetSwipeGestureElement: function () {
1501   return this.GetImageAreaElement();
1502  },
1503  OnImageAreaClick: function (evt) {
1504   if(this.IsExecutedGesture())
1505    return ASPx.Evt.PreventEventAndBubble(evt);
1506   else
1507    ImageAreaStrategy.prototype.OnImageAreaClick.call(this, evt);
1508  },
1509  CreateSwipeGestureHandler: function () {
1510   ASPx.GesturesHelper.AddSwipeSlideGestureHandler(
1511    this.GetClientControlName() + this.GetUniqueId(),
1512    function () { return this.GetSwipeGestureElement(); }.aspxBind(this),
1513    this.IsHorizontalNavigation() ? ASPx.AnimationHelper.SLIDE_HORIZONTAL_DIRECTION : ASPx.AnimationHelper.SLIDE_VERTICAL_DIRECTION,
1514    function (evt) { return this.CanHandleSwipeGesture(evt); }.aspxBind(this),
1515    function () { this.PerformBackward(); }.aspxBind(this),
1516    function () { this.PerformForward(); }.aspxBind(this),
1517    function () { },
1518    function () { }
1519   );
1520  },
1521  GetItemsContainer: function () {
1522   return this.GetImageAreaElement();
1523  },
1524  SetVisible: function (element) {
1525   ASPx.SetStyles(element, {
1526    display: "",
1527    opacity: 1
1528   });
1529  },
1530  SetInvisible: function (element) {
1531   ASPx.SetStyles(element, {
1532    display: "none",
1533    opacity: 0
1534   });
1535  }
1536 });
1537 var NoneImageAreaStrategy = ASPx.CreateClass(FadeImageAreaStrategy, {
1538  constructor: function (imageSlider) {
1539   this.constructor.prototype.constructor.call(this, imageSlider);
1540  },
1541  SetActiveItemIndexInternal: function (index, preventAnimation) {
1542   FadeImageAreaStrategy.prototype.SetActiveItemIndexInternal.call(this, index, true);
1543  }
1544 });
1545 var NavigationBarStrategy = ASPx.CreateClass(ItemsOwnerBase, {
1546  constructor: function (imageSlider) {
1547   this.navigationBarElement = null;
1548   this.slidePanelWrapperElement = null;
1549   this.lastSlideItemsPortionDate = new Date();
1550   this.slideElementPosition = 0;
1551   this.constructor.prototype.constructor.call(this, imageSlider);
1552  },
1553  GetUniqueId: function () {
1554   return "_nb_";
1555  },
1556  IsHorizontalNavigation: function () {
1557   var position = this.GetPositionMode();
1558   return position == NavigationBarPositionEnum.Top || position == NavigationBarPositionEnum.Bottom;
1559  },
1560  IsNeedCreateHyperLink: function () {
1561   return false;
1562  },
1563  GetLoadingElement: function (index) {
1564   return null;
1565  },
1566  CreateItemElementsManager: function () {
1567   return new NavigationBarItemElementsManager(this);
1568  },
1569  GetTemplate: function (index) {
1570   return this.GetItem(index).tmtpl;
1571  },
1572  GetImageSrc: function (index) {
1573   var thumbnailImageSrc = this.GetItem(index).ts;
1574   if(thumbnailImageSrc)
1575    return thumbnailImageSrc;
1576   return this.GetItem(index).s;
1577  },
1578  SetActiveItemIndexInternal: function (index, preventAnimation) {
1579   var snapToLeft = this.IsSnapToLeft(index);
1580   var nextIndex = snapToLeft ? index - 1 : index + 1;
1581   if(this.GetImageSlider().extremeItemClickMode == ExtremeItemClickModeEnum.Select || !this.IsValidItemIndex(nextIndex))
1582    nextIndex = index;
1583   if(!this.IsVisibleItemElement(nextIndex, true))
1584    this.SlideToItem(nextIndex, snapToLeft, preventAnimation);

1585   this.SetActiveItemVisually(index, preventAnimation);
1586  },
1587  IsVisibleItemElement: function (index, considerSize) {
1588   var slideWrapperElementSize = this.GetElementSize(this.GetSlidePanelWrapperElement());
1589   var itemPosition = (this.GetItemElementSize() + this.GetItemSpacing()) * index;
1590   var itemPositionInSlideWrapper = this.ConvertItemPositionToSlideWrapperPosition(itemPosition);
1591   if(considerSize)
1592    return itemPositionInSlideWrapper >= 0 && itemPositionInSlideWrapper + this.GetItemElementSize() <= slideWrapperElementSize;
1593   return itemPositionInSlideWrapper + this.GetItemElementSize() >= 0 && itemPositionInSlideWrapper <= slideWrapperElementSize;
1594  },
1595  IsSnapToLeft: function (index) {
1596   var slideWrapperElementSize = this.GetElementSize(this.GetSlidePanelWrapperElement());
1597   var itemPosition = (this.GetItemElementSize() + this.GetItemSpacing()) * index;
1598   var lastItemSize = this.GetItemElementSize() + (index != this.GetItemCount() - 1 ? this.GetItemSpacing() : 0);
1599   return this.ConvertItemPositionToSlideWrapperPosition(itemPosition + lastItemSize) < (slideWrapperElementSize / 2);
1600  },
1601  ConvertItemPositionToSlideWrapperPosition: function (itemPosition) {
1602   return this.GetElementTransformPosition(this.GetSlidePanelElement()) + itemPosition;
1603  },
1604  SlideToItem: function (index, snapToLeft, preventAnimation) {
1605   this.UpdateItemElementsAfterDelayIfRequired();
1606   this.CalculateSlideElementPosition(index, snapToLeft);
1607   this.PerformSlideAction(preventAnimation);
1608  },
1609  CalculateSlideElementPosition: function (index, snapToLeft) {
1610   var slideWrapperElementSize = this.GetElementSize(this.GetSlidePanelWrapperElement());
1611   var itemPosition = (this.GetItemElementSize() + this.GetItemSpacing()) * index;
1612   if(snapToLeft) {
1613    this.slideElementPosition = -itemPosition;
1614    var limitPosition = -(this.GetElementSize(this.GetSlidePanelElement()) - this.GetElementSize(this.GetSlidePanelWrapperElement()));
1615    var next = this.GetElementTransformPosition(this.GetSlidePanelElement()) > this.slideElementPosition;
1616    if(this.slideElementPosition < limitPosition || next && Math.abs(-limitPosition + this.slideElementPosition) < this.GetItemElementSize())
1617     this.slideElementPosition = limitPosition;
1618   }
1619   else {
1620    this.slideElementPosition = slideWrapperElementSize - (itemPosition + this.GetItemElementSize());
1621    var prev = this.GetElementTransformPosition(this.GetSlidePanelElement()) < this.slideElementPosition;
1622    if(this.slideElementPosition > 0 || prev && this.slideElementPosition > -this.GetItemElementSize())
1623     this.slideElementPosition = 0;
1624   }
1625  },
1626  PerformSlideAction: function (preventAnimation) {
1627   this.UpdateNavigationButtonsState(); 
1628   if(preventAnimation) {
1629    this.SetElementTransformPosition(this.GetSlidePanelElement(), this.slideElementPosition);
1630    this.PerformSlideActionComplete();
1631   }
1632   else {
1633    ASPx.AnimationHelper.slideTo(this.GetSlidePanelElement(), {
1634     to: this.slideElementPosition, callBack: function () { this.UpdateItemElementsIfRequired(); }.aspxBind(this),
1635     duration: this.IsSinglePagingMode() ? 300 : ASPx.AnimationConstants.Durations.Default,
1636     direction: this.IsHorizontalNavigation() ? ASPx.AnimationHelper.SLIDE_HORIZONTAL_DIRECTION : ASPx.AnimationHelper.SLIDE_VERTICAL_DIRECTION,
1637     onComplete: function() { this.PerformSlideActionComplete(); }.aspxBind(this)
1638    });
1639   }
1640  },
1641  PerformSlideActionComplete: function() {
1642  },
1643  SetActiveItemVisually: function (index, preventAnimation) {
1644  },
1645  GetNavigationBtnsVisibilityMode: function () {
1646   return this.GetImageSlider().thumbNavBtnsVbl;
1647  },
1648  GetButtonsContainer: function () {
1649   return this.GetNavigationBarElement();
1650  },
1651  GetPrevButtonHtml: function () {
1652   return this.GetImageSlider().nbpbh;
1653  },
1654  GetNextButtonHtml: function () {
1655   return this.GetImageSlider().nbnbh;
1656  },
1657  UpdateNavigationButtonsState: function () {
1658   if(this.navigationButtons) {
1659    var oldButtonsVisibility = this.navigationButtons.GetVisibilityButtons();
1660    if(this.IsWrapperOverlapsItemCollection())
1661     this.SetVisibilityButtons(false);
1662    else {
1663     this.SetVisibilityButtons(true);
1664     var minOffset = -(this.GetElementSize(this.GetSlidePanelElement(), false) - this.GetElementSize(this.GetSlidePanelWrapperElement(), true)), maxOffset = 0;
1665     this.SetEnablePrevButton(this.slideElementPosition != maxOffset);
1666     this.SetEnableNextButton(this.slideElementPosition != minOffset);
1667    }
1668    return oldButtonsVisibility != this.navigationButtons.GetVisibilityButtons();
1669   }
1670   return false;
1671  },
1672  PerformBackward: function () {
1673   if(this.IsSinglePagingMode())
1674    this.SlideItemsPortionSingleMode(true);
1675   else
1676    this.SlideItemsPortionPageMode(true);
1677  },
1678  PerformForward: function () {
1679   if(this.IsSinglePagingMode())
1680    this.SlideItemsPortionSingleMode(false);
1681   else
1682    this.SlideItemsPortionPageMode(false);
1683  },
1684  PerformRollBack: function () {
1685   var position = this.GetElementTransformPosition(this.GetSlidePanelElement());
1686   var slidePanelElementSize = this.GetElementSize(this.GetSlidePanelElement());
1687   var slidePanelWrapperElementSize = this.GetElementSize(this.GetSlidePanelWrapperElement());
1688   var minPosition = slidePanelWrapperElementSize - slidePanelElementSize;
1689   if(this.IsWrapperOverlapsItemCollection())
1690    this.slideElementPosition = (slidePanelWrapperElementSize - slidePanelElementSize) / 2;
1691   else if(position > 0)
1692    this.slideElementPosition = 0;
1693   else if(position < minPosition)
1694    this.slideElementPosition = minPosition;
1695   this.PerformSlideAction();
1696  },
1697  SlideItemsPortionPageMode: function (backward) {
1698   var index = backward ? 0 : this.GetItemCount() - 1;
1699   var lastIndex = backward ? this.GetItemCount() - 1 : 0;
1700   var previousInvisibleIndex = index;
1701   while(index != lastIndex) {
1702    if(this.IsVisibleItemElement(index, true)) {
1703     this.SlideToItem(previousInvisibleIndex, !backward);
1704     break;
1705    }
1706    previousInvisibleIndex = index;
1707    index += backward ? 1 : -1;
1708   }
1709  },
1710  SlideItemsPortionSingleMode: function (backward) {
1711   var index = backward ? 0 : this.GetItemCount() - 1;
1712   var lastIndex = backward ? this.GetItemCount() - 1 : 0;
1713   var previousInvisibleIndex = index;
1714   var considerSize = new Date() - this.lastSlideItemsPortionDate < 350 ? false : true;
1715   while(index != lastIndex) {
1716    if(this.IsVisibleItemElement(index, considerSize)) {
1717     this.SlideToItem(previousInvisibleIndex, backward);
1718     break;
1719    }
1720    previousInvisibleIndex = index;
1721    index += backward ? 1 : -1;
1722   }
1723   this.lastSlideItemsPortionDate = new Date();
1724  },
1725  CreateControlHierarchyInternal: function () {
1726   ItemsOwnerBase.prototype.CreateControlHierarchyInternal.call(this);
1727   var mainElement = this.GetMainElement();
1728   this.navigationBarElement = this.CreateDiv();
1729   this.slidePanelWrapperElement = this.CreateDiv();
1730   var positionMode = this.GetPositionMode();
1731   var passePartour = this.GetImageSlider().GetPassePartoutElement();
1732   if((positionMode == NavigationBarPositionEnum.Top || positionMode == NavigationBarPositionEnum.Left) && passePartour)
1733    mainElement.insertBefore(this.navigationBarElement, passePartour);
1734   else
1735    mainElement.appendChild(this.navigationBarElement);
1736   this.slidePanelElement = this.CreateDiv();
1737   this.slidePanelWrapperElement.appendChild(this.slidePanelElement);
1738   this.navigationBarElement.appendChild(this.slidePanelWrapperElement);
1739  },
1740  GetItemsContainer: function () {
1741   return this.GetSlidePanelElement();
1742  },
1743  PrepareControlHierarchy: function () {
1744   ItemsOwnerBase.prototype.PrepareControlHierarchy.call(this);
1745   this.PrepareNavigationBarElement();
1746   this.PrepareSlidePanelElement();
1747  },
1748  PrepareNavigationBarElement: function () {
1749   var navigationBarElement = this.GetNavigationBarElement();
1750   ASPx.SetStyles(navigationBarElement, {
1751    className: this.GetImageSlider().navBarCssCl,
1752    cssText: this.GetImageSlider().navBarStyle
1753   });
1754  },
1755  PrepareSlidePanelElement: function () {
1756   var slideElement = this.GetSlidePanelElement();

1757   slideElement.className = CssClassesConstants.NavigationBarSlidePanelCssClassName;
1758   this.GetSlidePanelWrapperElement().className = CssClassesConstants.NavigationBarSlidePanelWrapperCssClassName;
1759   this.PatchElementForMSTouch(slideElement);
1760  },
1761  AdjustControlInternal: function () {
1762   ItemsOwnerBase.prototype.AdjustControlInternal.call(this);
1763   this.AdjustNavigationBarElement();
1764   this.AdjustSlidePanelElement();
1765   this.UpdateItemElementsIfRequired();
1766   if(this.UpdateNavigationButtonsState())
1767    this.AdjustNavigationBarElement();
1768  },
1769  AdjustItemElements: function () {
1770   if(!this.IsAdjustedSize()) {
1771    ItemsOwnerBase.prototype.AdjustItemElements.call(this);
1772    var horizontal = this.IsHorizontalNavigation();
1773    var width = horizontal ? this.GetItemCount() * this.GetItemWidthWithSpacing() - this.GetItemSpacing() : this.GetItemElementWidth();
1774    var height = horizontal ? this.GetItemElementHeight() : this.GetItemCount() * this.GetItemHeightWithSpacing() - this.GetItemSpacing();
1775    ASPx.SetStyles(this.GetSlidePanelElement(), { width: width, height: height });
1776   }
1777  },
1778  AdjustNavigationBarElement: function () {
1779   var styles = this.GetNavigationBarElementsStyles();
1780   ASPx.SetStyles(this.GetNavigationBarElement(), styles.navBarStyle);
1781   ASPx.SetStyles(this.GetSlidePanelWrapperElement(), styles.wrapperStyle);
1782  },
1783  GetNavigationBarElementsStyles: function () {
1784   var isHorizontal = this.IsHorizontalNavigation();
1785   var styles = {};
1786   if(this.CanUseVisibleItemCount())
1787    styles = {
1788     width: isHorizontal ? this.GetItemWidthWithSpacing() * this.GetVisibleItemCount() - this.GetItemSpacing() : this.GetItemElementWidth(),
1789     height: isHorizontal ? this.GetItemElementHeight() : this.GetItemHeightWithSpacing() * this.GetVisibleItemCount() - this.GetItemSpacing()
1790    };
1791   else {
1792    var navigationBar = this.GetNavigationBarElement();
1793    var mainElementWidth = SizeUtils.GetClientWidth(this.GetMainElement(), true);
1794    var mainElementHeight = SizeUtils.GetClientHeight(this.GetMainElement(), true);
1795    styles = {
1796     width: this.IsHorizontalNavigation() ? mainElementWidth : this.GetItemElementWidth(),
1797     height: this.IsHorizontalNavigation() ? this.GetItemElementHeight() : mainElementHeight
1798    };
1799    ASPx.SetStyles(navigationBar, styles);
1800    styles.width = this.IsHorizontalNavigation() ? mainElementWidth - (navigationBar.offsetWidth - mainElementWidth) : this.GetItemElementWidth();
1801    styles.height = this.IsHorizontalNavigation() ? this.GetItemElementHeight() : mainElementHeight - (navigationBar.offsetHeight - mainElementHeight);
1802   }
1803   return {
1804    navBarStyle: {
1805     width: styles.width,
1806     height: styles.height
1807    },
1808    wrapperStyle: {
1809     width: styles.width,
1810     height: styles.height
1811    }
1812   };
1813  },
1814  CanUseVisibleItemCount: function () {
1815   return !this.GetImageSlider().showImageArea && this.GetVisibleItemCount() > 0;
1816  },
1817  AdjustSlidePanelElement: function () {
1818   this.slideElementPosition = this.GetPostDataOffset();
1819   if(this.IsWrapperOverlapsItemCollection())
1820    this.slideElementPosition = (this.GetElementSize(this.GetSlidePanelWrapperElement()) - this.GetElementSize(this.GetSlidePanelElement())) / 2;
1821   else if(this.slideElementPosition > 0 && !this.IsRtl())
1822    this.slideElementPosition = 0;
1823   this.SetElementTransformPosition(this.GetSlidePanelElement(), this.slideElementPosition);
1824  },
1825  IsWrapperOverlapsItemCollection: function() {
1826   return this.GetElementSize(this.GetSlidePanelWrapperElement()) > this.GetElementSize(this.GetSlidePanelElement());
1827  },
1828  GetPostDataOffset: function () {
1829   var offset = this.IsAdjustedSize() ? 0 : this.GetImageSlider().navBarOffset;
1830   if(offset == 0 && this.IsRtl())
1831    offset = this.GetElementSize(this.GetSlidePanelWrapperElement()) - this.GetElementSize(this.GetSlidePanelElement());
1832   return offset;
1833  },
1834  PrepareItemElement: function (index) {
1835   ItemsOwnerBase.prototype.PrepareItemElement.call(this, index);
1836   this.GetItemElement(index).itemIndex = index;
1837  },
1838  AdjustItemElement: function (index) {
1839   ItemsOwnerBase.prototype.AdjustItemElement.call(this, index);
1840   ASPx.SetStyles(this.GetItemElement(index), this.IsHorizontalNavigation() ? { left

1840: this.GetItemWidthWithSpacing() * index } : { top: this.GetItemHeightWithSpacing() * index });
1841  },
1842  CalculateSize: function () {
1843   if(!this.IsAdjustedSize())
1844    ItemsOwnerBase.prototype.CalculateSize.call(this);
1845  },
1846  CalculateItemElementSize: function (fakeElement) {
1847   this.GetNavigationBarElement().appendChild(fakeElement);
1848   this.fullItemWidth = SizeUtils.GetClientWidth(fakeElement);
1849   this.fullItemHeight = SizeUtils.GetClientHeight(fakeElement);
1850   this.clearItemWidth = SizeUtils.GetClientWidth(fakeElement, true);
1851   this.clearItemHeight = SizeUtils.GetClientHeight(fakeElement, true);
1852  },
1853  ResetControlStyle: function () {
1854   ASPx.SetStyles(this.GetNavigationBarElement(), { width: 0, height: 0 });
1855  },
1856  GetShownItemIndexes: function(getUncroppedItems) { return []; },
1857  CanCreateSwipeGestureHandler: function () {
1858   return true;
1859  },
1860  CanHandleSwipeGesture: function(evt) {
1861   return !this.IsWrapperOverlapsItemCollection() && ItemsOwnerBase.prototype.CanHandleSwipeGesture.call(this, evt);
1862  },
1863  InitializeHandlers: function () {
1864   ItemsOwnerBase.prototype.InitializeHandlers.call(this);
1865   ASPx.Evt.AttachEventToElement(this.GetSlidePanelElement(), this.GetMouseUpEventName(), function (evt) { this.OnNavigationBarMouseUp(evt); }.aspxBind(this)); 
1866  },
1867  OnNavigationBarMouseUp: function (evt) {
1868   if(this.CanCandleMouseUpEvent(evt)) {
1869    var index = this.GetItemIndexFromEvent(evt);
1870    if(index != -1) {
1871     this.GetImageSlider().SetActiveItemIndexInternal(index);
1872     this.StopPlayingWhenPaging();
1873     this.GetImageSlider().RaiseThumbnailItemClick();
1874    }
1875   }
1876  },
1877  GetMouseUpEventName: function () {
1878   return ASPx.TouchUIHelper.touchMouseUpEventName;
1879  },
1880  CanCandleMouseUpEvent: function (evt) {
1881   return !this.IsExecutedGesture() && ASPx.Evt.IsLeftButtonPressed(evt);
1882  },
1883  GetItemIndexFromEvent: function (evt) {
1884   var itemElement = ASPx.GetParentByClassName(ASPx.Evt.GetEventSource(evt),this.GetItemElementCssClass());
1885   return itemElement ? itemElement.itemIndex : -1;
1886  },
1887  GetImageSizeMode: function () {
1888   return this.GetImageSlider().thumbImageSizeMode;
1889  },
1890  GetMainElement: function () {
1891   return this.GetImageSlider().GetMainElement();
1892  },
1893  GetSlidePanelWrapperElement: function () {
1894   return this.slidePanelWrapperElement;
1895  },
1896  GetNavigationBarElement: function () {
1897   return this.navigationBarElement;
1898  },
1899  GetElementSize: function (element, clear) {
1900   return this.IsHorizontalNavigation() ? SizeUtils.GetClientWidth(element, clear) : SizeUtils.GetClientHeight(element, clear);
1901  },
1902  GetItemWidthWithSpacing: function () {
1903   return this.GetItemElementWidth() + this.GetItemSpacing();
1904  },
1905  GetItemHeightWithSpacing: function () {
1906   return this.GetItemElementHeight() + this.GetItemSpacing();
1907  },
1908  GetPositionMode: function () {
1909   return this.GetImageSlider().GetNavigationBarPosition();
1910  },
1911  GetItemSpacing: function () {
1912   return this.GetImageSlider().itemSpacing;
1913  },
1914  IsSinglePagingMode: function () {
1915   return this.GetImageSlider().navBarPagingMode == NavigationBarPagingModeEnum.Single;
1916  },
1917  GetVisibleItemCount: function () {
1918   return this.GetImageSlider().visibleItemsCount;
1919  },
1920  GetSlideElementPosition: function () {
1921   return Math.round(this.slideElementPosition);
1922  },
1923  GetWidth: function () {
1924   var navigationBarElement = this.GetNavigationBarElement();
1925   var currentStyle = ASPx.GetCurrentStyle(navigationBarElement);
1926   var width = SizeUtils.GetClientWidth(navigationBarElement) + ASPx.PxToInt(currentStyle.marginLeft) + ASPx.PxToInt(currentStyle.marginRight);
1927   return width > 0 ? width : 0;
1928  },
1929  GetHeight: function () {
1930   var navigationBarElement = this.GetNavigationBarElement();
1931   var currentStyle = ASPx.GetCurrentStyle(navigationBarElement);
1932   var height = SizeUtils.GetClientHeight(navigationBarElement) + ASPx.PxToInt(currentStyle.marginTop) + ASPx.PxToInt(currentStyle.marginBottom);
1933   return height > 0 ? height : 0;
1934  }
1935 });
1936 var NavigationBarThumbnailStrategy = ASPx.CreateClass(NavigationBarStrategy, {
1937  constructor: function (imageSlider) {
1938   this.selectedStateElement = null;
1939   this.hoverStateElementSize = {};
1940   this.innerHoverStateElementSize = {};
1941   this.loadingElenentSize = {};
1942   this.setActiveIndexCounter = 0;
1943   this.constructor.prototype.constructor.call(this, imageSlider);
1944  },
1945  BeginSetActiveIndex: function () {
1946   this.setActiveIndexCounter++;
1947  },
1948  EndSetActiveIndex: function () {
1949   this.setActiveIndexCounter--;
1950  },
1951  NeedOffsetCorrection: function () {
1952   return this.setActiveIndexCounter > 0 && this.GetImageSlider().extremeItemClickMode == ExtremeItemClickModeEnum.SelectAndSlide;
1953  },
1954  GetNavigationButtonsPosition: function () {
1955   return this.GetImageSlider().thumbNavBtnsPos;
1956  },
1957  GetItemIndexFromEvent: function(evt) {
1958   var result = NavigationBarStrategy.prototype.GetItemIndexFromEvent.call(this, evt);
1959   if(result == -1) {
1960    var eventSource = ASPx.Evt.GetEventSource(evt);
1961    var selectedItem = this.GetSelectedStateElement();
1962    if (eventSource.parentNode == selectedItem || eventSource == selectedItem)
1963     result = this.GetRtlIndex(this.GetImageSlider().GetActiveItemIndex());
1964   }
1965   return result;
1966  },
1967  SetActiveItemIndexInternal: function (index, preventAnimation) {
1968   this.BeginSetActiveIndex();
1969   NavigationBarStrategy.prototype.SetActiveItemIndexInternal.call(this, index, preventAnimation);
1970   this.EndSetActiveIndex();
1971  },
1972  SetActiveItemVisually: function (index, preventAnimation) {
1973   this.SelectItemElement(index);
1974   this.MoveSelectedItem(index, preventAnimation);
1975  },
1976  SelectItemElement: function (index) {
1977   var currentItemElement = this.GetItemElement(index);
1978   var prevItemElement = this.GetItemElement(this.GetPrevItemIndex());
1979   if(prevItemElement)
1980    prevItemElement.className = prevItemElement.className.replace(CssClasse

1980sConstants.NavigationBarSelectedStateCssClassName, "");
1981   if(currentItemElement && !ASPx.ElementContainsCssClass(currentItemElement, CssClassesConstants.NavigationBarSelectedStateCssClassName))
1982    currentItemElement.className += CssClassesConstants.NavigationBarSelectedStateCssClassName;
1983  },
1984  MoveSelectedItem: function (index, preventAnimation) {
1985   var selectedStateElement = this.GetSelectedStateElement();
1986   var position = (this.GetItemElementSize() + this.GetItemSpacing()) * index;
1987   preventAnimation = this.GetImageSlider().disableSelectedStateAnimation || preventAnimation; 
1988   if(preventAnimation)
1989    this.SetElementTransformPosition(selectedStateElement, position);
1990   else
1991    ASPx.AnimationHelper.slideTo(selectedStateElement, {
1992     to: position,
1993     direction: this.IsHorizontalNavigation() ? ASPx.AnimationHelper.SLIDE_HORIZONTAL_DIRECTION : ASPx.AnimationHelper.SLIDE_VERTICAL_DIRECTION
1994    });
1995  },
1996  PerformSlideActionComplete: function() {
1997   this.EnsureShownItemsLoaded();
1998  },
1999  SlideItemsPortionPageMode: function (backward) {
2000   this.PerformSlideToExtremeInvisibleElement(backward, true, !backward);
2001  },
2002  PerformRollBack: function () {
2003   NavigationBarStrategy.prototype.PerformRollBack.call(this);
2004  },
2005  UpdateItemElementsIfRequired: function () {
2006   NavigationBarStrategy.prototype.UpdateItemElementsIfRequired.call(this);
2007   if(this.GetImageLoadMode() != LoadModeEnum.AllImages)
2008    this.SelectItemElement(this.GetActiveItemIndex());
2009  },
2010  CanCreateNavigationButtons: function () {
2011   if(!this.CanUseVisibleItemCount())
2012    return true;
2013   return this.GetVisibleItemCount() < this.GetItemCount();
2014  },
2015  CreateNavigationButtons: function () {
2016   if(this.GetNavigationBtnsVisibilityMode() == ElementVisibilityModeEnum.None)
2017    return null;
2018   if(this.GetNavigationButtonsPosition() == NavigationBarButtonPositionEnum.Outside)
2019    return new OutsideNavigationButtons(this);
2020   return new NavigationButtons(this);
2021  },
2022  CreateControlHierarchy: function () {
2023   NavigationBarStrategy.prototype.CreateControlHierarchy.call(this);
2024   this.CreateSelectedStateElement();
2025  },
2026  CreateTemplate: function(index) {
2027   ItemsOwnerBase.prototype.CreateTemplate.call(this, index);
2028   var template = this.GetTemplate(index);
2029   if(template)
2030    this.HideLoadingElement(index);
2031  },
2032  CreateItemElement: function (index) {
2033   var itemElement = NavigationBarStrategy.prototype.CreateItemElement.call(this, index);
2034   itemElement.appendChild(this.CreateLoadingElement());
2035   if(this.IsEnabled() && !ASPx.Browser.TouchUI)
2036    itemElement.appendChild(this.CreateHoverStateElement());
2037   return itemElement;
2038  },
2039  CreateLoadingElement: function(itemElement) {
2040   var element = this.CreateDiv();
2041   element.className = CssClassesConstants.LoadingElement;
2042   return element;
2043  },
2044  CreateHoverStateElement: function (itemElement) {
2045   var element = this.CreateDiv();
2046   element.className = CssClassesConstants.NavigationBarHoverStateElementCssClassName;
2047   element.appendChild(this.CreateDiv());
2048   return element;
2049  },
2050  CreateSelectedStateElement: function () {
2051   this.selectedStateElement = this.CreateDiv();
2052   this.selectedStateElement.appendChild(this.CreateDiv()); 
2053   this.GetSlidePanelElement().appendChild(this.selectedStateElement);
2054  },
2055  PrepareControlHierarchy: function () {
2056   NavigationBarStrategy.prototype.PrepareControlHierarchy.call(this);
2057   ASPx.SetStyles(this.GetSelectedStateElement(), {
2058    className: this.GetImageSlider().thSelCssCl,
2059    cssText: this.GetImageSlider().thSelStyle
2060   });
2061  },
2062  PrepareItemElement: function (index) {
2063   NavigationBarStrategy.prototype.PrepareItemElement.call(this, index);
2064   var stateController = this.GetStateController();
2065   if(this.IsEnabled() && !ASPx.Browser.TouchUI && stateController && this.GetEnableItemHoverState()) {
2066    var itemElement = this.GetItemElement(index);
2067    itemElement.id = this.GetClientControlName() + "_nb_" + index;
2068    stateController.AddHoverItem(itemElement.id, [CssClassesConstants.NavigationBarHoverStateCssClassName], [""], [""], null, null, false);
2069   }
2070  },
2071  GetEnableItemHoverState: function () {
2072   return true;
2073  },
2074  CalculateItemElementSize: function (fakeElement) {
2075   NavigationBarStrategy.prototype.CalculateItemElementSize.call(this, fakeElement);
2076   if(this.IsEnabled() && !ASPx.Browser.TouchUI)
2077    this.CalculateHoverStateElement(fakeElement);
2078   this.CalculateLoadingElement(fakeElement);
2079  },
2080  CalculateHoverStateElement: function (fakeElement) { 
2081   var hoverStateElement = this.CreateHoverStateElement();
2082   fakeElement.appendChild(hoverStateElement);
2083   ASPx.SetStyles(hoverStateElement, { display: "block" });

2084   this.hoverStateElementSize = this.GetBorderBoxSize(hoverStateElement, this.GetItemElementWidth(), this.GetItemElementHeight());
2085   var innerDiv = this.GetFirstChild(hoverStateElement);
2086   this.innerHoverStateElementSize = this.GetBorderBoxSize(innerDiv, this.hoverStateElementSize.width, this.hoverStateElementSize.height);
2087  },
2088  CalculateLoadingElement: function(fakeElement) {
2089   var loadingElement = this.CreateLoadingElement();
2090   fakeElement.appendChild(loadingElement);
2091   this.loadingElenentSize.width = loadingElement.offsetWidth;
2092   this.loadingElenentSize.height = loadingElement.offsetHeight;
2093  },
2094  AdjustControlInternal: function () {
2095   NavigationBarStrategy.prototype.AdjustControlInternal.call(this);
2096   this.AdjustSelectedStateElement();
2097  },
2098  AdjustItemElement: function (index) {
2099   NavigationBarStrategy.prototype.AdjustItemElement.call(this, index);
2100   if(this.IsEnabled() && !ASPx.Browser.TouchUI)
2101    this.AdjustHoverStateElement(index);
2102   this.AdjustLoadingElement(index);
2103  },
2104  AdjustLoadingElement: function(index) {
2105   var loadingElement = this.GetLoadingElement(index);
2106   loadingElement.style.left = (this.GetItemElementWidth() - this.loadingElenentSize.width) / 2 + "px";
2107   loadingElement.style.top = (this.GetItemElementHeight() - this.loadingElenentSize.height) / 2 + "px";
2108  },
2109  AdjustHoverStateElement: function (index) {
2110   var hoverStateElement = this.GetHoverStateElement(index);
2111   ASPx.SetStyles(hoverStateElement, this.hoverStateElementSize);
2112   ASPx.SetStyles(this.GetFirstChild(hoverStateElement), this.innerHoverStateElementSize);
2113  },
2114  AdjustSelectedStateElement: function () {
2115   var selectedStateElement = this.GetSelectedStateElement();
2116   var size = this.GetBorderBoxSize(selectedStateElement, this.GetItemElementWidth(), this.GetItemElementHeight());
2117   ASPx.SetStyles(selectedStateElement, size);
2118   var innerDiv = this.GetFirstChild(selectedStateElement);
2119   size = this.GetBorderBoxSize(selectedStateElement, size.width, size.height);
2120   ASPx.SetStyles(innerDiv, size);
2121  },
2122  GetHoverStateElement: function (index) {
2123   return ASPx.GetChildByClassName(this.GetItemElement(index), CssClassesConstants.NavigationBarHoverStateElementCssClassName);
2124  },
2125  GetLoadingElement: function (index) {
2126   return ASPx.GetChildByClassName(this.GetItemElement(index), CssClassesConstants.LoadingElement);
2127  },
2128  HideLoadingElement: function(index) {
2129   var element = this.GetLoadingElement(index);
2130   if(element)
2131    element.style.display = "none";
2132  },
2133  GetSelectedStateElement: function () {
2134   return this.selectedStateElement;
2135  },
2136  GetItemElementCssClass: function () {
2137   return this.GetImageSlider().thCssCl;
2138  },
2139  GetItemElementStyle: function () {
2140   return this.GetImageSlider().thStyle;
2141  },
2142  CalculateSlideElementPosition: function (index, snapToLeft) {
2143   var prevSlideElementPosition = this.slideElementPosition;
2144   NavigationBarStrategy.prototype.CalculateSlideElementPosition.call(this, index, snapToLeft);
2145   this.slideElementPosition = this.CorrectSelectAndSlideOffsetPosition(index, prevSlideElementPosition, this.slideElementPosition);
2146  },
2147  IsSnapToLeft: function (index) {
2148   var shownItemIndexes = this.GetShownItemIndexes(true);
2149   for(var i = 0; i < shownItemIndexes.length; i++)
2150    if(shownItemIndexes[i] == index)
2151     return i < shownItemIndexes.length / 2;
2152   return index < shownItemIndexes[0];
2153  },
2154  SlideItemsPortionSingleMode: function (backward) {
2155   var considerSize = new Date() - this.lastSlideItemsPortionDate >= 350;
2156   this.PerformSlideToExtremeInvisibleElement(backward, considerSize, backward);
2157   this.lastSlideItemsPortionDate = new Date();
2158  },
2159  PerformSlideToExtremeInvisibleElement: function (backward, considerSize, preventAnimation) {
2160   var shownItemIndexes = this.GetShownItemIndexes(false);
2161   var lastIndex = backward ? -1 : this.GetItemCount();
2162   var incValue = backward ? -1 : 1;
2163   for(var index = shownItemIndexes[backward ? 0 : shownItemIndexes.length - 1]; index != lastIndex; index += incValue)
2164    if(!this.IsVisibleItemElement(index, considerSize)) {
2165     this.SlideToItem(index, preventAnimation);
2166     break;
2167    }
2168  },
2169  GetShownItemIndexes: function (getUncroppedItems) {
2170   var result = [];
2171   var itemSize = this.GetItemElementSize();
2172   var constOffset = this.GetElementTransformPosition(this.GetSlidePanelElement());
2173   var itemFullSize = itemSize + this.GetItemSpacing();
2174   var minValue = getUncroppedItems ? -1 : -itemSize;
2175   var maxValue = getUncroppedItems ? this.GetSlidePanelWrapperSize() - itemSize + 1 : this.GetSlidePanelWrapperSize();
2176   var tempValue = null;
2177   for(var index = 0; index < this.GetItemCount() ; index++) {
2178    tempValue = constOffset + itemFullSize * index;
2179    if(tempValue > minValue && tempValue < maxValue)
2180     result.push(index);
2181   }
2182   return result;
2183  },
2184  OnImageLoad: function (image) {
2185   NavigationBarStrategy.prototype.OnImageLoad.call(this, image);
2186   this.HideLoadingElement(image.dxIndex);
2187  },
2188  CorrectSelectAndSlideOffsetPosition: function (nextItemIndex, prevPos, nextPos) {
2189   var index = this.GetActiveItemIndex();
2190   if(!this.NeedOffsetCorrection() || nextItemIndex == index)
2191    return nextPos;
2192   var itemElementSize = this.GetItemElementSize();
2193   var sliderWrapperSize = this.GetSlidePanelWrapperSize();
2194   if(sliderWrapperSize < (itemElementSize * 3)) {
2195    var offsetDelta = Math.abs(Math.abs(nextPos) - Math.abs(prevPos));
2196    var itemSpacing = this.GetItemSpacing();
2197    var itemPosition = (itemElementSize + itemSpacing) * index;

2198    var itemPositionInSlideWrapper = this.ConvertItemPositionToSlideWrapperPosition(itemPosition) +
2199     (nextItemIndex < index ? offsetDelta : -offsetDelta);
2200    nextPos += (sliderWrapperSize - itemElementSize) / 2 - itemPositionInSlideWrapper;
2201   }
2202   return nextPos;
2203  },
2204  GetBorderBoxSize: function (element, width, height) {
2205   ASPx.SetStyles(element, { width: width, height: height });
2206   if(element.offsetWidth > width)
2207    width -= element.offsetWidth - width;
2208   if(element.offsetHeight > height)
2209    height -= element.offsetHeight - height;
2210   return { width: width, height: height };
2211  },
2212  GetFirstChild: function (parent) {
2213   return parent.children[0];
2214  },
2215  GetSlidePanelWrapperSize: function () {
2216   return this.GetElementSize(this.GetSlidePanelWrapperElement());
2217  },
2218  GetNavigationBarElementsStyles: function () {
2219   var styles = NavigationBarStrategy.prototype.GetNavigationBarElementsStyles.call(this);
2220   if(this.GetNavigationButtonsPosition() == NavigationBarButtonPositionEnum.Outside && this.navigationButtons) {
2221    var prevButtonSize = this.navigationButtons.GetPrevButtonWrapperSize();
2222    var nextButtonSize = this.navigationButtons.GetNextButtonWrapperSize();
2223    var isHorizontal = this.IsHorizontalNavigation();
2224    var styleName = isHorizontal ? "width" : "height";
2225    if(this.CanUseVisibleItemCount())
2226     styles.navBarStyle[styleName] += prevButtonSize[styleName] + nextButtonSize[styleName];
2227    else
2228     styles.wrapperStyle[styleName] -= prevButtonSize[styleName] + nextButtonSize[styleName];
2229    styles.wrapperStyle[isHorizontal ? "left" : "top"] = prevButtonSize[styleName];
2230   }
2231   return styles;
2232  }
2233 });
2234 var NavigationBarDotsStrategy = ASPx.CreateClass(NavigationBarStrategy, {
2235  constructor: function (imageSlider) {
2236   this.cloneElement = null;
2237   this.constructor.prototype.constructor.call(this, imageSlider);
2238  },
2239  Initialize: function () {
2240   NavigationBarStrategy.prototype.Initialize.call(this);
2241   this.cloneElement = ASPx.CreateHtmlElementFromString(this.GetImageSlider().dbh);
2242  },
2243  SetActiveItemVisually: function (index, preventAnimation) {
2244   var stateController = this.GetStateController();
2245   if(stateController) {
2246    if(this.GetPrevItemIndex() != -1)
2247     stateController.DeselectElementBySrcElement(this.GetItemElement(this.GetPrevItemIndex()));
2248    stateController.SelectElementBySrcElement(this.GetItemElement(index));
2249   }
2250  },
2251  GetImageLoadMode: function () {
2252   return LoadModeEnum.AllImages;
2253  },
2254  OnNavigationBarMouseUp: function (evt) {
2255   ASPx.ClearHoverState();
2256   NavigationBarStrategy.prototype.OnNavigationBarMouseUp.call(this, evt);
2257  },
2258  CanCandleMouseUpEvent: function (evt) {
2259   if(ASPx.Browser.IE && ASPx.Browser.Version < 9)
2260    return !this.IsExecutedGesture();
2261   return NavigationBarStrategy.prototype.CanCandleMouseUpEvent.call(this, evt);
2262  }, 
2263  GetMouseUpEventName: function () {
2264   return ASPx.Browser.IE && ASPx.Browser.Version < 9 ? "click" : ASPx.TouchUIHelper.touchMouseUpEventName; 
2265  },
2266  GetNavigationBtnsVisibilityMode: function () {
2267   return ElementVisibilityModeEnum.None;
2268  },
2269  CreateItemElement: function (index) {
2270   var itemElement = this.CreateDiv();
2271   itemElement.id = this.GetItemElementId(index);
2272   return itemElement;
2273  },
2274  PrepareControlHierarchy: function () {
2275   NavigationBarStrategy.prototype.PrepareControlHierarchy.call(this);
2276   var imageSlider = this.GetImageSlider();
2277   var stateController = this.GetStateController();
2278   if(!stateController)
2279    return;
2280   this.ForEachItem(function (i) {
2281    if(this.IsEnabled()) {
2282     stateController.AddHoverItem(this.GetItemElementId(i), [imageSlider.dotHCssCl], [imageSlider.dotHStyle],
2283      null, [imageSlider.dotHSprt], [""], false);
2284     stateController.AddPressedItem(this.GetItemElementId(i), [imageSlider.dotPCssCl], [imageSlider.dotPStyle],
2285      null, [imageSlider.dotPSprt], [""], false);
2286    }
2287    stateController.AddSelectedItem(this.GetItemElementId(i), [imageSlider.dotSCssCl], [imageSlider.dotSStyle],
2288     null, [imageSlider.dotSSprt], [""], false);
2289   });
2290  },
2291  AdjustImageElement: function (index) {
2292  },
2293  GetItemElementCssClass: function () {
2294   return this.cloneElement.className;
2295  },
2296  GetItemElementStyle: function () {
2297   return this.cloneElement.style.cssText;
2298  },
2299  GetItemElementId: function (index) {
2300   return this.GetClientControlName() + "_dot_" + index;
2301  }
2302 });
2303 var ItemElementsManagerBase = ASPx.CreateClass(null, {
2304  constructor: function (itemsOwner) {
2305   this.itemsOwner = itemsOwner;
2306   this.timerId = -1;
2307   this.itemCollection = [];
2308  },
2309  GetOwner: function () {
2310   return this.itemsOwner;
2311  },
2312  GetCollection: function () {

2313   if(this.IsEnablePartialLoading())
2314    return this.itemCollection;
2315   return ASPx.GetChildNodesByTagName(this.GetOwner().GetItemsContainer(), "DIV");
2316  },
2317  HasItem: function (index) {
2318   return !!this.GetCollection()[index];
2319  },
2320  SaveItem: function (index, item) {
2321   if(this.IsEnablePartialLoading())
2322    this.itemCollection[index] = item;
2323  },
2324  GetImageLoadMode: function () {
2325   return this.GetOwner().GetImageLoadMode();
2326  },
2327  IsEnablePartialLoading: function () {
2328   return this.GetImageLoadMode() != LoadModeEnum.AllImages;
2329  },
2330  CreateItemsIfRequired: function () {
2331   if(this.GetImageLoadMode() == LoadModeEnum.AllImages)
2332    this.GetOwner().CreateItemElements();
2333  },
2334  PrepareItemsIfRequired: function () {
2335   if(this.GetImageLoadMode() == LoadModeEnum.AllImages)
2336    this.GetOwner().PrepareItemElements();
2337  },
2338  AdjustItemsIfRequired: function () {
2339   var owner = this.GetOwner();
2340   for(var i = 0; i < owner.GetItemCount() ; i++) {
2341    if(this.IsEnablePartialLoading() && !this.HasItem(i))
2342     continue;
2343    this.GetOwner().AdjustItemElement(i);
2344    this.GetOwner().AdjustImageElement(i);
2345   }
2346  },
2347  UpdateHierarchyIfRequired: function () {
2348   if(this.IsEnablePartialLoading()) {
2349    this.timerId = ASPx.Timer.ClearTimer(this.timerId);
2350    this.UpdateHierarchyCore();
2351   }
2352  },
2353  CreateItemAndAppend: function (index, parent) {
2354   var owner = this.GetOwner();
2355   var element = owner.CreateItemElement(index);
2356   this.SaveItem(index, element);
2357   parent.appendChild(element);
2358   owner.PrepareItemElement(index);
2359   owner.AdjustItemElement(index);
2360   owner.AdjustImageElement(index);
2361   if(owner.GetImageSlider().HasTemplates())
2362    owner.CreateTemplate(index);
2363  },
2364  RemoveItem: function (index) {
2365   if(this.GetImageLoadMode() == LoadModeEnum.DynamicLoadAndCache)
2366    return;
2367   var owner = this.GetOwner();
2368   var element = owner.GetItemElement(index);
2369   if(element) {
2370    var image = owner.GetImageElement(index);
2371    if(image)
2372     owner.DetachLoadEvents(image);
2373    this.itemCollection[index] = undefined;
2374    ASPx.RemoveElement(element);
2375   }
2376  },
2377  UpdateHierarchyCore: function () {
2378  },
2379  GetDelay: function () {
2380   return 450;
2381  },
2382  UpdateHierarchyAfterDelayIfRequired: function () {
2383   if(this.IsEnablePartialLoading() && this.timerId == -1)
2384    this.timerId = window.setTimeout(function () { this.UpdateHierarchyIfRequired(); }.aspxBind(this), this.GetDelay());
2385  }
2386 });
2387 var ImageAreaItemElementsManager = ASPx.CreateClass(ItemElementsManagerBase, {
2388  constructor: function (imageAreaStrategy) {
2389   this.constructor.prototype.constructor.call(this, imageAreaStrategy);
2390  },
2391  GetDelay: function () {
2392   return this.GetOwner().GetImageSlider().animationDuration + 50;
2393  },
2394  UpdateHierarchyCore: function () {
2395   var owner = this.GetOwner();
2396   var activeItemIndex = owner.GetActiveItemIndex();
2397   var prevItemIndex = owner.GetPrevItemIndex();
2398   if(prevItemIndex == -1) 
2399    prevItemIndex = 0;
2400   var isForwardDirection = (activeItemIndex - prevItemIndex) >= 0;
2401   var fragment = owner.CreateDocumentFragment();
2402   var itemsContainer = owner.GetItemsContainer();
2403   if(!this.HasItem(activeItemIndex))
2404    this.CreateItemAndAppend(activeItemIndex, fragment || itemsContainer);
2405   if(this.CanUpdateItemElements(isForwardDirection, isForwardDirection ? activeItemIndex + 1 : activeItemIndex - 1)) {
2406    for(var i = 0; i < owner.GetItemCount() ; i++) {
2407     if(this.CanRemoveItem(i, activeItemIndex, prevItemIndex, isForwardDirection))
2408      this.RemoveItem(i);
2409     else if(!this.HasItem(i))
2410      this.CreateItemAndAppend(i, fragment || itemsContainer);
2411    }
2412   }
2413   if(fragment)
2414    itemsContainer.appendChild(fragment);
2415  },
2416  CanRemoveItem: function (index, activeItemIndex, prevItemIndex, forwardDirection) {
2417   var visibleItemCount = 6;
2418   var result = forwardDirection ? (index < activeItemIndex || index > (activeItemIndex + visibleItemCount)) :
2419     (index > activeItemIndex || index < (activeItemIndex - visibleItemCount));
2420   return result && prevItemIndex != index; 
2421  },
2422  CanUpdateItemElements: function (forwardDirection, followingItemIndex) {
2423   return forwardDirection ? followingItemIndex < this.GetOwner().GetItemCount() && !this.HasItem(followingItemIndex) :
2424    followingItemIndex > 0 && !this.HasItem(followingItemIndex);
2425  }
2426 });
2427 var LoopImageAreaItemElementsManager = ASPx.CreateClass(ItemElementsManagerBase, {
2428  constructor: function (imageAreaStrategy) {
2429   this.constructor.prototype.constructor.call(this, imageAreaStrategy);
2430  },
2431  UpdateHierarchyCore: function () {
2432   var owner = this.GetOwner();
2433   var activeIndex = owner.GetActiveItemIndex();
2434   var fragment = owner.CreateDocumentFragment();
2435   var itemsContainer = owner.GetItemsContainer();
2436   if(!this.HasItem(activeIndex))
2437    this.CreateItemAndAppend(activeIndex, fragment || itemsContainer);
2438   var activeItem = owner.GetItemElement(activeIndex);
2439   var nextIndex = activeIndex + 1;
2440   if(nextIndex == owner.GetItemCount())
2441    nextIndex = 0;
2442   if(!this.HasItem(nextIndex)) {
2443    this.CreateItemAndAppend(nextIndex, fragment || itemsContainer);
2444    var item = owner.GetItemElement(nextIndex);
2445    item.dxPosition = activeItem.dxPosition + owner.GetItemElementSize();
2446    owner.SetItemPosition(item);
2447   }
2448   var prevIndex = activeIndex - 1;
2449   var prevIndex = activeIndex - 1;
2450   if(prevIndex < 0)
2451    prevIndex = owner.GetItemCount() - 1;
2452   if(!this.HasItem(prevIndex)) {
2453    this.CreateItemAndAppend(prevIndex, fragment || itemsContainer);
2454    var item = owner.GetItemElement(prevIndex);
2455    item.dxPosition = activeItem.dxPosition - owner.GetItemElementSize();
2456    owner.SetItemPosition(item);
2457   }
2458   for(var i = 0; i < owner.GetItemCount() ; i++)
2459    if(i != activeIndex && i != prevIndex && i != nextIndex && owner.GetPrevItemIndex() != i && owner.GetItemElement(i))
2460     this.RemoveItem(i);
2461   if(fragment)
2462    itemsContainer.appendChild(fragment);
2463  }
2464 });
2465 var NavigationBarItemElementsManager = ASPx.CreateClass(ItemElementsManagerBase, {
2466  constructor: function (navigationBarStrategy) {
2467   this.constructor.prototype.constructor.call(this, navigationBarStrategy);
2468  },
2469  CreateDummyItem: function (index, parent) {
2470   if(!this.HasItem(index))
2471    this.CreateAndPrepareItemElement(index, parent);
2472   else if(this.GetImageLoadMode() != LoadModeEnum.DynamicLoadAndCache) {
2473    var owner = this.GetOwner();
2474    var element = owner.GetItemElement(index);
2475    if(element) {
2476     element.style.backgroundImage = "";
2477     var image = owner.GetImageElement(index);
2478     if(image)
2479      owner.DetachLoadEvents(image);
2480     ASPx.RemoveElement(image);
2481     ASPx.RemoveElement(owner.GetCanvasElement(index));
2482     var el = owner.GetLoadingElement(index);
2483     if(el) el.style.display = "";
2484    }
2485    this.SetDummyFlagToElement(index, true);
2486   }
2487  },
2488  SetDummyFlagToElement: function (index, isDummy) {
2489   var element = this.GetOwner().GetItemElement(index);
2490   if(element)
2491    element.isDummy = isDummy;
2492  },
2493  IsElementDummy: function (index) {
2494   var element = this.GetOwner().GetItemElement(index);
2495   if(element)
2496    return !!element.isDummy;
2497   return false;
2498  },
2499  CreateItemAndAppend: function (index, parent) {
2500   if(!this.HasItem(index))
2501    this.CreateAndPrepareItemElement(index, parent);
2502   if(this.IsElementDummy(index)) {
2503    this.SetDummyFlagToElement(index, false);
2504    this.GetOwner().UpdateItemElement(index);
2505   }
2506  },
2507  CreateAndPrepareItemElement: function (index, parent) {
2508   var owner = this.GetOwner();
2509   var element = owner.CreateItemElement(index);
2510   this.SaveItem(index, element);
2511   parent.appendChild(element);
2512   owner.PrepareItemElement(index);
2513   owner.AdjustItemElement(index);
2514   this.SetDummyFlagToElement(index, true);
2515  },
2516  UpdateHierarchyCore: function () {
2517   var owner = this.GetOwner();
2518   var navigationBarSize = owner.GetElementSize(owner.GetSlidePanelWrapperElement()),
2519    slidePanelPosition = owner.GetElementTransformPosition(owner.GetSlidePanelElement());
2520   var fragment = owner.CreateDocumentFragment();
2521   var itemsContainer = owner.GetItemsContainer();
2522   var itemFullSize = owner.GetItemElementSize() + owner.GetItemSpacing();
2523   var lPos = Math.min(-navigationBarSize * 0.3, -itemFullSize);
2524   var rPos = Math.max(navigationBarSize * 1.3, navigationBarSize + itemFullSize);
2525   var lDummyPos = lPos - navigationBarSize;
2526   var rDummyPos = rPos + navigationBarSize;
2527   var itemPos = 0;
2528   for(var i = 0; i < owner.GetItemCount() ; i++) {
2529    itemPos = slidePanelPosition + itemFullSize * i;
2530    if(itemPos > lDummyPos && itemPos < rDummyPos && (itemPos < lPos || itemPos > rPos))
2531     this.CreateDummyItem(i, fragment || itemsContainer);
2532    else {
2533     if(itemPos <= lDummyPos || itemPos >= rDummyPos)
2534      this.RemoveItem(i);
2535     else
2536      this.CreateItemAndAppend(i, fragment || itemsContainer);
2537    }
2538   }
2539   if(fragment)
2540    itemsContainer.appendChild(fragment);
2541  }
2542 });
2543 var ASPxClientImageSlider = ASPx.CreateClass(ASPxClientControl, {
2544  constructor: function (name) {
2545   this.constructor.prototype.constructor.call(this, name);
2546   this.activeItemIndex = 0;
2547   this.imageAreaStrategy = null; 
2548   this.navigationBarStrategy = null; 
2549   this.passePartoutElement = null;
2550   this.hiddenField = null;
2551   this.pendingItemsTimerID = -1;
2552   this.slideShowEnabled = false;
2553   this.templateCreated = false;
2554   this.timerID = -1;
2555   this.defaultControlSize = { width: "", height: "" };
2556   this.showImageArea = true;
2557   this.showNavBar = true;
2558   this.seoFriendlyItems = {};
2559   this.items = {}; 
2560   this.itemsPerRequest = 0;
2561   this.enableLoopNavigation = false;
2562   this.enableKeyboardSupport = true;
2563   this.enablePagingByClick = true;
2564   this.enablePagingGestures = true;
2565   this.extremeItemClickMode = 0;
2566   this.animationDuration = 400;
2567   this.allowMouseWheel = false;
2568   this.imageLoadMode = 1;
2569   this.imageSizeMode = ASPx.ImageControlUtils.ImageSizeModeEnum.ActualSizeOrFit;
2570   this.thumbImageSizeMode = ASPx.ImageControlUtils.ImageSizeModeEnum.FitAndCrop;
2571   this.animationType = 0;
2572   this.navDirection = 0;
2573   this.itemSpacing = 5;
2574   this.target = "";
2575   this.hasNavigateUrls = false;
2576   this.hasTemplates = false;
2577   this.navBtnsVbl = 2;
2578   this.itemTxtVbl = 3;
2579   this.interval = 5000;
2580   this.autoPlay = false;
2581   this.stopPlayingWhenPaging = false;
2582   this.stopPlayingWhenPagingExecuted = false;
2583   this.pausePlayingWhenMouseOver = false;
2584   this.playPauseBtnVbl = 0;
2585   this.visibleStartIndex = 0;
2586   this.visibleItemsCount = 0;
2587   this.navBarPos = 0;
2588   this.navBarPagingMode = 0;
2589   this.thumbNavBtnsVbl = 2;
2590   this.thumbNavBtnsPos = 0;
2591   this.navBarOffset = 0;
2592   this.passePartoutStyle = "";
2593   this.imgAreaCssCl = "";
2594   this.imgAreaStyle = "";
2595   this.itemCssCl = "";
2596   this.itemStyle = "";
2597   this.navBarCssCl = "";
2598   this.navBarStyle = "";
2599   this.thCssCl = "";
2600   this.thStyle = "";
2601   this.thSelCssCl = "";
2602   this.thSelStyle = "";
2603   this.itemTxtCssCl = "";
2604   this.itemTxtStyle = "";
2605   this.dotHSprt = null;
2606   this.dotHCssCl = "";
2607   this.dotHStyle = "";
2608   this.dotPSprt = null;
2609   this.dotPCssCl = "";
2610   this.dotPStyle = "";
2611   this.dotSSprt = null;
2612   this.dotSCssCl = "";
2613   this.dotSStyle = "";
2614   this.dbh = "";
2615   this.playBH = "";
2616   this.pauseBH = "";
2617   this.pbh = "";
2618   this.nbh = "";
2619   this.nbpbh = "";
2620   this.nbnbh = "";
2621   this.sizingConfig.adjustControl = true;
2622   this.disableSelectedStateAnimation = false;

2623   this.ActiveItemChanged = new ASPxClientEvent();
2624   this.ItemClick = new ASPxClientEvent();
2625   this.ThumbnailItemClick = new ASPxClientEvent();
2626   this.ItemLoadedOnCallback = new ASPxClientEvent();
2627   this.StrategiesCreated = new ASPxClientEvent();
2628  },
2629  InlineInitialize: function () {
2630   ASPxClientControl.prototype.InlineInitialize.call(this);
2631   this.PopulateItemsSeoMode();
2632  },
2633  Initialize: function () {
2634   ASPxClientControl.prototype.Initialize.call(this);
2635   if(this.hasTemplates)
2636    for(var key in this.seoFriendlyItems) {
2637     if(!this.seoFriendlyItems.hasOwnProperty(key)) continue;
2638     if(!this.items[key])
2639      this.items[key] = {};
2640     var item = this.items[key],
2641      seoFriendlyItem = this.seoFriendlyItems[key];
2642     item.s = seoFriendlyItem.s;
2643     item.ts = seoFriendlyItem.ts;
2644     item.t = seoFriendlyItem.t;
2645     item.u = seoFriendlyItem.u;
2646    }
2647   this.seoFriendlyItems = null;
2648   this.CreateControlHierarchy();
2649   this.PrepareControlHierarchy();
2650   this.InitializeElementsSize();
2651  },
2652  PopulateItemsSeoMode: function () {
2653   var elements = ASPx.GetNodesByTagName(this.GetMainElement(), "IMG");
2654   if(elements.length > 0)
2655    this.populateItemCollection(elements, this.hasTemplates ? this.seoFriendlyItems : this.items);
2656  },
2657  populateItemCollection: function(imageCollection, itemsCollection, image) {
2658   var index = this.visibleStartIndex;
2659   while(image = imageCollection[0]) {
2660    var collectionItem = (itemsCollection[index] || (itemsCollection[index] = {}));
2661    collectionItem.s = ASPx.Attr.GetAttribute(image, "src");
2662    collectionItem.t = ASPx.Attr.GetAttribute(image, "alt");
2663    if(image.parentNode.tagName == "A") {
2664     collectionItem.u = ASPx.Attr.GetAttribute(image.parentNode, "href");
2665     ASPx.RemoveElement(image.parentNode);
2666    } else 
2667     ASPx.RemoveElement(image);
2668    index++;
2669   }
2670  },
2671  InitializeElementsSize: function () {
2672   var mainElement = this.GetMainElement();
2673   this.defaultControlSize = {
2674    width: mainElement.style.width,
2675    height: mainElement.style.height
2676   };
2677  },
2678  AfterInitialize: function () {
2679   ASPxClientControl.prototype.AfterInitialize.call(this);
2680   this.InitializeHandlers();
2681   this.EnsureShownItemsLoaded();
2682  },
2683  InitializeHandlers: function () {
2684   if(ASPx.Browser.TouchUI)
2685    return;
2686   if(this.enableKeyboardSupport) {
2687    var element = this.GetMainElement();
2688    ASPx.Evt.AttachEventToElement(element, "keydown", function (evt) { this.OnKeyDown(evt); }.aspxBind(this));
2689    ASPx.Evt.AttachEventToElement(element, "mousedown", function(evt) {
2690     if(!ASPx.Ident.IsFocusableElementRegardlessTabIndex(ASPx.Evt.GetEventSource(evt)))
2691      this.Focus();
2692    }.aspxBind(this));
2693   }
2694   if(this.pausePlayingWhenMouseOver)
2695    MouseEnterHelper.AddHandler(this.GetMainElement(), function () {
2696     if(this.slideShowEnabled)
2697      this.PauseInternal();
2698    }.aspxBind(this), function () {
2699     if(this.slideShowEnabled && !this.stopPlayingWhenPagingExecuted)
2700      this.PlayInternal();
2701    }.aspxBind(this));
2702  },
2703  GetNavigationBarOffset: function(){
2704   var offset = 0;
2705   var navigationBar = this.GetNavigationBarStrategy();
2706   if(navigationBar) 
2707    offset = navigationBar.GetSlideElementPosition();
2708   return isNaN(offset) ? 0 : offset;
2709  },
2710  UpdateStateObject: function(){
2711   this.UpdateStateObjectWithObject({ activeItemIndex: this.GetActiveItemIndex(), navigationBarOffset: this.GetNavigationBarOffset() });
2712  },
2713  CreateTemplates: function () {
2714   var imageArea = this.GetImageAreaStrategy();
2715   if(imageArea)
2716    imageArea.CreateTemplates();
2717   var navigationBar = this.GetNavigationBarStrategy();
2718   if(navigationBar)
2719    navigationBar.CreateTemplates();
2720   ASPx.ProcessScriptsAndLinks(this.name);
2721   this.templateCreated = true;
2722  },
2723  AdjustControlCore: function () {
2724   this.AdjustControlCoreInternal();
2725   if(this.HasTemplates() && !this.templateCreated)
2726    window.setTimeout(function () { this.CreateTemplates(); }.aspxBind(this), 0);
2727  },
2728  SetSizeCore: function(sizePropertyName, size, getFunctionName, corrected) {
2729   this.defaultControlSize[sizePropertyName] = size;
2730   ASPxClientControl.prototype.SetSizeCore.call(this, sizePropertyName, size, getFunctionName, corrected);
2731  },
2732  AdjustControlCoreInternal: function () {
2733   this.AllowRubberLayout();
2734   var mainElementStyle = {
2735    width: SizeUtils.GetClientWidth(this.GetMainElement(), true),
2736    height: SizeUtils.GetClientHeight(this.GetMainElement(), true)
2737   };
2738   var passePartourStyle = {
2739    width: mainElementStyle.width,
2740    height: mainElementStyle.height
2741   };
2742   this.AdjustNavigationBar(mainElementStyle, passePartourStyle);
2743   this.AdjustImageArea(mainElementStyle, passePartourStyle);
2744   this.ensureSizesAreValid(mainElementStyle);
2745   ASPx.SetStyles(this.GetMainElement(), mainElementStyle);
2746   if(this.showImageArea)
2747    ASPx.SetStyles(this.GetPassePartoutElement(), passePartourStyle);
2748   this.DenyRubberLayout();
2749  },
2750  AdjustNavigationBar: function (mainElementStyle, passePartourStyle) {
2751   var navigationBar = this.GetNavigationBarStrategy();
2752   if(navigationBar) {
2753    navigationBar.AdjustControl();
2754    var width = navigationBar.GetWidth();
2755    var height = navigationBar.GetHeight();
2756    if(this.showImageArea) {
2757     switch (this.GetNavigationBarPosition()) {
2758      case NavigationBarPositionEnum.Right:
2759      case NavigationBarPositionEnum.Left:
2760       passePartourStyle.float = "left";
2761       passePartourStyle.width -= width;
2762       break;
2763      case NavigationBarPositionEnum.Bottom:
2764      case NavigationBarPositionEnum.Top:
2765       passePartourStyle.height -= height;
2766       break;
2767     }
2768    }
2769    else {
2770     mainElementStyle.width = width;
2771     mainElementStyle.height = height;
2772    }
2773   }
2774  },
2775  AdjustImageArea: function (mainElementStyle, passePartourStyle) {
2776   var imageAreaStrategy = this.GetImageAreaStrategy();
2777   if(imageAreaStrategy) {
2778    imageAreaStrategy.AdjustControl(passePartourStyle.width, passePartourStyle.height);
2779    var imageAreaWidth = imageAreaStrategy.GetWidth();
2780    var imageAreaHeight = imageAreaStrategy.GetHeight();
2781    var navigationBar = this.GetNavigationBarStrategy();
2782    var navigationBarWidth = navigationBar ? navigationBar.GetWidth() : 0;
2783    var navigationBarHeight = navigationBar ? navigationBar.GetHeight() : 0;
2784    var useHorizLayout = this.GetNavigationBarPosition() == NavigationBarPositionEnum.Left
2785     || this.GetNavigationBarPosition() == NavigationBarPositionEnum.Right;
2786    if(imageAreaWidth > passePartourStyle.width) {
2787     var widthCorrection = useHorizLayout ? navigationBarWidth : 0;
2788     passePartourStyle.width = imageAreaWidth;
2789     mainElementStyle.width = imageAreaWidth + widthCorrection;
2790    }
2791    if(imageAreaHeight > passePartourStyle.height) {
2792     var heightCorrection = !useHorizLayout ? navigationBarHeight : 0;
2793     passePartourStyle.height = imageAreaHeight;

2794     mainElementStyle.height = imageAreaHeight + heightCorrection;
2795    }
2796   }
2797  },
2798  AllowRubberLayout: function () {
2799   this.ResetControlStyle();
2800   ASPx.SetStyles(this.GetMainElement(), {
2801    borderSpacing: 0,
2802    overflow: "hidden",
2803    display: "table" 
2804   });
2805   if(this.showImageArea)
2806    ASPx.SetStyles(this.GetPassePartoutElement(), { width: "", height: "" });
2807  },
2808  DenyRubberLayout: function () {
2809   ASPx.SetStyles(this.GetMainElement(), {
2810    display: "",
2811    overflow: "",
2812    borderSpacing: ""
2813   });
2814   if(this.showImageArea)
2815    ASPx.SetStyles(this.GetPassePartoutElement(), { display: "" });
2816  },
2817  ResetControlStyle: function () {
2818   ASPx.SetStyles(this.GetMainElement(), this.defaultControlSize);
2819   var navigationBar = this.GetNavigationBarStrategy();
2820   if(navigationBar)
2821    navigationBar.ResetControlStyle();
2822   var imageAreaStrategy = this.GetImageAreaStrategy();
2823   if(imageAreaStrategy)
2824    imageAreaStrategy.ResetControlStyle();
2825  },
2826  ensureSizesAreValid: function(style) {
2827   if(style.width <= 0)
2828    style.width = 1;
2829   if(style.height <= 0)
2830    style.height = 1;
2831  },
2832  CreateControlHierarchy: function () {
2833   if(this.showImageArea) {
2834    this.passePartoutElement = document.createElement("DIV");
2835    this.GetMainElement().appendChild(this.passePartoutElement);
2836    this.imageAreaStrategy = this.CreateImageAreaStrategy();
2837   }
2838   if(this.showNavBar)
2839    this.navigationBarStrategy = this.CreateNavigationBarStrategy();
2840   this.RaiseStrategiesCreated();
2841  },
2842  CreateImageAreaStrategy: function () {
2843   switch (this.GetAnimationType()) {
2844    case AnimationTypeEnum.Slide:
2845     return this.CreateSlideImageAreaStrategy();
2846    case AnimationTypeEnum.Fade:
2847     return new FadeImageAreaStrategy(this);
2848    case AnimationTypeEnum.None:
2849     return new NoneImageAreaStrategy(this);
2850   }
2851  },
2852  CreateSlideImageAreaStrategy: function () {
2853   return this.enableLoopNavigation ? new SlideLoopNavigationImageAreaStrategy(this) : new SlideImageAreaStrategy(this);
2854  },
2855  CreateNavigationBarStrategy: function () {
2856   switch (this.GetNavigationBarMode()) {
2857    case NavigationBarModeEnum.Thumbnails:
2858     return new NavigationBarThumbnailStrategy(this);
2859    case NavigationBarModeEnum.Dots:
2860     return new NavigationBarDotsStrategy(this);
2861   }
2862  },
2863  PrepareControlHierarchy: function () {
2864   this.PrepareMainElement();
2865   if(this.showImageArea)
2866    this.PreparePassePartoutElement();
2867   if(this.autoPlay)
2868    this.Play();
2869  },
2870  PrepareMainElement: function () {
2871   var mainElement = this.GetMainElement();
2872   mainElement.tabIndex = Math.max(mainElement.tabIndex, 0);
2873   ASPx.SetElementDisplay(mainElement, true);
2874  },
2875  PreparePassePartoutElement: function () {
2876   ASPx.SetStyles(this.GetPassePartoutElement(), {
2877    cssText: this.passePartoutStyle,
2878    className: CssClassesConstants.PassePartoutCssClassName
2879   });
2880  },
2881  OnBrowserWindowResize: function(e) {
2882   this.AdjustControl();
2883  },
2884  OnKeyDown: function(evt) {
2885   if(!this.IsFocused())
2886    return;
2887   var keyKode = ASPx.Evt.GetKeyCode(evt);
2888   switch (keyKode) {
2889    case ASPx.Key.Left:
2890     var index = this.rtl ? this.GetActiveItemIndex() + 1 : this.GetActiveItemIndex() - 1;
2891     this.SetActiveItemIndex(index);
2892     return ASPx.Evt.PreventEvent(evt);
2893    case ASPx.Key.Up:
2894     this.SetActiveItemIndex(this.GetActiveItemIndex() - 1);
2895     return ASPx.Evt.PreventEvent(evt);
2896    case ASPx.Key.Right:
2897     var index = this.rtl ? this.GetActiveItemIndex() - 1 : this.GetActiveItemIndex() + 1;
2898     this.SetActiveItemIndex(index);
2899     return ASPx.Evt.PreventEvent(evt);
2900    case ASPx.Key.Down:
2901     this.SetActiveItemIndex(this.GetActiveItemIndex() + 1);
2902     return ASPx.Evt.PreventEvent(evt);
2903    case ASPx.Key.Home:
2904     this.SetActiveItemIndex(0);
2905     return ASPx.Evt.PreventEvent(evt);
2906    case ASPx.Key.End:
2907     this.SetActiveItemIndex(this.GetItemCount() - 1);
2908     return ASPx.Evt.PreventEvent(evt);
2909   }
2910  },
2911  OnCallback: function(result) {
2912   if(result.items)
2913    this.ProcessCreatedItems(result.items);
2914  },
2915  GetImageAreaStrategy: function () {
2916   return this.imageAreaStrategy;
2917  },
2918  GetNavigationBarStrategy: function () {
2919   return this.navigationBarStrategy;
2920  },
2921  GetPassePartoutElement: function () {
2922   return this.passePartoutElement;
2923  },
2924  GetItem: function(index, forceLoad) {
2925   var item = this.GetItemInternal(index);
2926   if(item) {
2927    var isLoaded = !item.skipped && !item.pending;
2928    if(forceLoad && !isLoaded)
2929     this.LoadItemsViaCallback([index]);
2930    return new ASPxClientImageSliderItem(this, index, item.n, item.s, item.t, isLoaded);
2931   }
2932   return null;
2933  },
2934  GetItemByName: function(name, forceLoad) {
2935   for(var i = 0; i < this.GetItemCount(); i++) {
2936    if(this.GetItemInternal(i).n == name)
2937     return this.GetItem(i, forceLoad);
2938   }
2939   if(forceLoad)
2940    this.DoLoadItemsViaCallback(null, [name]);
2941   return null;
2942  },
2943  GetActiveItemIndex: function () {
2944   return this.GetRtlIndex(this.GetActiveItemIndexInternal());
2945  },
2946  SetActiveItemIndex: function (index, preventAnimation, isAPICall) {

2947   this.SetActiveItemIndexInternal(this.GetRtlIndex(index), preventAnimation, isAPICall);
2948  },
2949  GetActiveItem: function () {
2950   return this.GetItem(this.GetActiveItemIndex());
2951  },
2952  SetActiveItem: function (item, preventAnimation) {
2953   this.SetActiveItemIndex(item.index, preventAnimation);
2954  },
2955  GetItemCount: function () {
2956   return this.itemsCount;
2957  },
2958  GetLoadedItems: function() {
2959   var itemsCount = this.GetItemCount(),
2960    result = [];
2961   for(var i = 0; i < itemsCount; i++) {
2962    var item = this.GetItem(i);
2963    if(item.loaded)
2964     result.push(item);
2965   }
2966   return result;
2967  },
2968  Focus: function () {
2969   if(!ASPx.Browser.TouchUI && this.enableKeyboardSupport)
2970    ASPx.SetFocus(this.GetMainElement());
2971  },
2972  Play: function () {
2973   if(this.enabled) {
2974    this.PlayInternal();
2975    this.slideShowEnabled = true;
2976   }
2977  },
2978  Pause: function () {
2979   if(this.enabled) {
2980    this.PauseInternal();
2981    this.slideShowEnabled = false;
2982   }
2983  },
2984  IsSlideShowPlaying: function () {
2985   return this.timerID != -1;
2986  },
2987  IsFocused: function () {
2988   return ASPx.GetActiveElement() == this.GetMainElement();
2989  },
2990  PlayInternal: function () {
2991   if(this.IsSlideShowPlaying())
2992    return;
2993   this.timerID = window.setInterval(function () { this.DoSeActivetNextItem(); }.aspxBind(this), this.interval);
2994   this.stopPlayingWhenPagingExecuted = false;
2995   if(this.GetImageAreaStrategy())
2996    this.GetImageAreaStrategy().SetSlideShowButtonState(false);
2997  },
2998  PauseInternal: function () {
2999   this.timerID = ASPx.Timer.ClearInterval(this.timerID);
3000   if(this.GetImageAreaStrategy())
3001    this.GetImageAreaStrategy().SetSlideShowButtonState(true);
3002  },
3003  ResetSlideShowTimer: function () {
3004   if(this.IsSlideShowPlaying()) {
3005    this.timerID = ASPx.Timer.ClearInterval(this.timerID);
3006    this.timerID = window.setInterval(function () { this.DoSeActivetNextItem(); }.aspxBind(this), this.interval);
3007   }
3008  },
3009  StopPlayingWhenPaging: function () {
3010   if(this.stopPlayingWhenPaging) {
3011    this.Pause();
3012    this.stopPlayingWhenPagingExecuted = true;
3013   }
3014  },
3015  DoSeActivetNextItem: function () {
3016   var activeIndex = this.GetActiveItemIndex() + 1;
3017   if(activeIndex >= this.GetItemCount())
3018    activeIndex = 0;

3019   this.SetActiveItemIndex(activeIndex);
3020  },
3021  RaiseStrategiesCreated: function () {
3022   if(!this.StrategiesCreated.IsEmpty())
3023    this.StrategiesCreated.FireEvent(this, null);
3024  },
3025  RaiseActiveItemChanged: function () {
3026   this.RaiseItemEvent(this.ActiveItemChanged);
3027  },
3028  RaiseItemClick: function () {
3029   this.RaiseItemEvent(this.ItemClick);
3030  },
3031  RaiseThumbnailItemClick: function () {
3032   this.RaiseItemEvent(this.ThumbnailItemClick);
3033  },
3034  RaiseItemLoadedOnCallback: function(item) {
3035   this.RaiseItemEvent(this.ItemLoadedOnCallback, item);
3036  },
3037  RaiseItemEvent: function(event, item) {
3038   if(!event.IsEmpty()) {
3039    var args = new ASPxClientImageSliderItemEventArgs(item || this.GetActiveItem());
3040    event.FireEvent(this, args);
3041   }
3042  },
3043  SetActiveItemIndexInternal: function (index, preventAnimation, isAPICall) {
3044   if(index >= 0 && index < this.GetItemCount() && index != this.GetActiveItemIndexInternal()) {
3045    if(this.GetImageAreaStrategy())
3046     this.GetImageAreaStrategy().SetActiveItemIndex(index, preventAnimation);
3047    if(this.GetNavigationBarStrategy())
3048     this.GetNavigationBarStrategy().SetActiveItemIndex(index, preventAnimation);
3049    this.ResetSlideShowTimer();
3050    if(!isAPICall)
3051     this.RaiseActiveItemChanged();
3052   }
3053  },
3054  GetActiveItemIndexInternal: function() {
3055   var strategy = this.GetImageAreaStrategy() || this.GetNavigationBarStrategy();
3056   if(strategy)
3057    return strategy.GetActiveItemIndex();
3058   return 0;
3059  },
3060  GetItemInternal: function (index) {
3061   if(index < 0 || index >= this.GetItemCount())
3062    return null;
3063   return this.items[index] || { skipped: true };
3064  },
3065  GetRtlIndex: function (index) {
3066   if(this.rtl)
3067    return this.GetItemCount() - 1 - index;
3068   return index;
3069  },
3070  IsSkippedItem: function(index) {
3071   var item = this.GetItemInternal(index);
3072   return item ? !!item.skipped : false;
3073  },
3074  IsPendingItem: function(index) {
3075   var item = this.GetItemInternal(index);
3076   return item ? !!item.pending : false;
3077  },
3078  IsAllowItemCallback: function(index) {
3079   return this.IsSkippedItem(index) && !this.IsPendingItem(index);
3080  },
3081  EnsureShownItemsLoaded: function() {
3082   this.pendingItemsTimerID = ASPx.Timer.ClearTimer(this.pendingItemsTimerID);
3083   this.pendingItemsTimerID = window.setTimeout(function() {
3084    var navigationBar = this.GetNavigationBarStrategy();
3085    var indexes = navigationBar ? navigationBar.GetShownItemIndexes(false) : [];
3086    for(var i = 0; i < indexes.length; i++)
3087     indexes[i] = this.GetRtlIndex(indexes[i]);
3088    var activeItemIndex = this.GetActiveItemIndex(),
3089     shownIndexes = navigationBar ? indexes : [activeItemIndex];
3090    indexes.push(activeItemIndex);
3091    indexes = ASPxClientImageSlider.ExtendItemsPerRequest(indexes, this.itemsPerRequest, shownIndexes, this.GetItemCount(), this.IsAllowItemCallback.bind(this));
3092    this.LoadItemsViaCallback(indexes);
3093   }.aspxBind(this), 1000);
3094  },
3095  LoadItemsViaCallback: function(indexArray) {
3096   var pendingItemsQueue = [];
3097   for(var i = 0; i < indexArray.length; i++) {
3098    var index = indexArray[i];
3099    if(this.IsAllowItemCallback(index)) {
3100     this.items[index] = { pending: true };
3101     pendingItemsQueue.push(index);
3102    }
3103   }
3104   if(pendingItemsQueue.length > 0)
3105    this.DoLoadItemsViaCallback(pendingItemsQueue);
3106  },
3107  DoLoadItemsViaCallback: function(indexArray, nameArray) {
3108   var args = {};
3109   if(indexArray)
3110    args.i = indexArray;
3111   if(nameArray)
3112    args.n = nameArray;
3113   var preparedArgs = ASPx.Json.ToJson(args);
3114   this.CreateCallback(preparedArgs);
3115   this.HideLoadingPanel();
3116  },
3117  ProcessCreatedItems: function(items) {
3118   var navigationBar = this.GetNavigationBarStrategy();
3119   var imageArea = this.GetImageAreaStrategy();
3120   for(var key in items) {
3121    if(!items.hasOwnProperty(key)) continue;
3122    this.items[key] = items[key];
3123    this.RaiseItemLoadedOnCallback(this.GetItem(key));
3124    var index = this.GetRtlIndex(key);
3125    if(navigationBar)
3126     navigationBar.UpdateItemElement(index);
3127    if(imageArea)
3128     imageArea.UpdateItemElement(index);
3129   }
3130   if(this.HasTemplates())
3131    ASPx.ProcessScriptsAndLinks(this.name);
3132  },
3133  GetAnimationType: function () {
3134   return this.animationType;
3135  },
3136  HasNavigateUrls: function () {
3137   return this.hasNavigateUrls;
3138  },
3139  HasTemplates: function () {
3140   return this.hasTemplates;
3141  },
3142  GetNavigationBarPosition: function () {
3143   return this.navBarPos;
3144  },
3145  GetNavigationBarMode: function () {
3146   return this.dotHCssCl != "" ? 1 : 0;
3147  }
3148 });

3149 ASPxClientImageSlider.ExtendItemsPerRequest = function(indexes, itemsPerRequest, shownIndexes, itemsCount, allowFunc) {
3150  var result = indexes.filter(function(i) { return allowFunc(i); }.aspxBind(this)),
3151   extendedItemsCount = itemsPerRequest - result.length;
3152  if(result.length === 0 || extendedItemsCount < 1)
3153   return result;
3154  var index = shownIndexes[Math.floor(shownIndexes.length / 2)],
3155   count = itemsCount,
3156   i = 0;
3157  while(i < count && extendedItemsCount > 0) {
3158   index = (i % 2 === 0) ? index + i : index - i;
3159   if(index < 0 || index >= count)
3160    count++;
3161   else if(!ASPx.Data.ArrayContains(indexes, index) && allowFunc(index)) {
3162    result.push(index);
3163    extendedItemsCount--;
3164   }
3165   i++;
3166  }
3167  return result;
3168 };
3169 ASPxClientImageSlider.Cast = ASPxClientControl.Cast;
3170 var ASPxClientImageSliderItemEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
3171  constructor: function (item) {
3172   this.constructor.prototype.constructor.call(this);
3173   this.item = item;
3174  }
3175 });
3176 var ASPxClientImageSliderItem = ASPx.CreateClass(null, {
3177  constructor: function (imageSlider, index, name, imageUrl, text, loaded) {
3178   this.imageSlider = imageSlider;
3179   this.index = index;
3180   this.name = name;
3181   this.imageUrl = imageUrl;
3182   this.text = text;
3183   this.loaded = loaded;
3184  }
3185 });
3186 var ASPxClientImageZoomNavigator = ASPx.CreateClass(ASPxClientImageSlider, {
3187  constructor: function (name) {
3188   this.constructor.prototype.constructor.call(this, name);
3189   this.disableSelectedStateAnimation = true;
3190   this.imageZoomName = "";
3191   this.changeAction = 0;
3192   this.buttonVisibilityMode = 0;
3193  },
3194  Initialize: function () {
3195   ASPxClientImageSlider.prototype.Initialize.call(this);
3196   this.ActiveItemChanged.AddHandler(function () {
3197    this.OnActiveItemChanged();
3198   }.aspxBind(this));
3199  },
3200  CreateNavigationBarStrategy: function () {
3201   return new ImageZoomNavigationBarStrategy(this);
3202  },
3203  PrepareControlHierarchy: function () {
3204   ASPxClientImageSlider.prototype.PrepareControlHierarchy.call(this);
3205   ASPx.AddClassNameToElement(this.GetMainElement(), CssClassesConstants.ImageZoomNavigatorCssClassName);
3206  },
3207  OnActiveItemChanged: function () {
3208   this.UpdageImageZoomImages();
3209  },
3210  ProcessCreatedItems: function(items) {
3211   ASPxClientImageSlider.prototype.ProcessCreatedItems.call(this, items);
3212   this.UpdageImageZoomImages();
3213  },
3214  UpdageImageZoomImages: function() {
3215   var activeItemIndex = this.GetActiveItemIndex();
3216   if(this.IsSkippedItem(activeItemIndex))
3217    return;
3218   var imageZoom = this.GetImageZoom();
3219   if(imageZoom) {
3220    var item = this.GetItemInternal(activeItemIndex);
3221    imageZoom.SetImageProperties(item.s, item.liu || item.s, item.zt, item.et, item.zt || item.at);
3222   }
3223  },
3224  GetImageZoom: function() {
3225   return this.imageZoomName ? ASPx.GetControlCollection().Get(this.imageZoomName) : null;
3226  }
3227 });
3228 var ImageZoomNavigationBarStrategy = ASPx.CreateClass(NavigationBarThumbnailStrategy, {
3229  constructor: function (imageZoomNavigator) {
3230   this.visibleItemCount = 0;
3231   this.constructor.prototype.constructor.call(this, imageZoomNavigator);
3232  },
3233  InitializeHandlers: function () {
3234   if(this.GetImageSlider().changeAction == ActiveItemChangeActionEnum.Hover) {
3235    ItemsOwnerBase.prototype.InitializeHandlers.call(this);
3236    ASPx.Evt.AttachEventToElement(this.GetSlidePanelElement(), "mouseover", function (evt) { this.OnNavigationBarMouseOver(evt); }.aspxBind(this));
3237   }
3238   else
3239    NavigationBarThumbnailStrategy.prototype.InitializeHandlers.call(this);
3240  },
3241  OnNavigationBarMouseOver: function (evt) {
3242   if(!this.IsExecutedGesture()) {
3243    var index = this.GetItemIndexFromEvent(evt);
3244    if(index != -1)
3245     this.GetImageSlider().SetActiveItemIndexInternal(index);
3246   }
3247  },
3248  GetEnableItemHoverState: function () {
3249   return this.GetImageSlider().changeAction == ActiveItemChangeActionEnum.Click;
3250  },
3251  GetItemAlternateText: function (index) {
3252   if(this.IsValidItemIndex(index)) {
3253    var item = this.GetItem(index);
3254    return item.zt || item.at || "";
3255   }
3256   return "";
3257  },
3258  CalculateSize: function() {
3259   NavigationBarThumbnailStrategy.prototype.CalculateSize.call(this);
3260   if(!this.CanUseVisibleItemCount()) {
3261    var isHorizontal = this.IsHorizontalNavigation();
3262    var size = {
3263     width: isHorizontal ? this.GetItemWidthWithSpacing() * this.GetItemCount() - this.GetItemSpacing() : this.GetItemElementWidth(),
3264     height: isHorizontal ? this.GetItemElementHeight() : this.GetItemHeightWithSpacing() * this.GetItemCount() - this.GetItemSpacing()
3265    };
3266    var mainElementWidth = SizeUtils.GetClientWidth(this.GetMainElement(), true);
3267    var mainElementHeight = SizeUtils.GetClientHeight(this.GetMainElement(), true);
3268    if(isHorizontal && size.width < mainElementWidth || !isHorizontal && size.height < mainElementHeight) {
3269     this.visibleItemCount = this.GetItemCount();
3270     if(this.GetImageSlider().buttonVisibilityMode == NavigationButtonVisibilityModeEnum.Auto)
3271      this.SetVisibilityButtons(false);
3272    }
3273   }
3274  },
3275  UpdateNavigationButtonsState: function () {
3276   if(this.GetVisibleItemCount() != this.GetItemCount() || this.GetImageSlider().buttonVisibilityMode != NavigationButtonVisibilityModeEnum.Auto)
3277    return NavigationBarThumbnailStrategy.prototype.UpdateNavigationButtonsState.call(this);
3278   return false;
3279  },
3280  CanCreateNavigationButtons: function() {
3281   if(this.GetImageSlider().buttonVisibilityMode == NavigationButtonVisibilityModeEnum.Always)
3282    return true;
3283   return NavigationBarThumbnailStrategy.prototype.CanCreateNavigationButtons.call(this);
3284  },
3285  GetVisibleItemCount: function() {
3286   return this.GetImageSlider().visibleItemsCount || this.visibleItemCount;
3287  }
3288 });
3289 var ClientGalleryImageSlider = ASPx.CreateClass(ASPxClientImageSlider, {
3290  constructor: function(name) {
3291   this.constructor.prototype.constructor.call(this, name);
3292   this.OnLoadItemsViaCallback = new ASPxClientEvent();
3293  },

3294  ExtendItemsPerRequest: function(indexes, startIndex, itemsCount, allowFunc) {
3295   return indexes;
3296  },
3297  DoLoadItemsViaCallback: function(indexArray) {
3298   this.RaiseLoadItemsViaCallback(indexArray);
3299  },
3300  RaiseLoadItemsViaCallback: function(pendingQueue) {
3301   if(!this.OnLoadItemsViaCallback.IsEmpty() && pendingQueue.length > 0)
3302    this.OnLoadItemsViaCallback.FireEvent(this, pendingQueue);
3303  }
3304 });
3305 ASPx.ClientGalleryImageSlider = ClientGalleryImageSlider;
3306 window.ASPxClientImageSlider = ASPxClientImageSlider;
3307 window.ASPxClientImageSliderItemEventArgs = ASPxClientImageSliderItemEventArgs;
3308 window.ASPxClientImageSliderItem = ASPxClientImageSliderItem;
3309 window.ASPxClientImageZoomNavigator = ASPxClientImageZoomNavigator;
3310})();
3311