API tools faq
paste
Guest User

post-gallery-slider/js/jquery.sudoSlider.js (inactive)

a guest
Mar 29th, 2015
24
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 107.73 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. * Sudo Slider verion 3.3.0 - jQuery plugin
  3. * Written by Erik Krogh Kristensen [email protected].
  4. * http://webbies.dk/SudoSlider/
  5. *
  6. * Dual licensed under the MIT and GPL licenses.
  7. *
  8. * Based on EasySlider http://cssglobe.com/easy-slider-17-numeric-navigation-jquery-slider/
  9. * But bear little resemblance at this point.
  10. *
  11. * Built for jQuery library
  12. * http://jquery.com
  13. *
  14. */
  15. (function ($, win) {
  16. // Saves space in the minified version.
  17. var undefined; // Makes sure that undefined really is undefined within this scope.
  18. var FALSE = false;
  19. var TRUE = true;
  20.  
  21. // Constants
  22. var PAGES_MARKER_STRING = "pages";
  23. var NEXT_STRING = "next";
  24. var PREV_STRING = "prev";
  25. var LAST_STRING = "last";
  26. var FIRST_STRING = "first";
  27. var ABSOLUTE_STRING = "absolute";
  28. var RELATIVE_STRING = "relative";
  29. var HIDDEN_STRING = "hidden";
  30. var EMPTY_FUNCTION = function () { };
  31. var ANIMATION_CLONE_MARKER_CLASS = "sudo-box";
  32. var CSSVendorPrefix = getCSSVendorPrefix();
  33. var jWin = $(win);
  34.  
  35. var TOUCHSTART = "touchstart";
  36. var TOUCHMOVE = "touchmove";
  37. var TOUCHCANCEL = "touchcancel";
  38. var TOUCHEND = "touchend";
  39. var MOUSEDOWN = "mousedown";
  40. var MOUSEMOVE = "mousemove";
  41. var MOUSEUP = "mouseup";
  42.  
  43. $.fn.sudoSlider = function (optionsOrg) {
  44. // default configuration properties
  45. var defaults = {
  46. effect: "slide", /*option[0]/*effect*/
  47. speed: 1500, /* option[1]/*speed*/
  48. customLink: FALSE, /* option[2]/*customlink*/
  49. controlsShow: TRUE, /* option[3]/*controlsShow*/
  50. controlsFadeSpeed: 400, /* option[4]/*controlsfadespeed*/
  51. controlsFade: TRUE, /* option[5]/*controlsfade*/
  52. insertAfter: TRUE, /* option[6]/*insertafter*/
  53. vertical: FALSE, /* option[7]/*vertical*/
  54. slideCount: 1, /* option[8]/*slidecount*/
  55. moveCount: 1, /* option[9]/*movecount*/
  56. startSlide: 1, /* option[10]/*startslide*/
  57. responsive: FALSE, /* option[11]/*responsive*/
  58. ease: "swing", /* option[12]/*ease*/
  59. auto: FALSE, /* option[13]/*auto*/
  60. pause: 2000, /* option[14]/*pause*/
  61. resumePause: FALSE, /* option[15]/*resumepause*/
  62. continuous: FALSE, /* option[16]/*continuous*/
  63. prevNext: TRUE, /* option[17]/*prevnext*/
  64. numeric: FALSE, /* option[18]/*numeric*/
  65. numericText: [], /* option[19]/*numerictext*/
  66. slices: 15, /* option[20]/*slices*/
  67. boxCols: 8, /* option[21]/*boxCols*/
  68. boxRows: 4, /* option[22]/*boxRows*/
  69. initCallback: EMPTY_FUNCTION, /* option[23]/*initCallback*/
  70. ajaxLoad: EMPTY_FUNCTION, /* option[24]/*ajaxload*/
  71. beforeAnimation: EMPTY_FUNCTION, /* option[25]/*beforeanimation*/
  72. afterAnimation: EMPTY_FUNCTION, /* option[26]/*afteranimation*/
  73. history: FALSE, /* option[27]/*history*/
  74. autoHeight: TRUE, /* option[28]/*autoheight*/
  75. autoWidth: TRUE, /* option[29]/*autowidth*/
  76. updateBefore: FALSE, /* option[30]/*updateBefore*/
  77. ajax: FALSE, /* option[31]/*ajax*/
  78. preloadAjax: 100, /* option[32]/*preloadajax*/
  79. loadingText: "", /* option[33]/*loadingtext*/
  80. prevHtml: '<a href="#" class="prevBtn"> previous </a>', /* option[34]/*prevhtml*/
  81. nextHtml: '<a href="#" class="nextBtn"> next </a>', /* option[35]/*nexthtml*/
  82. controlsAttr: 'class="controls"', /* option[36]/*controlsattr*/
  83. numericAttr: 'class="numericControls"', /* option[37]/*numericattr*/
  84. interruptible: FALSE, /* option[38]/*interruptible*/
  85. useCSS: TRUE, /* option[39]/*useCSS*/
  86. loadStart: EMPTY_FUNCTION, /* option[40]/*loadStart*/
  87. loadFinish: EMPTY_FUNCTION, /* option[41]/*loadFinish*/
  88. touch: FALSE, /* option[42]/*touch*/
  89. touchHandle: FALSE, /* option[43]/*touchHandle*/
  90. destroyCallback: EMPTY_FUNCTION /* option[44]/*destroyCallback*/
  91. };
  92. // Defining the base element.
  93. var baseSlider = this;
  94.  
  95. optionsOrg = $.extend(objectToLowercase(defaults), objectToLowercase(optionsOrg));
  96. if (CSSVendorPrefix === FALSE || !minJQueryVersion([1, 8, 0])) {
  97. optionsOrg.usecss = FALSE;
  98. }
  99.  
  100. return this.each(function () {
  101. var init,
  102. isSlideContainerUl,
  103. slidesContainer,
  104. slides,
  105. imagesInSlidesLoaded,
  106. totalSlides,
  107. currentSlide,
  108. previousSlide,
  109. clickable,
  110. numericControls,
  111. numericContainer,
  112. destroyed,
  113. slideNumberBeforeDestroy = FALSE,
  114. controls,
  115. nextbutton,
  116. prevbutton,
  117. autoTimeout,
  118. autoOn,
  119. numberOfVisibleSlides,
  120. asyncDelayedSlideLoadTimeout,
  121. obj = $(this),
  122. finishedAdjustingTo = FALSE, // This variable tells if the slider is currently adjusted (height and width) to any specific slide. This is usefull when ajax-loading stuff.
  123. adjustingTo, // This one tells what slide we are adjusting to, to make sure that we do not adjust to something we shouldn't.
  124. adjustTargetTime = 0, // This one holds the time that the autoadjust animation should complete.
  125. currentlyAnimating = FALSE,
  126. currentAnimation,
  127. currentAnimationCallback,
  128. currentAnimationObject,
  129. runAfterAnimationCallbacks,
  130. awaitingAjaxCallbacks,
  131. startedAjaxLoads,
  132. finishedAjaxLoads,
  133. animateToAfterCompletion = FALSE,
  134. animateToAfterCompletionClicked,
  135. animateToAfterCompletionSpeed,
  136. slideContainerCreated = FALSE,
  137. option = [],
  138. options = $.extend(TRUE, {}, optionsOrg),
  139. currentSliderPositionTop,
  140. currentSliderPositionLeft,
  141. unBindCallbacks = [],
  142. autoStartedWithPause = FALSE,
  143. animationWasInterrupted = FALSE;
  144.  
  145. // The call to the init function is after the definition of all the functions.
  146. function initSudoSlider() {
  147. // Storing the public options in an array.
  148. var optionIndex = 0;
  149. for (var key in options) {
  150. option[optionIndex] = options[key];
  151. optionIndex++;
  152. }
  153.  
  154. init = TRUE;
  155.  
  156. imagesInSlidesLoaded = [];
  157. runAfterAnimationCallbacks = [];
  158. awaitingAjaxCallbacks = [];
  159. startedAjaxLoads = [];
  160. finishedAjaxLoads = [];
  161.  
  162. // Fix for nested list items
  163. slidesContainer = childrenNotAnimationClones(obj);
  164.  
  165. // Is the ul element there?
  166. var ulLength = slidesContainer.length;
  167. var newUl = $("<div></div>");
  168. if (!ulLength) {
  169. obj.append(slidesContainer = newUl);
  170. isSlideContainerUl = FALSE;
  171. } else if (!(isSlideContainerUl = slidesContainer.is("ul")) && !slideContainerCreated) {
  172. newUl.append(slidesContainer);
  173. obj.append(slidesContainer = newUl);
  174. }
  175. slideContainerCreated = TRUE;
  176.  
  177. var slidesJquery = childrenNotAnimationClones(slidesContainer);
  178. slides = [];
  179.  
  180. totalSlides = slidesJquery.length;
  181.  
  182. slidesJquery.each(function (index, elem) {
  183. var that = $(elem);
  184. slides[index] = that;
  185. that.css({position: RELATIVE_STRING});
  186. if (that.css("display") == "none") {
  187. that.css("display", "inline");
  188. }
  189. });
  190.  
  191. // Adding CSS classes
  192. slidesContainer.addClass("slidesContainer");
  193.  
  194. slidesJquery.addClass("slide");
  195.  
  196. // Now we are going to fix the document, if it's 'broken'. (No <li>).
  197. // I assume that it's can only be broken, if ajax is enabled. If it's broken without Ajax being enabled, the script doesn't have anything to fill the holes.
  198. if (option[31]/*ajax*/) {
  199. // Do we have enough list elements to fill out all the ajax documents.
  200. var numerOfAjaxUrls = option[31]/*ajax*/.length;
  201. if (numerOfAjaxUrls > totalSlides) {
  202. for (var a = 1; a <= numerOfAjaxUrls - totalSlides; a++) {
  203. var tag;
  204. if (isSlideContainerUl) {
  205. tag = "li";
  206. } else {
  207. tag = "div";
  208. }
  209. var slide = $("<" + tag + ">" + option[33]/*loadingtext*/ + "</" + tag + ">");
  210. slidesContainer.append(slide);
  211. slides[totalSlides + (a - 1)] = slide;
  212. }
  213. slidesJquery = childrenNotAnimationClones(slidesContainer);
  214. totalSlides = numerOfAjaxUrls;
  215. }
  216. }
  217.  
  218. slidesJquery.each(function (index, elem) {
  219. imagesInSlidesLoaded[index] = FALSE;
  220. runOnImagesLoaded($(elem), TRUE, function () {
  221. imagesInSlidesLoaded[index] = TRUE;
  222. });
  223. });
  224.  
  225. if (slideNumberBeforeDestroy === FALSE) {
  226. currentSlide = 0;
  227. } else {
  228. currentSlide = slideNumberBeforeDestroy;
  229. }
  230. currentSlide = currentSlide || 0;
  231.  
  232. previousSlide = currentSlide;
  233.  
  234. clickable = TRUE;
  235. numericControls = [];
  236. destroyed = FALSE;
  237.  
  238.  
  239. // Set obj overflow to hidden (and position to relative <strike>, if fade is enabled. </strike>)
  240. obj.css({overflow: HIDDEN_STRING});
  241. if (obj.css("position") == "static") obj.css({position: RELATIVE_STRING}); // Fixed a lot of IE6 + IE7 bugs.
  242.  
  243. // Float items to the left, and make sure that all elements are shown.
  244. slidesJquery.css({"float": "left", listStyle: "none", overflow: HIDDEN_STRING});
  245. // The last CSS to make it work.
  246. slidesContainer.add(slidesJquery).css({display: "block", position: RELATIVE_STRING, margin: "0"});
  247.  
  248. option[8]/*slidecount*/ = parseInt10(option[8]/*slidecount*/);
  249.  
  250. // Lets just redefine slidecount
  251. numberOfVisibleSlides = option[8]/*slidecount*/;
  252.  
  253. option[8]/*slidecount*/ += option[9]/*movecount*/ - 1;
  254.  
  255. // startslide can only be a number (and not 0). Converting from 1 index to 0 index.
  256. option[10]/*startslide*/ = parseInt10(option[10]/*startslide*/) - 1 || 0;
  257.  
  258. option[0]/*effect*/ = getEffectMethod(option[0]/*effect*/);
  259.  
  260.  
  261.  
  262. for (var a = 0; a < totalSlides; a++) {
  263. if (!option[19]/*numerictext*/[a] && option[19]/*numerictext*/[a] != "") {
  264. option[19]/*numerictext*/[a] = (a + 1);
  265. }
  266. option[31]/*ajax*/[a] = option[31]/*ajax*/[a] || FALSE;
  267. }
  268.  
  269. option[5]/*controlsfade*/ = option[5]/*controlsfade*/ && !option[16]/*continuous*/;
  270.  
  271. if (option[11]/*responsive*/) {
  272. adjustResponsiveLayout(TRUE);
  273. }
  274.  
  275. // Making sure that i have enough room in the <ul> (Through testing, i found out that the max supported size (height or width) in Firefox is 17895697px, Chrome supports up to 134217726px, and i didn't find any limits in IE (6/7/8/9)).
  276. // 9000000px gives room for about 12500 slides of 700px each (and works in every browser i tested). Down to 9000000 from 10000000 because the later might not work perfectly in FireFox on OSX.
  277. slidesContainer[option[7]/*vertical*/ ? "height" : "width"](9000000)[option[7]/*vertical*/ ? "width" : "height"]("100%");
  278.  
  279. // If responsive is turned on, autowidth doesn't work.
  280. option[29]/*autowidth*/ = option[29]/*autowidth*/ && !option[11]/*responsive*/;
  281.  
  282. if (option[11]/*responsive*/) {
  283. bindAndRegisterOff(jWin, "resize focus", adjustResponsiveLayout, "");
  284. }
  285.  
  286. if (option[3]/*controlsShow*/) {
  287. controls = $("<span " + option[36]/*controlsattr*/ + "></span>");
  288. obj[option[6]/*insertafter*/ ? "after" : "before"](controls);
  289.  
  290. if (option[18]/*numeric*/) {
  291. numericContainer = $("<ol " + option[37]/*numericattr*/ + "></ol>");
  292. controls.prepend(numericContainer);
  293. var usePages = option[18]/*numeric*/ == PAGES_MARKER_STRING;
  294. var distanceBetweenPages = usePages ? numberOfVisibleSlides : 1;
  295. for (var a = 0; a < totalSlides - ((option[16]/*continuous*/ || usePages) ? 1 : numberOfVisibleSlides) + 1; a += distanceBetweenPages) {
  296. numericControls[a] = $("<li data-target=\"" + (a + 1) + "\"><a href=\"#\"><span>" + option[19]/*numerictext*/[a] + "</span></a></li>")
  297. .appendTo(numericContainer)
  298. .click(function () {
  299. enqueueAnimation(getTargetAttribute(this) - 1, TRUE);
  300. return FALSE;
  301. });
  302. }
  303. }
  304. if (option[17]/*prevnext*/) {
  305. nextbutton = makecontrol(option[35]/*nexthtml*/, NEXT_STRING);
  306. prevbutton = makecontrol(option[34]/*prevhtml*/, PREV_STRING);
  307. }
  308. }
  309.  
  310.  
  311. // Lets make those fast/normal/fast into some numbers we can make calculations with.
  312. var optionsToConvert = [4/*controlsfadespeed*/, 1/*speed*/, 14/*pause*/];
  313. for (var i = 0; i < optionsToConvert.length; i++) {
  314. option[optionsToConvert[i]] = textSpeedToNumber(option[optionsToConvert[i]]);
  315. }
  316.  
  317. if (option[2]/*customlink*/) {
  318. bindAndRegisterOff($(document), "click", customLinkClickHandler, option[2]/*customlink*/);
  319. }
  320.  
  321. runOnImagesLoaded(getSlides(option[10]/*startslide*/, option[8]/*slidecount*/), TRUE, function () {
  322. if (slideNumberBeforeDestroy !== FALSE) {
  323. goToSlide(slideNumberBeforeDestroy, FALSE);
  324. } else if (option[27]/*history*/) {
  325. // I support the jquery.address plugin, Ben Alman's hashchange plugin and Ben Alman's jQuery.BBQ.
  326. var hashPlugin;
  327. if (hashPlugin = jWin.hashchange) {
  328. hashPlugin(URLChange);
  329. } else if (hashPlugin = $.address) {
  330. hashPlugin.change(URLChange);
  331. } else {
  332. // This assumes that jQuery BBQ is included. If not, stuff won't work in old browsers.
  333. jWin.on("hashchange", URLChange);
  334. }
  335. URLChange();
  336.  
  337. } else {
  338. goToSlide(option[10]/*startslide*/, FALSE);
  339. }
  340.  
  341. setCurrent(currentSlide);
  342. });
  343. if (option[31]/*ajax*/[option[10]/*startslide*/]) {
  344. ajaxLoad(option[10]/*startslide*/);
  345. }
  346. if (option[32]/*preloadajax*/ === TRUE) {
  347. for (var i = 0; i < totalSlides; i++) {
  348. if (option[31]/*ajax*/[i] && option[10]/*startslide*/ != i) {
  349. ajaxLoad(i);
  350. }
  351. }
  352. } else {
  353. startAsyncDelayedLoad();
  354. }
  355. }
  356.  
  357. /*
  358. * The functions do the magic.
  359. */
  360.  
  361. function customLinkClickHandler() {
  362. var target;
  363. if (target = getTargetAttribute(this)) {
  364. if (target == 'stop') {
  365. option[13]/*auto*/ = FALSE;
  366. stopAuto();
  367. } else if (target == "start") {
  368. startAuto();
  369. option[13]/*auto*/ = TRUE;
  370. } else if (target == 'block') {
  371. clickable = FALSE;
  372. } else if (target == 'unblock') {
  373. clickable = TRUE;
  374. } else {
  375. enqueueAnimation((target == parseInt10(target)) ? target - 1 : target, TRUE);
  376. }
  377. }
  378. return FALSE;
  379. }
  380.  
  381. // Adjusts the slider when a change in layout has happened.
  382. var previousAdjustedResponsiveWidth = -1;
  383. function adjustResponsiveLayout(forced) {
  384. function doTheAdjustment() {
  385. if ((cantDoAdjustments() && !forced) || totalSlides == 0) {
  386. return;
  387. }
  388.  
  389. var newWidth = getResponsiveWidth();
  390.  
  391. if (previousAdjustedResponsiveWidth != newWidth) {
  392. previousAdjustedResponsiveWidth = newWidth;
  393.  
  394. for (var i = 0; i < totalSlides; i++) {
  395. slides[i].width(newWidth);
  396. }
  397. if (autoStartedWithPause !== FALSE) {
  398. startAuto(autoStartedWithPause);
  399. }
  400.  
  401. stopAnimation();
  402. ensureSliderContainerCSSDurationReset();
  403. adjustPositionTo(currentSlide);
  404. autoadjust(currentSlide, 0);
  405. }
  406. }
  407. doTheAdjustment();
  408. callAsync(doTheAdjustment); // Fixing invisible scrollbar.
  409. setTimeout(doTheAdjustment, 20);
  410. }
  411.  
  412. // Returns the width of a single <li> if the page layout is responsive.
  413. function getResponsiveWidth() {
  414. return obj.width() / numberOfVisibleSlides;
  415. }
  416.  
  417. // For backwards compability, the rel attribute is used as a fallback.
  418. function getTargetAttribute(that) {
  419. that = $(that);
  420. return that.attr("data-target") || that.attr("rel");
  421. }
  422.  
  423. // Triggered when the URL changes.
  424. function URLChange() {
  425. var target = getUrlHashTarget();
  426. if (init) {
  427. goToSlide(target, FALSE);
  428. } else {
  429. enqueueAnimation(target, FALSE);
  430. }
  431. }
  432.  
  433. function startAsyncDelayedLoad() {
  434. if (option[32]/*preloadajax*/ !== FALSE) {
  435. var preloadAjaxTime = parseInt10(option[32]/*preloadajax*/);
  436. if (option[31]/*ajax*/) {
  437. for (var i = 0; i < option[31]/*ajax*/.length; i++) {
  438. if (option[31]/*ajax*/[i]) {
  439. clearTimeout(asyncDelayedSlideLoadTimeout);
  440. asyncDelayedSlideLoadTimeout = setTimeout(function () {
  441. if (option[31]/*ajax*/[i]) {
  442. ajaxLoad(parseInt10(i));
  443. } else {
  444. startAsyncDelayedLoad();
  445. }
  446. }, preloadAjaxTime);
  447.  
  448. break;
  449. }
  450. }
  451. }
  452. }
  453. }
  454.  
  455. function startAuto(pause) {
  456. if (pause === undefined) {
  457. var dataPause = slides[currentSlide].attr("data-pause");
  458. if (dataPause !== undefined) {
  459. pause = parseInt10(dataPause);
  460. } else {
  461. pause = option[14]/*pause*/;
  462. }
  463. }
  464. if (animationWasInterrupted) {
  465. pause = mathMax(pause, 100);
  466. }
  467. stopAuto();
  468. autoOn = TRUE;
  469. autoStartedWithPause = pause;
  470. autoTimeout = setTimeout(function () {
  471. if (autoOn) {
  472. enqueueAnimation(NEXT_STRING, FALSE);
  473. autoStartedWithPause = FALSE;
  474. }
  475. }, pause);
  476. }
  477.  
  478. function stopAuto(autoPossibleStillOn) {
  479. if (autoTimeout) {
  480. clearTimeout(autoTimeout);
  481. }
  482. if (!autoPossibleStillOn) autoOn = FALSE;
  483. }
  484.  
  485. function textSpeedToNumber(speed) {
  486. if (parseInt10(speed) || speed == 0) {
  487. return parseInt10(speed);
  488. }
  489. if (speed == "fast") {
  490. return 200;
  491. }
  492. if (speed == "normal" || speed == "medium") {
  493. return 400;
  494. }
  495. if (speed == "slow") {
  496. return 600;
  497. }
  498. return 600;
  499. }
  500.  
  501. function makecontrol(html, action) {
  502. return $(html).prependTo(controls).click(function () {
  503. enqueueAnimation(action, TRUE);
  504. return FALSE;
  505. });
  506. }
  507.  
  508. function enqueueAnimation(direction, clicked, speed) {
  509. if (clickable && !init) {
  510. // Stopping, because if its needed then its restarted after the end of the animation.
  511. stopAuto(TRUE);
  512.  
  513. if (!destroyed) {
  514. loadSlidesAndAnimate(direction, clicked, speed);
  515. }
  516. } else {
  517. if (option[38]/*interruptible*/ && currentlyAnimating) {
  518. stopAnimation();
  519. enqueueAnimation(direction, clicked, speed);
  520. } else {
  521. animateToAfterCompletion = direction;
  522. animateToAfterCompletionClicked = clicked;
  523. animateToAfterCompletionSpeed = speed;
  524.  
  525. // I can just as well start the ajax loads
  526. if (option[31]/*ajax*/) {
  527. var targetSlide = filterDir(direction);
  528. for (var loadSlide = targetSlide; loadSlide < targetSlide + numberOfVisibleSlides; loadSlide++) {
  529. if (option[31]/*ajax*/[loadSlide]) {
  530. ajaxLoad(getRealPos(loadSlide));
  531. }
  532. }
  533. }
  534. }
  535. }
  536. }
  537.  
  538. // It may not sound like it, but the variable fadeOpacity is only for TRUE/FALSE.
  539. function fadeControl(fadeOpacity, fadetime, nextcontrol) {
  540. fadeOpacity = fadeOpacity ? 1 : 0;
  541. var fadeElement = $();
  542.  
  543. if (option[3]/*controlsShow*/ && option[17]/*prevnext*/) {
  544. fadeElement = nextcontrol ? nextbutton : prevbutton;
  545. }
  546.  
  547. if (option[2]/*customlink*/) {
  548. var customLink = $(option[2]/*customlink*/);
  549. var filterString = "=\"" + (nextcontrol ? NEXT_STRING : PREV_STRING) + "\"]";
  550. var filtered = customLink.filter("[rel" + filterString + ", [data-target" + filterString + "");
  551. fadeElement = fadeElement.add(filtered);
  552. }
  553.  
  554. var adjustObject = {opacity: fadeOpacity};
  555.  
  556. function callback() {
  557. if (!fadeOpacity && fadeElement.css("opacity") == 0) {
  558. fadeElement.css({visibility: HIDDEN_STRING});
  559. }
  560. }
  561.  
  562. if (fadeOpacity) {
  563. fadeElement.css({visibility: "visible"});
  564. }
  565.  
  566. if (option[39]/*useCSS*/) {
  567. animate(fadeElement, adjustObject, fadetime, option[12]/*ease*/, callback);
  568. } else {
  569. fadeElement.animate(
  570. adjustObject,
  571. {
  572. queue: FALSE,
  573. duration: fadetime,
  574. easing: option[12]/*ease*/,
  575. callback: callback
  576. }
  577. );
  578. }
  579. }
  580.  
  581. // Fade the controls, if we are at the end of the slide.
  582. // It's all the different kind of controls.
  583. function fadeControls(a, fadetime) {
  584. fadeControl(a, fadetime, FALSE); // abusing that the number 0 == FALSE.
  585. // The new way of doing it.
  586. fadeControl(a < totalSlides - numberOfVisibleSlides, fadetime, TRUE);
  587. }
  588.  
  589. // Updating the 'current' class
  590. function setCurrent(i) {
  591. i = getRealPos(i) + 1;
  592.  
  593. // Fixing that the last numeric control isn't marked when we are at the last possible position.
  594. if (option[18]/*numeric*/ == PAGES_MARKER_STRING && i == totalSlides - numberOfVisibleSlides + 1 && !option[16]/*continuous*/) {
  595. i = totalSlides;
  596. }
  597.  
  598. if (option[18]/*numeric*/){
  599. for (var control = 0; control < numericControls.length; ++control) {
  600. var element = numericControls[control];
  601. setCurrentElement(element, i)
  602. }
  603. }
  604. if (option[2]/*customlink*/) setCurrentElement($(option[2]/*customlink*/), i);
  605. }
  606.  
  607. function setCurrentElement(element, i) {
  608. if (element && element.filter) {
  609. element
  610. .filter(".current")
  611. .removeClass("current");
  612.  
  613. element
  614. .filter(function () {
  615. var elementTarget = getTargetAttribute(this);
  616. if (option[18]/*numeric*/ == PAGES_MARKER_STRING) {
  617. for (var a = numberOfVisibleSlides - 1; a >= 0; a--) {
  618. if (elementTarget == i - a) {
  619. return TRUE;
  620. }
  621. }
  622. } else {
  623. return elementTarget == i;
  624. }
  625. return FALSE;
  626. })
  627. .addClass("current");
  628. }
  629. }
  630.  
  631. function getUrlHashTarget() {
  632. var hashString = location.hash.substr(1)
  633. for (var i = 0; i < option[19]/*numerictext*/.length; i++) {
  634. if (option[19]/*numerictext*/[i] == hashString) {
  635. return i;
  636. }
  637. }
  638. if (hashString && !init) {
  639. return currentSlide;
  640. } else {
  641. return option[10]/*startslide*/;
  642. }
  643. }
  644.  
  645. function autoadjust(i, speed) {
  646. i = getRealPos(i); // I assume that the continuous clones, and the original element is the same height. So i always adjust according to the original element.
  647.  
  648. adjustingTo = i;
  649. adjustTargetTime = getTimeInMillis() + speed;
  650.  
  651. if (speed == 0) {
  652. finishedAdjustingTo = i;
  653. } else {
  654. finishedAdjustingTo = FALSE;
  655. }
  656.  
  657. if (option[28]/*autoheight*/ || option[29]/*autowidth*/) {
  658. autoHeightWidth(i);
  659. }
  660. }
  661.  
  662.  
  663. function autoHeightWidth(i) {
  664. obj.ready(function () {
  665. adjustHeightWidth(i);
  666. runOnImagesLoaded(slides[i], FALSE, makeCallback(adjustHeightWidth, [i]));
  667. });
  668. }
  669.  
  670. // Axis: TRUE == height, FALSE == width.
  671. function getSliderDimensions(fromSlide, axis) {
  672. var pixels = 0;
  673. for (var slide = fromSlide; slide < fromSlide + numberOfVisibleSlides; slide++) {
  674. var targetSlide = slides[getRealPos(slide)];
  675. if (targetSlide) {
  676. var targetPixels = targetSlide['outer' + (axis ? "Height" : "Width")](TRUE);
  677. if (axis == option[7]/*vertical*/) {
  678. pixels += targetPixels;
  679. } else {
  680. pixels = mathMax(targetPixels, pixels);
  681. }
  682. }
  683. }
  684. return pixels;
  685. }
  686.  
  687. function adjustHeightWidth(i) {
  688. if (i != adjustingTo || cantDoAdjustments()) {
  689. return;
  690. }
  691.  
  692. var speed = adjustTargetTime - getTimeInMillis();
  693. speed = mathMax(speed, 0);
  694. var adjustObject = {};
  695. if (option[28]/*autoheight*/) {
  696. adjustObject.height = getSliderDimensions(i, TRUE) || 1; // Making it completely invisible gives trouble.
  697. }
  698. if (option[29]/*autowidth*/) {
  699. adjustObject.width = getSliderDimensions(i, FALSE) || 1;
  700. }
  701.  
  702. if (option[39]/*useCSS*/) {
  703. animate(obj, adjustObject, speed, option[12]/*ease*/)
  704. } else {
  705. if (speed == 0) {
  706. // Doing CSS if speed == 0, 1: its faster. 2: it fixes bugs.
  707. obj.stop().css(adjustObject);
  708. } else {
  709. obj.animate(
  710. adjustObject,
  711. {
  712. queue: FALSE,
  713. duration: speed,
  714. easing: option[12]/*ease*/
  715. }
  716. );
  717. }
  718. }
  719. }
  720.  
  721. function adjustPositionTo(slide) {
  722. var left = getSlidePosition(slide, FALSE);
  723. var top = getSlidePosition(slide, TRUE);
  724.  
  725. adjustPositionToPosition(left, top);
  726. }
  727.  
  728. function adjustPositionToPosition(left, top) {
  729. currentSliderPositionLeft = left;
  730. currentSliderPositionTop = top;
  731.  
  732. if (option[39]/*useCSS*/) {
  733. slidesContainer.css({transform: "translate(" + left + "px, " + top + "px)"});
  734. } else {
  735. function setMargins(left, top) {
  736. slidesContainer.css({
  737. marginLeft: left,
  738. marginTop: top
  739. });
  740. }
  741. setMargins(0, 0);
  742. setMargins(left, top);
  743. }
  744. }
  745.  
  746. function getSlidePosition(slide, vertical) {
  747. var targetSlide = slides[getRealPos(slide)];
  748. return (targetSlide && targetSlide.length) ? -targetSlide.position()[vertical ? "top" : "left"] : 0;
  749. }
  750.  
  751. function callQueuedAnimation() {
  752. if (animateToAfterCompletion !== FALSE) {
  753. var animateTo = animateToAfterCompletion;
  754. animateToAfterCompletion = FALSE;
  755. callAsync(makeCallback(enqueueAnimation, [animateTo, animateToAfterCompletionClicked, animateToAfterCompletionSpeed]));
  756. }
  757. }
  758.  
  759. function adjust(clicked) {
  760. ensureSliderContainerCSSDurationReset();
  761.  
  762. autoadjust(currentSlide, 0);
  763. currentSlide = getRealPos(currentSlide); // Going to the real slide, away from the clone.
  764. if (!option[30]/*updateBefore*/) setCurrent(currentSlide);
  765. adjustPositionTo(currentSlide);
  766. clickable = TRUE;
  767.  
  768. if (option[13]/*auto*/) {
  769. // Stopping auto if clicked. And also continuing after X seconds of inactivity.
  770. if (clicked) {
  771. stopAuto();
  772. if (option[15]/*resumepause*/) startAuto(option[15]/*resumepause*/);
  773. } else if (!init) {
  774. startAuto();
  775. }
  776. }
  777.  
  778. callQueuedAnimation();
  779. }
  780.  
  781. // This function is called when i need a callback on the current element and it's continuous clones (if they are there).
  782. // after: TRUE == afteranimation : FALSE == beforeanimation;
  783. function aniCall(i, after, synchronous) {
  784. i = getRealPos(i);
  785. // Wierd fix to let IE accept the existance of the sudoSlider object.
  786. var func = makeCallback(after ? afterAniCall : beforeAniCall, [slides[i], i + 1]);
  787. if (synchronous) {
  788. func();
  789. } else {
  790. callAsync(func);
  791. }
  792. }
  793.  
  794. function afterAniCall(el, a) {
  795. option[26]/*afteranimation*/.call(el, a);
  796. }
  797.  
  798. function beforeAniCall(el, a) {
  799. option[25]/*beforeanimation*/.call(el, a);
  800. }
  801.  
  802. // Convert the direction into a usefull number.
  803. function filterDir(dir) {
  804. if (dir == NEXT_STRING) {
  805. return limitDir(currentSlide + option[9]/*movecount*/, dir);
  806. } else if (dir == PREV_STRING) {
  807. return limitDir(currentSlide - option[9]/*movecount*/, dir);
  808. } else if (dir == FIRST_STRING) {
  809. return 0;
  810. } else if (dir == LAST_STRING) {
  811. return totalSlides - 1;
  812. } else {
  813. return limitDir(parseInt10(dir), dir);
  814. }
  815. }
  816.  
  817. // If continuous is off, we sometimes do not want to move to far.
  818. // This method was added in 2.1.8, se the changelog as to why.
  819. function limitDir(i, dir) {
  820. if (option[16]/*continuous*/) {
  821. if (dir == NEXT_STRING || dir == PREV_STRING) {
  822. return i;
  823. } else {
  824. return getRealPos(i);
  825. }
  826. } else {
  827. var maxSlide = totalSlides - numberOfVisibleSlides;
  828. if (i > maxSlide) {
  829. if (currentSlide == maxSlide && dir == NEXT_STRING) {
  830. return 0;
  831. } else {
  832. return maxSlide;
  833. }
  834. } else if (i < 0) {
  835. if (currentSlide == 0 && dir == PREV_STRING) {
  836. return maxSlide;
  837. } else {
  838. return 0;
  839. }
  840. } else {
  841. return i;
  842. }
  843. }
  844. }
  845.  
  846. // Load a ajax document (or image) into a slide.
  847. // If testing this locally (loading everything from a harddisk instead of the internet), it may not work.
  848. // But then try to upload it to a server, and see it shine.
  849. function ajaxLoad(slide, ajaxCallBack) {
  850. if (ajaxCallBack) {
  851. var callbackList = awaitingAjaxCallbacks[slide];
  852. if (!callbackList) {
  853. callbackList = awaitingAjaxCallbacks[slide] = [];
  854. }
  855. callbackList.push(ajaxCallBack);
  856. }
  857.  
  858. if (finishedAjaxLoads[slide]) {
  859. if (ajaxCallBack) {
  860. runOnImagesLoaded(slides[slide], TRUE, makeCallback(callAsync, [ajaxCallBack]));
  861. }
  862. return;
  863. }
  864.  
  865. if (startedAjaxLoads[slide]) {
  866. return;
  867. }
  868. startedAjaxLoads[slide] = TRUE;
  869.  
  870. var target = option[31]/*ajax*/[slide];
  871. if (!target) {
  872. callAsync(ajaxCallBack);
  873. return;
  874. }
  875.  
  876. if (asyncDelayedSlideLoadTimeout) clearTimeout(asyncDelayedSlideLoadTimeout);// I dont want it to run to often.
  877.  
  878. var targetslide = slides[slide];
  879.  
  880. // Loads the url as an image, either if it is an image, or if everything else failed.
  881. function loadImage() {
  882. var image = new Image();
  883. image.src = target;
  884. var thatImage = $(image);
  885. runOnImagesLoaded(thatImage, TRUE, makeCallback(runWhenNotAnimating, [function () {
  886. targetslide.empty().append(image);
  887.  
  888. ajaxAdjust(slide, TRUE);
  889. }]));
  890. }
  891.  
  892. var succesRan = FALSE;
  893.  
  894. $.ajax({
  895. url: target,
  896. success: function (data, textStatus, jqXHR) {
  897. succesRan = TRUE;
  898. runWhenNotAnimating(function () {
  899. var type = jqXHR.getResponseHeader('Content-Type');
  900. if (type && type.substr(0, 1) != "i") {
  901. targetslide.html(data);
  902. ajaxAdjust(slide, FALSE);
  903. } else {
  904. loadImage();
  905. }
  906. });
  907. },
  908. complete: function () {
  909. // Some browsers wont load images this way, so i treat an error as an image.
  910. // There is no stable way of determining if it's a real error or if i tried to load an image in a old browser, so i do it this way.
  911. if (!succesRan) {
  912. loadImage();
  913. }
  914. }
  915. });
  916. // It is loaded, we dont need to do that again.
  917. option[31]/*ajax*/[slide] = FALSE;
  918. // It is the only option that i need to change for good.
  919. options.ajax[slide] = FALSE;
  920. }
  921.  
  922. // Performs the callback immediately if no animation is running.
  923. // Otherwise waits for the animation to complete in a FIFO queue.
  924. function runWhenNotAnimating(completeFunction) {
  925. if (currentlyAnimating) {
  926. runAfterAnimationCallbacks.push(completeFunction);
  927. } else {
  928. callAsync(completeFunction);
  929. }
  930. }
  931.  
  932. function ajaxAdjust(i, img) {
  933. var target = slides[i];
  934.  
  935. adjustPositionTo(currentSlide);
  936. autoadjust(currentSlide, 0);
  937.  
  938. runOnImagesLoaded(target, TRUE, makeCallback(runWhenNotAnimating, [
  939. function () {
  940. adjustPositionTo(currentSlide);
  941. autoadjust(currentSlide, 0);
  942.  
  943. finishedAjaxLoads[i] = TRUE;
  944.  
  945. performCallbacks(awaitingAjaxCallbacks[i]);
  946.  
  947. startAsyncDelayedLoad();
  948.  
  949. callAsync(function () {
  950. option[24]/*ajaxload*/.call(slides[i], i + 1, img);
  951. });
  952.  
  953. if (init) {
  954. init = FALSE;
  955. callAsync(performInitCallback);
  956. }
  957. }
  958. ]));
  959. }
  960.  
  961. function performInitCallback() {
  962. if (option[16]/*continuous*/) {
  963. centerTargetSlideAfter(currentSlide);
  964. }
  965.  
  966. autoadjust(currentSlide, 0);
  967. adjustPositionTo(currentSlide);
  968. callQueuedAnimation();
  969. if (option[11]/*responsive*/) {
  970. adjustResponsiveLayout();
  971. }
  972. if (option[13]/*auto*/) {
  973. startAuto();
  974. }
  975. option[23]/*initCallback*/.call(baseSlider);
  976.  
  977. if (option[42]/*touch*/) {
  978. setUpTouch();
  979. }
  980.  
  981. // Fixing once and for all that the wrong slide is shown on init.
  982. runOnImagesLoaded(getSlides(currentSlide, totalSlides), FALSE, makeCallback(runWhenNotAnimating, [
  983. function () {
  984. autoadjust(currentSlide, 0);
  985. adjustPositionTo(currentSlide);
  986. }
  987. ]));
  988. }
  989.  
  990. function setUpTouch() {
  991. var easingToUse;
  992. var runningTouchEffect = FALSE;
  993.  
  994. var prevEffect = option[0]/*effect*/;
  995.  
  996. option[0]/*effect*/ = function (obj) {
  997. if (runningTouchEffect) {
  998. runningTouchEffect = FALSE;
  999. obj.options.ease = easingToUse;
  1000. return slide(obj);
  1001. } else {
  1002. return prevEffect(obj);
  1003. }
  1004. };
  1005. var initialOffsetLeft;
  1006. var initialOffsetTop;
  1007.  
  1008. var startTime;
  1009. var lastTime;
  1010. var lastDistance;
  1011.  
  1012. var bufferSize = 3;
  1013. var positionsBuffer = [];
  1014. var timeBuffer = [];
  1015. var bufferIndex = 0;
  1016.  
  1017. function touchStart(x, y) {
  1018. currentlyAnimating = TRUE;
  1019. ensureSliderContainerCSSDurationReset();
  1020. initialOffsetTop = currentSliderPositionTop;
  1021. initialOffsetLeft = currentSliderPositionLeft;
  1022.  
  1023. var distance;
  1024. if (option[7]/*vertical*/) {
  1025. distance = mathAbs(y);
  1026. } else {
  1027. distance = mathAbs(x);
  1028. }
  1029.  
  1030. lastDistance = distance;
  1031. startTime = getTimeInMillis();
  1032. lastTime = startTime;
  1033. }
  1034.  
  1035. function touchMove(x, y) {
  1036. var distance;
  1037. if (option[7]/*vertical*/) {
  1038. distance = mathAbs(y);
  1039. } else {
  1040. distance = mathAbs(x);
  1041. }
  1042. positionsBuffer[bufferIndex] = distance - lastDistance;
  1043. var newTime = getTimeInMillis();
  1044. timeBuffer[bufferIndex] = newTime - lastTime;
  1045. bufferIndex = (bufferIndex + 1) % bufferSize;
  1046.  
  1047. lastTime = newTime;
  1048. lastDistance = distance;
  1049.  
  1050. if (option[7]/*vertical*/) {
  1051. x = 0;
  1052. } else {
  1053. y = 0;
  1054. }
  1055. adjustPositionToPosition(initialOffsetLeft + x, initialOffsetTop + y);
  1056. }
  1057.  
  1058. function touchEnd(x, y) {
  1059. var distance;
  1060. if (option[7]/*vertical*/) {
  1061. distance = y;
  1062. } else {
  1063. distance = x;
  1064. }
  1065. var distanceAbs = mathAbs(distance);
  1066. var currentTime = getTimeInMillis();
  1067. var time = 0;
  1068. var bufferDistance = 0;
  1069. for (var i = 0; i < bufferSize; i++) {
  1070. var thisTime = timeBuffer[i];
  1071. if (thisTime + 100 < currentTime) {
  1072. time += thisTime;
  1073. bufferDistance += positionsBuffer[i];
  1074. }
  1075. }
  1076. var slideDimensions;
  1077. if (option[7]/*vertical*/) {
  1078. slideDimensions = obj.height();
  1079. } else {
  1080. slideDimensions = obj.width();
  1081. }
  1082. // This is in pixels pr. ms.
  1083. var speed = mathAbs(bufferDistance) / time;
  1084.  
  1085. var goToAnotherSlide = speed >= 0.2 || distanceAbs >= slideDimensions / 2;
  1086.  
  1087. if ((bufferDistance > 0 && distanceAbs < 0) || (bufferDistance < 0 && distanceAbs > 0) || distanceAbs <= 10) {
  1088. goToAnotherSlide = FALSE;
  1089. }
  1090.  
  1091.  
  1092. var direction = distance < 0 ? NEXT_STRING : PREV_STRING;
  1093.  
  1094. if (!option[16]/*continuous*/) {
  1095. if (currentSlide + 1 == totalSlides) {
  1096. if (direction == NEXT_STRING) {
  1097. goToAnotherSlide = FALSE;
  1098. }
  1099. } else if (currentSlide == 0) {
  1100. if (direction == PREV_STRING) {
  1101. goToAnotherSlide = FALSE;
  1102. }
  1103. }
  1104. }
  1105.  
  1106. var distanceLeft;
  1107. if (goToAnotherSlide) {
  1108. distanceLeft = slideDimensions - distanceAbs;
  1109. } else {
  1110. distanceLeft = distanceAbs;
  1111. }
  1112.  
  1113. var timeFromSpeed = (distanceLeft / speed) * 1.3;
  1114. var timeFromDistance = mathMax((option[1]/*speed*/) * (slideDimensions / distanceLeft), (option[1]/*speed*/) / 4);
  1115.  
  1116. var timeLeft;
  1117. if (timeFromSpeed < timeFromDistance) {
  1118. timeLeft = mathMin(timeFromSpeed, (option[1]/*speed*/));
  1119. } else {
  1120. timeLeft = mathMin(timeFromDistance, (option[1]/*speed*/));
  1121. }
  1122.  
  1123. var cubicBezierY = (speed*timeLeft)/(distanceLeft + speed*timeLeft);
  1124. var cubicBezierX = 1-cubicBezierY;//distanceLeft/(distanceLeft + speed*timeLeft);
  1125.  
  1126. if (option[39]/*useCSS*/) {
  1127. easingToUse = "cubic-bezier(" + cubicBezierX + "," + cubicBezierY + ",0.3,1)";
  1128. } else {
  1129. easingToUse = makeBezier([cubicBezierX || 0, cubicBezierY || 0, 0.3, 1]);
  1130. }
  1131.  
  1132. clickable = FALSE;
  1133. runningTouchEffect = TRUE;
  1134. if (goToAnotherSlide) {
  1135. performAnimation(filterDir(direction), timeLeft, TRUE, TRUE, TRUE);
  1136. } else {
  1137. performAnimation(currentSlide, timeLeft, TRUE, TRUE, TRUE);
  1138. }
  1139. }
  1140.  
  1141. {
  1142. var startedTouch = FALSE;
  1143. var startX = 0;
  1144. var startY = 0;
  1145. var prevX = 0;
  1146. var prevY = 0;
  1147.  
  1148. var dragFunction = function (event) {
  1149. if (!clickable) {
  1150. return;
  1151. }
  1152. var type = event.type;
  1153. var startEvent;
  1154. var endEvent1;
  1155. var endEvent2;
  1156. var isMouseEvent = type.substr(0, 1) == "m";
  1157. if (isMouseEvent) {
  1158. startEvent = MOUSEDOWN;
  1159. endEvent1 = MOUSEUP;
  1160. endEvent2 = "";
  1161. } else {
  1162. startEvent = TOUCHSTART;
  1163. endEvent1 = TOUCHEND;
  1164. endEvent2 = TOUCHCANCEL;
  1165. event = event.originalEvent;
  1166. }
  1167.  
  1168.  
  1169. if (!startedTouch) {
  1170. if (type != startEvent) {
  1171. return;
  1172. }
  1173.  
  1174. var eventTarget = event.target;
  1175. var target = $(eventTarget);
  1176. if (!option[43]/*touchHandle*/) {
  1177. target = target.parents().add(eventTarget);
  1178. }
  1179. var filter = option[43]/*touchHandle*/ || obj;
  1180.  
  1181. var isTarget = target.filter(filter).length;
  1182.  
  1183. if (!isTarget) {
  1184. return;
  1185. } else {
  1186. startedTouch = TRUE;
  1187. }
  1188. }
  1189.  
  1190. if (type != endEvent1 && type != endEvent2) {
  1191. var x;
  1192. var y;
  1193. if (isMouseEvent) {
  1194. x = event.pageX;
  1195. y = event.pageY;
  1196. } else {
  1197. var touch = event.touches[0];
  1198. x = touch.pageX;
  1199. y = touch.pageY;
  1200. }
  1201.  
  1202.  
  1203. if (type == startEvent) {
  1204. startX = x;
  1205. startY = y;
  1206. touchStart(x - startX, y - startY)
  1207. } else {
  1208. touchMove(x - startX, y - startY);
  1209. }
  1210.  
  1211. allowScroll(event, isMouseEvent, prevX, prevY, x - startX, y - startY);
  1212.  
  1213. prevX = x - startX;
  1214. prevY = y - startY;
  1215. } else {
  1216. touchEnd(prevX, prevY);
  1217. startedTouch = FALSE;
  1218. event.preventDefault();
  1219. }
  1220. };
  1221. bindMultiple(document, dragFunction, [TOUCHSTART, TOUCHMOVE, TOUCHEND, TOUCHCANCEL, MOUSEDOWN, MOUSEMOVE, MOUSEUP]);
  1222. }
  1223.  
  1224. function allowScroll(event, isMouseEvent, prevX, prevY, x, y) {
  1225. isMouseEvent = FALSE;
  1226. if (isMouseEvent || isDirectionVertical(prevX, prevY, x, y) == option[7]/*vertical*/) {
  1227. event.preventDefault();
  1228. }
  1229. }
  1230.  
  1231. function isDirectionVertical(prevX, prevY, x, y) {
  1232. var dX = prevX - x;
  1233. var dY = prevY - y;
  1234.  
  1235. return mathAbs(dY / dX) >= 1;
  1236. }
  1237. }
  1238.  
  1239. function performCallbacks(callbacks) {
  1240. while (callbacks && callbacks.length) {
  1241. // Removing and running the first, so we maintain FIFO.
  1242. callbacks.splice(0, 1)[0]();
  1243. }
  1244. }
  1245.  
  1246. function isContentInSlideReady(slide) {
  1247. if (!imagesInSlidesLoaded[slide]) {
  1248. return FALSE;
  1249. }
  1250. if (!option[31]/*ajax*/) {
  1251. return TRUE;
  1252. } else {
  1253. if (option[31]/*ajax*/[slide]) {
  1254. return FALSE;
  1255. }
  1256. return !(startedAjaxLoads[slide] && !finishedAjaxLoads[slide]);
  1257. }
  1258. }
  1259.  
  1260. function loadSlidesAndAnimate(i, clicked, speed) {
  1261. var dir = filterDir(i);
  1262. var prevNext = i == NEXT_STRING || i == PREV_STRING;
  1263.  
  1264. var targetSlide = getRealPos(dir);
  1265. if (targetSlide == currentSlide) {
  1266. return;
  1267. }
  1268. clickable = FALSE;
  1269. if (option[31]/*ajax*/) {
  1270. var waitCounter = 0;
  1271. for (var loadSlide = targetSlide; loadSlide < targetSlide + numberOfVisibleSlides; loadSlide++) {
  1272. var realLoadSlide = getRealPos(loadSlide);
  1273. if (!isContentInSlideReady(realLoadSlide)) {
  1274. waitCounter++;
  1275. ajaxLoad(realLoadSlide, function () {
  1276. // This runs aync, so every callback is placed before the first is run. Therefore this works.
  1277. waitCounter--;
  1278. if (waitCounter == 0) {
  1279. option[41]/*loadFinish*/.call(baseSlider, dir + 1);
  1280. performAnimation(dir, speed, clicked, prevNext);
  1281. }
  1282. });
  1283. }
  1284. }
  1285. if (waitCounter == 0) {
  1286. performAnimation(dir, speed, clicked, prevNext);
  1287. } else {
  1288. option[40]/*loadStart*/.call(baseSlider, dir + 1);
  1289. }
  1290. } else {
  1291. performAnimation(dir, speed, clicked, prevNext);
  1292. }
  1293. }
  1294.  
  1295. function ensureSliderContainerCSSDurationReset() {
  1296. if (option[39]/*useCSS*/) {
  1297. slidesContainer.css(CSSVendorPrefix + "transition-duration", "");
  1298. }
  1299. }
  1300.  
  1301. var reorderedSlidesToStartFromSlide = 0;
  1302. function reorderSlides(slide) {
  1303. if (getRealPos(slide) == reorderedSlidesToStartFromSlide) {
  1304. return;
  1305. }
  1306. reorderedSlidesToStartFromSlide = slide;
  1307. ensureSliderContainerCSSDurationReset();
  1308. for (var i = 0; i < totalSlides; i++) {
  1309. var slideToInsert = slides[getRealPos((slide + i))];
  1310. slidesContainer.append(slideToInsert);
  1311. }
  1312. adjustPositionTo(currentSlide);
  1313. }
  1314.  
  1315. function centerTargetSlideAdjusted(targetSlide, extraSpace) {
  1316. var offset = mathMax(parseInt10((totalSlides - extraSpace - numberOfVisibleSlides) / 2), 0);
  1317. targetSlide = mod(targetSlide - offset, totalSlides);
  1318. reorderSlides(targetSlide);
  1319. }
  1320.  
  1321. function centerTargetSlideAfter(targetSlide) {
  1322. centerTargetSlideAdjusted(targetSlide, 0);
  1323. }
  1324.  
  1325. function centerTargetSlideBefore(targetSlide) {
  1326. var startSlide = mathMin(targetSlide, currentSlide);
  1327. var adjustment = mathAbs(targetSlide - currentSlide);
  1328.  
  1329. centerTargetSlideAdjusted(startSlide, adjustment);
  1330. }
  1331.  
  1332.  
  1333. function performAnimation(dir, speed, clicked, prevNext, skipPreCenterTargetSlide) {
  1334. if (option[30]/*updateBefore*/) setCurrent(dir);
  1335.  
  1336. if (option[27]/*history*/ && clicked) win.location.hash = option[19]/*numerictext*/[dir];
  1337.  
  1338. if (option[5]/*controlsfade*/) fadeControls(dir, option[4]/*controlsfadespeed*/);
  1339.  
  1340. var fromSlides = $();
  1341. var toSlides = $();
  1342. for (var a = 0; a < numberOfVisibleSlides; a++) {
  1343. fromSlides = fromSlides.add(slides[getRealPos(currentSlide + a)]);
  1344. toSlides = toSlides.add(slides[getRealPos(dir + a)]);
  1345. }
  1346.  
  1347.  
  1348. // Finding a "shortcut", used for calculating the offsets.
  1349. var diff = -currentSlide + dir;
  1350. var targetSlide;
  1351. if (option[16]/*continuous*/ && !prevNext) {
  1352. var diffAbs = mathAbs(diff);
  1353. targetSlide = dir;
  1354.  
  1355. var newDiff = -currentSlide + dir + totalSlides;
  1356. if (mathAbs(newDiff) < diffAbs) {
  1357. targetSlide = dir + totalSlides;
  1358. diff = newDiff;
  1359. diffAbs = mathAbs(diff);
  1360. }
  1361.  
  1362. newDiff = -currentSlide + dir - totalSlides;
  1363. if (mathAbs(newDiff) < diffAbs) {
  1364. targetSlide = dir - totalSlides;
  1365. diff = newDiff;
  1366. }
  1367. } else {
  1368. targetSlide = dir;
  1369. }
  1370.  
  1371. if (option[16]/*continuous*/ && !skipPreCenterTargetSlide) {
  1372. centerTargetSlideBefore(targetSlide);
  1373. }
  1374.  
  1375. var leftTarget = getSlidePosition(targetSlide, FALSE);
  1376. var topTarget = getSlidePosition(targetSlide, TRUE);
  1377.  
  1378. var targetLi = slides[getRealPos(dir)];
  1379. var callOptions = $.extend(TRUE, {}, options); // Making a copy, to enforce read-only.
  1380. var overwritingSpeed = option[1]/*speed*/;
  1381. var attributeSpeed = targetLi.attr("data-speed");
  1382. if (attributeSpeed != undefined) {
  1383. overwritingSpeed = parseInt10(attributeSpeed);
  1384. }
  1385. if (speed != undefined) {
  1386. overwritingSpeed = parseInt10(speed);
  1387. }
  1388. callOptions.speed = overwritingSpeed;
  1389.  
  1390. var effect = option[0]/*effect*/;
  1391.  
  1392. var specificEffectAttrName = "data-effect";
  1393. var slideSpecificEffect = targetLi.attr(specificEffectAttrName);
  1394. if (slideSpecificEffect) {
  1395. effect = getEffectMethod(slideSpecificEffect);
  1396. }
  1397.  
  1398. var slideOutSlide = slides[currentSlide];
  1399. if (slideOutSlide) {
  1400. var slideOutSpecificEffect = slides[currentSlide].attr(specificEffectAttrName + "out")
  1401. if (slideOutSpecificEffect) {
  1402. effect = getEffectMethod(slideOutSpecificEffect);
  1403. }
  1404. }
  1405.  
  1406. currentlyAnimating = TRUE;
  1407. currentAnimation = effect;
  1408.  
  1409. var callbackHasYetToRun = TRUE;
  1410. currentAnimationCallback = function () {
  1411. currentlyAnimating = FALSE;
  1412. callbackHasYetToRun = FALSE;
  1413.  
  1414. goToSlide(dir, clicked);
  1415. fixClearType(toSlides);
  1416.  
  1417. if (option[16]/*continuous*/) {
  1418. centerTargetSlideAfter(targetSlide);
  1419. }
  1420.  
  1421. // afteranimation
  1422. aniCall(dir, TRUE);
  1423. if (option[11]/*responsive*/) {
  1424. adjustResponsiveLayout();
  1425. }
  1426.  
  1427. performCallbacks(runAfterAnimationCallbacks);
  1428. };
  1429. currentAnimationObject = {
  1430. fromSlides: fromSlides,
  1431. toSlides: toSlides,
  1432. slider: obj,
  1433. container: slidesContainer,
  1434. options: callOptions,
  1435. to: dir + 1,
  1436. from: currentSlide + 1,
  1437. diff: diff,
  1438. target: {
  1439. left: leftTarget,
  1440. top: topTarget
  1441. },
  1442. stopCallbacks: [],
  1443. callback: function () {
  1444. if (callbackHasYetToRun) {
  1445. callbackHasYetToRun = FALSE;
  1446. stopAnimation();
  1447. }
  1448. },
  1449. goToNext: function () {
  1450. if (callbackHasYetToRun) {
  1451. // Only moving after there is content ready to replace the previous.
  1452. runOnImagesLoaded($("." + ANIMATION_CLONE_MARKER_CLASS, obj), TRUE, makeCallback(adjustPositionTo, [dir]));
  1453. }
  1454. }
  1455. };
  1456.  
  1457. autoadjust(dir, overwritingSpeed);
  1458. callAsync(function () {
  1459. // beforeanimation
  1460. aniCall(dir, FALSE, TRUE);
  1461.  
  1462. effect.call(baseSlider, currentAnimationObject);
  1463. });
  1464. }
  1465.  
  1466. function stopAnimation() {
  1467. if (currentlyAnimating) {
  1468. //noinspection JSUnusedAssignment
  1469. animationWasInterrupted = TRUE;
  1470. // Doing it in this order isn't a problem in relation to the user-callbacks, since they are run in a setTimeout(callback, 0) anyway.
  1471. currentAnimationCallback();
  1472.  
  1473. performCallbacks(currentAnimationObject.stopCallbacks);
  1474.  
  1475.  
  1476. var stopFunction = currentAnimation.stop;
  1477. if (stopFunction) {
  1478. stopFunction();
  1479. } else {
  1480. defaultStopFunction();
  1481. }
  1482. autoadjust(currentSlide, 0);
  1483. adjustPositionTo(currentSlide);
  1484. animationWasInterrupted = FALSE;
  1485. }
  1486. }
  1487.  
  1488. function bindAndRegisterOff(element, events, handler, selector) {
  1489. element.on(events, selector, handler);
  1490. unBindCallbacks.push(function () {
  1491. element.off(events, selector, handler);
  1492. });
  1493. }
  1494.  
  1495.  
  1496. function bindMultiple(element, func, events) {
  1497. for (var i=0; i < events.length; i++) {
  1498. bindAndRegisterOff($(element), events[i], func);
  1499. }
  1500. }
  1501.  
  1502. function cantDoAdjustments() {
  1503. return !obj.is(":visible") || init;
  1504. }
  1505.  
  1506. function defaultStopFunction() {
  1507. $("." + ANIMATION_CLONE_MARKER_CLASS, obj).remove();
  1508. slidesContainer.stop();
  1509. }
  1510.  
  1511. function goToSlide(slide, clicked) {
  1512. clickable = !clicked && !option[13]/*auto*/;
  1513. previousSlide = currentSlide;
  1514. currentSlide = slide;
  1515.  
  1516. adjust(clicked);
  1517.  
  1518. if (option[5]/*controlsfade*/ && init) {
  1519. fadeControls(currentSlide, 0);
  1520. }
  1521. // This is handles in AjaxAdjust, if something is loading.
  1522. if (init && !option[31]/*ajax*/[currentSlide] && !startedAjaxLoads[currentSlide]) {
  1523. init = FALSE;
  1524. callAsync(performInitCallback);
  1525. }
  1526. }
  1527.  
  1528. function getSlides(from, count) {
  1529. var visibleSlides = $();
  1530. for (var i = 0; i < count; i++) {
  1531. visibleSlides = visibleSlides.add(slides[getRealPos(from + i)]);
  1532. }
  1533. return visibleSlides;
  1534. }
  1535.  
  1536. function getRealPos(a) {
  1537. return mod(a, totalSlides);
  1538. }
  1539.  
  1540. function fixClearType(element) {
  1541. if (screen.fontSmoothingEnabled && element.style) element.style.removeAttribute("filter"); // Fix cleartype
  1542. }
  1543.  
  1544. /*
  1545. * Public methods.
  1546. */
  1547.  
  1548. // First i just define those i use more than one. Then i just add the others as anonymous functions.
  1549. function publicDestroy() {
  1550. stopAnimation();
  1551. destroyed = TRUE;
  1552. slideNumberBeforeDestroy = currentSlide;
  1553.  
  1554. performCallbacks(unBindCallbacks);
  1555.  
  1556. ensureSliderContainerCSSDurationReset();
  1557.  
  1558. if (controls) {
  1559. controls.remove();
  1560. }
  1561.  
  1562. reorderSlides(0);
  1563.  
  1564. adjustPositionTo(currentSlide);
  1565. autoadjust(currentSlide, 0);
  1566.  
  1567. option[44]/*destroyCallback*/.call(baseSlider);
  1568. }
  1569.  
  1570. baseSlider.destroy = publicDestroy;
  1571.  
  1572. function publicInit() {
  1573. if (destroyed) {
  1574. initSudoSlider();
  1575. }
  1576. }
  1577.  
  1578. baseSlider.init = publicInit;
  1579.  
  1580. baseSlider.getOption = function (a) {
  1581. return options[a.toLowerCase()];
  1582. };
  1583.  
  1584. baseSlider.setOption = function (name, val) {
  1585. publicDestroy();
  1586. if ($.isPlainObject(name)) {
  1587. for (var a in name) {
  1588. options[a] = name[a];
  1589. }
  1590. } else {
  1591. options[name.toLowerCase()] = val;
  1592. }
  1593. publicInit();
  1594. };
  1595.  
  1596. baseSlider.runWhenNotAnimating = runWhenNotAnimating;
  1597.  
  1598. baseSlider.insertSlide = function (html, pos, numtext, goToSlide) {
  1599. publicDestroy();
  1600. // pos = 0 means before everything else.
  1601. // pos = 1 means after the first slide.
  1602. // if pos is negative, then we count from the right instead.
  1603. if (pos < 0) {
  1604. pos = totalSlides - mod(-pos - 1, totalSlides + 1);
  1605. } else {
  1606. pos = mod(pos, totalSlides + 1);
  1607. }
  1608.  
  1609. html = $(html || "<div>");
  1610. if (isSlideContainerUl) {
  1611. html = $("<li>").prepend(html);
  1612. } else {
  1613. if (html.length != 1) {
  1614. html = $("<div>").prepend(html);
  1615. } else {
  1616. // Inserting as is.
  1617. }
  1618. }
  1619.  
  1620. if (!pos || pos == 0) {
  1621. slidesContainer.prepend(html);
  1622. } else {
  1623. slides[pos - 1].after(html);
  1624. }
  1625.  
  1626. // Finally, we make it work again.
  1627. if (goToSlide) {
  1628. slideNumberBeforeDestroy = goToSlide - 1;
  1629. } else if (pos <= slideNumberBeforeDestroy || (!pos || pos == 0)) {
  1630. slideNumberBeforeDestroy++;
  1631. }
  1632.  
  1633. if (option[19]/*numerictext*/.length < pos) {
  1634. option[19]/*numerictext*/.length = pos;
  1635. }
  1636.  
  1637. option[19]/*numerictext*/.splice(pos, 0, numtext || parseInt10(pos) + 1);
  1638. publicInit();
  1639. };
  1640.  
  1641. baseSlider.removeSlide = function (pos) {
  1642. pos--; // 1 == the first.
  1643. publicDestroy();
  1644.  
  1645. slides[mathMin(pos, totalSlides - 1)].remove();
  1646. option[19]/*numerictext*/.splice(pos, 1);
  1647. if (pos < slideNumberBeforeDestroy) {
  1648. slideNumberBeforeDestroy--;
  1649. }
  1650.  
  1651. publicInit();
  1652. };
  1653.  
  1654. baseSlider.goToSlide = function (a, speed) {
  1655. var parsedDirection = (a == parseInt10(a)) ? a - 1 : a;
  1656. callAsync(makeCallback(enqueueAnimation, [parsedDirection, TRUE, speed]));
  1657. };
  1658.  
  1659. baseSlider.block = function () {
  1660. clickable = FALSE;
  1661. };
  1662.  
  1663. baseSlider.unblock = function () {
  1664. clickable = TRUE;
  1665. };
  1666.  
  1667. baseSlider.startAuto = function () {
  1668. option[13]/*auto*/ = TRUE;
  1669. startAuto();
  1670. };
  1671.  
  1672. baseSlider.stopAuto = function () {
  1673. option[13]/*auto*/ = FALSE;
  1674. stopAuto();
  1675. };
  1676.  
  1677. baseSlider.adjust = function () {
  1678. var autoAdjustSpeed = mathMax(adjustTargetTime - getTimeInMillis(), 0);
  1679. autoadjust(currentSlide, autoAdjustSpeed);
  1680. if (!currentlyAnimating) {
  1681. adjustPositionTo(currentSlide);
  1682. }
  1683. };
  1684.  
  1685. baseSlider.getValue = function (a) {
  1686. return {
  1687. currentslide: currentSlide + 1,
  1688. totalslides: totalSlides,
  1689. clickable: clickable,
  1690. destroyed: destroyed,
  1691. autoanimation: autoOn
  1692. }[a.toLowerCase()];
  1693. };
  1694.  
  1695. baseSlider.getSlide = function (number) {
  1696. return slides[getRealPos(parseInt10(number) - 1)];
  1697. };
  1698.  
  1699. baseSlider.stopAnimation = stopAnimation;
  1700.  
  1701. // Done, now initialize.
  1702. initSudoSlider();
  1703. });
  1704. };
  1705. /*
  1706. * End generic slider. Start animations.
  1707. * A lot of the code here is an if-else-elseif nightmare. This is because it is smaller in JavaScript, and this thing needs to be small (when minimized).
  1708. */
  1709.  
  1710. var GROW_IN = "GrowIn";
  1711. var GROW_OUT = "GrowOut";
  1712. var ROUNDED = "Rounded";
  1713.  
  1714. // Start by defining everything, the implementations are below.
  1715. var normalEffectsPrefixObject = {
  1716. box: {
  1717. Random: [
  1718. "",
  1719. GROW_IN,
  1720. GROW_IN + ROUNDED,
  1721. GROW_OUT,
  1722. GROW_OUT + ROUNDED,
  1723. boxRandomTemplate
  1724. ],
  1725. Rain: [
  1726. "",
  1727. GROW_IN,
  1728. GROW_IN + ROUNDED,
  1729. GROW_OUT,
  1730. GROW_OUT + ROUNDED,
  1731. "FlyIn",
  1732. "FlyOut",
  1733. [
  1734. "UpLeft",
  1735. "DownLeft",
  1736. "DownRight",
  1737. "UpRight",
  1738. boxRainTemplate
  1739. ]
  1740. ],
  1741. Spiral: [
  1742. "InWards",
  1743. "OutWards",
  1744. {
  1745. "": boxSpiralTemplate,
  1746. Grow: [
  1747. "In",
  1748. "Out",
  1749. [
  1750. "",
  1751. "Rounded",
  1752. boxSpiralGrowTemplate
  1753. ]
  1754. ]
  1755. }
  1756. ]
  1757. },
  1758. fade: {
  1759. "": fade,
  1760. OutIn: fadeOutIn
  1761. },
  1762. foldRandom: [
  1763. "Horizontal",
  1764. "Vertical",
  1765. foldRandom
  1766. ],
  1767. slide: slide,
  1768. stack: [
  1769. "Up",
  1770. "Right",
  1771. "Down",
  1772. "Left",
  1773. [
  1774. "",
  1775. "Reverse",
  1776. stackTemplate
  1777. ]
  1778. ]
  1779. }
  1780.  
  1781. // Generic effects needs to have a "dir" attribute as their last argument.
  1782. var genericEffectsPrefixObject = {
  1783. blinds: [
  1784. "1",
  1785. "2",
  1786. blinds
  1787. ],
  1788. fold: fold,
  1789. push:
  1790. [
  1791. "Out",
  1792. "In",
  1793. pushTemplate
  1794. ],
  1795. reveal: revealTemplate,
  1796. slice: {
  1797. "": [
  1798. "",
  1799. "Reveal",
  1800. [
  1801. "",
  1802. "Reverse",
  1803. "Random",
  1804. slice
  1805. ]
  1806. ],
  1807. Fade: slicesFade
  1808. },
  1809. zip: zip,
  1810. unzip: unzip
  1811. }
  1812.  
  1813.  
  1814. function parsePrefixedEffects(resultObject, effectsObject, prefix, generic, argumentsStack) {
  1815. if (isFunction(effectsObject)) {
  1816. if (generic) {
  1817. // Parsing the value 0, as a hack to make generic effects work, see the below else case.
  1818. parsePrefixedEffects(resultObject, ["", "Up", "Right", "Down", "Left", effectsObject], prefix, 0, argumentsStack);
  1819. } else {
  1820. resultObject[prefix] = function (obj) {
  1821. var argumentArray = [obj].concat(argumentsStack);
  1822.  
  1823. // Ugly hack, to make "generic" functions to work.
  1824. var genericArgumentIndex = (argumentArray.length - 1);
  1825. if (generic === 0 && argumentArray[genericArgumentIndex] == 0) {
  1826. argumentArray[genericArgumentIndex] = getDirFromAnimationObject(obj);
  1827. }
  1828.  
  1829. effectsObject.apply(this, argumentArray);
  1830. }
  1831. }
  1832. } else if (isArray(effectsObject)) {
  1833. var effectIndex = effectsObject.length - 1;
  1834. var effect = effectsObject[effectIndex];
  1835. for (var i = 0; i < effectIndex; i++) {
  1836. var newArgumentStack = cloneArray(argumentsStack);
  1837. newArgumentStack.push(i);
  1838. var name = effectsObject[i];
  1839. parsePrefixedEffects(resultObject, effect, prefix + name, generic, newArgumentStack);
  1840. }
  1841. } else {
  1842. $.each(effectsObject, function (name, effect) {
  1843. parsePrefixedEffects(resultObject, effect, prefix + name, generic, argumentsStack);
  1844. });
  1845. }
  1846. }
  1847.  
  1848.  
  1849. var allEffects = {};
  1850. parsePrefixedEffects(allEffects, genericEffectsPrefixObject, "", TRUE, []);
  1851. parsePrefixedEffects(allEffects, normalEffectsPrefixObject, "", FALSE, []);
  1852.  
  1853. allEffects.random = makeRandomEffect(allEffects);
  1854.  
  1855. // Saving it.
  1856. $.fn.sudoSlider.effects = allEffects;
  1857.  
  1858.  
  1859. // The implementations
  1860. // dir: 0: UpRight, 1: DownRight: 2: DownLeft, 3: UpLeft
  1861. // effect: 0: none, 1: growIn, 2: growRoundedIn, 3: growOut, 4: growRoundedOut, 5: flyIn, 6: flyOut
  1862. function boxRainTemplate(obj, effect, dir) {
  1863. var reverseRows = dir == 1 || dir == 3;
  1864. var reverse = dir == 0 || dir == 3;
  1865. var grow = effect >= 1 && effect <= 4;
  1866. var flyIn = effect == 5 || effect == 6;
  1867. var reveal = effect == 6 || effect == 3 || effect == 4;
  1868. var roundedGrow = effect == 2 || effect == 4;
  1869. boxTemplate(obj, reverse, reverseRows, grow, FALSE, 1, flyIn, reveal, roundedGrow);
  1870. }
  1871.  
  1872. function boxSpiralTemplate(obj, direction) {
  1873. boxTemplate(obj, direction, FALSE, FALSE, FALSE, 2, FALSE, FALSE, FALSE);
  1874. }
  1875.  
  1876. function boxSpiralGrowTemplate(obj, direction, reveal, rounded) {
  1877. boxTemplate(obj, direction, FALSE, TRUE, FALSE, 2, FALSE, reveal, rounded);
  1878. }
  1879.  
  1880. // effect: 0: no grow, 1: growIn: 2: growInRounded, 3: growOut, 4: growOutRounded
  1881. function boxRandomTemplate(obj, effect) {
  1882. var reveal = effect == 3 || effect == 4;
  1883. var roundedGrow = effect == 2 || effect == 4;
  1884. boxTemplate(obj, FALSE, FALSE, effect != 0, TRUE, 0, FALSE, reveal, roundedGrow);
  1885. }
  1886.  
  1887. // SelectionAlgorithm: 0: Standard selection, 1: rain, 2: spiral
  1888. function boxTemplate(obj, reverse, reverseRows, grow, randomize, selectionAlgorithm, flyIn, reveal, roundedGrow) {
  1889. var options = obj.options;
  1890. var ease = options.ease;
  1891. var boxRows = options.boxrows;
  1892. var boxCols = options.boxcols;
  1893. var totalBoxes = boxRows * boxCols;
  1894. var speed = options.speed / (totalBoxes == 1 ? 1 : 2.5); // To make the actual time spent equal to options.speed.
  1895. var boxes = createBoxes(obj, boxCols, boxRows, !reveal);
  1896. var timeBuff = 0;
  1897. var rowIndex = 0;
  1898. var colIndex = 0;
  1899. var box2DArr = [];
  1900. box2DArr[rowIndex] = [];
  1901. if (reverse) {
  1902. reverseArray(boxes);
  1903. }
  1904. if (randomize) {
  1905. shuffle(boxes);
  1906. }
  1907.  
  1908.  
  1909. boxes.each(function () {
  1910. box2DArr[rowIndex][colIndex] = this;
  1911. colIndex++;
  1912. if (colIndex == boxCols) {
  1913. if (reverseRows) {
  1914. reverseArray(box2DArr[rowIndex]);
  1915. }
  1916. rowIndex++;
  1917. colIndex = 0;
  1918. box2DArr[rowIndex] = [];
  1919. }
  1920. });
  1921.  
  1922. var boxesResult = [];
  1923. if (selectionAlgorithm == 1) {
  1924. // Rain
  1925. for (var cols = 0; cols < (boxCols * 2) + 1; cols++) {
  1926. var prevCol = cols;
  1927. var boxesResultLine = [];
  1928. for (var rows = 0; rows < boxRows; rows++) {
  1929. if (prevCol >= 0 && prevCol < boxCols) {
  1930. var rawBox = box2DArr[rows][prevCol];
  1931. if (!rawBox) {
  1932. return;
  1933. }
  1934. boxesResultLine.push(rawBox);
  1935. }
  1936. prevCol--;
  1937. }
  1938. if (boxesResultLine.length != 0) {
  1939. boxesResult.push(boxesResultLine);
  1940. }
  1941. }
  1942. } else if (selectionAlgorithm == 2) {
  1943. // Spiral
  1944. // Algorithm borrowed from the Camera plugin by Pixedelic.com
  1945. var rows2 = boxRows / 2, x, y, z, n = reverse ? totalBoxes : -1;
  1946. var negative = reverse ? -1 : 1;
  1947. for (z = 0; z < rows2; z++) {
  1948. y = z;
  1949. for (x = z; x < boxCols - z - 1; x++) {
  1950. boxesResult[n += negative] = boxes.eq(y * boxCols + x);
  1951. }
  1952. x = boxCols - z - 1;
  1953. for (y = z; y < boxRows - z - 1; y++) {
  1954. boxesResult[n += negative] = boxes.eq(y * boxCols + x);
  1955. }
  1956. y = boxRows - z - 1;
  1957. for (x = boxCols - z - 1; x > z; x--) {
  1958. boxesResult[n += negative] = boxes.eq(y * boxCols + x);
  1959. }
  1960. x = z;
  1961. for (y = boxRows - z - 1; y > z; y--) {
  1962. boxesResult[n += negative] = boxes.eq(y * boxCols + x);
  1963. }
  1964. }
  1965. } else {
  1966. for (var row = 0; row < boxRows; row++) {
  1967. for (var col = 0; col < boxCols; col++) {
  1968. boxesResult.push([box2DArr[row][col]]);
  1969. }
  1970. }
  1971. }
  1972.  
  1973. if (reveal) {
  1974. obj.goToNext();
  1975. }
  1976.  
  1977. var count = 0;
  1978. for (var i = 0; i < boxesResult.length; i++) {
  1979. var boxLine = boxesResult[i];
  1980. for (var j = 0; j < boxLine.length; j++) {
  1981. var box = $(boxLine[j]);
  1982. (function (box, timeBuff) {
  1983. var boxChildren = box.children();
  1984. var orgWidth = box.width();
  1985. var orgHeight = box.height();
  1986. var goToWidth = orgWidth;
  1987. var goToHeight = orgHeight;
  1988. var orgLeft = parseNumber(box.css("left"));
  1989. var orgTop = parseNumber(box.css("top"));
  1990. var goToLeft = orgLeft;
  1991. var goToTop = orgTop;
  1992.  
  1993. var childOrgLeft = parseNumber(boxChildren.css("left"));
  1994. var childOrgTop = parseNumber(boxChildren.css("top"));
  1995. var childGoToLeft = childOrgLeft;
  1996. var childGoToTop = childOrgTop;
  1997.  
  1998. if (flyIn) {
  1999. var adjustLeft = reverse != reverseRows ? -goToWidth : goToWidth;
  2000. var adjustTop = reverse ? -goToHeight : goToHeight;
  2001.  
  2002. var flyDistanceFactor = 1.5;
  2003.  
  2004. if (reveal) {
  2005. goToLeft -= adjustLeft * flyDistanceFactor;
  2006. goToTop -= adjustTop * flyDistanceFactor;
  2007. } else {
  2008. box.css({left: orgLeft + adjustLeft * flyDistanceFactor, top: orgTop + adjustTop * flyDistanceFactor});
  2009. }
  2010. }
  2011.  
  2012. if (grow) {
  2013. if (reveal) {
  2014. childGoToLeft -= goToWidth / 2;
  2015. goToLeft += goToWidth / 2;
  2016. childGoToTop -= goToHeight / 2;
  2017. goToTop += goToHeight / 2;
  2018.  
  2019. goToHeight = goToWidth = 0;
  2020. } else {
  2021. box.css({left: orgLeft + (goToWidth / 2), top: orgTop + (goToHeight / 2)});
  2022. boxChildren.css({left: childOrgLeft - goToWidth / 2, top: childOrgTop - goToHeight / 2});
  2023.  
  2024. box.width(0).height(0);
  2025. if (roundedGrow) {
  2026. box.css({borderRadius: mathMax(orgHeight, orgWidth)});
  2027. }
  2028. }
  2029. }
  2030.  
  2031.  
  2032. if (reveal) {
  2033. box.css({opacity: 1});
  2034. }
  2035. count++;
  2036. setTimeout(function () {
  2037. animate(boxChildren, {left: childGoToLeft, top: childGoToTop}, speed, ease, FALSE, obj);
  2038. animate(box, {
  2039. opacity: reveal ? 0 : 1,
  2040. width: goToWidth,
  2041. height: goToHeight,
  2042. left: goToLeft,
  2043. top: goToTop,
  2044. borderRadius: grow && reveal && roundedGrow ? mathMax(orgHeight, orgWidth) : 0
  2045. }, speed, ease, function () {
  2046. count--;
  2047. if (count == 0) {
  2048. obj.callback();
  2049. }
  2050. }, obj);
  2051. }, timeBuff);
  2052. })(box, timeBuff);
  2053. }
  2054. timeBuff += (speed / boxesResult.length) * 1.5;
  2055. }
  2056. }
  2057.  
  2058. function slicesFade(obj, dir) {
  2059. var vertical = dir == 2 || dir == 4;
  2060. var negative = dir == 1 || dir == 4;
  2061. foldTemplate(obj, vertical, negative, FALSE, TRUE);
  2062. }
  2063.  
  2064. function fold(obj, dir) {
  2065. var vertical = dir == 2 || dir == 4;
  2066. var negative = dir == 1 || dir == 4;
  2067. foldTemplate(obj, vertical, negative);
  2068. }
  2069.  
  2070. function foldRandom(obj, vertical) {
  2071. foldTemplate(obj, vertical, FALSE, TRUE);
  2072. }
  2073.  
  2074. function blinds(obj, blindsEffect, dir) {
  2075. blindsEffect++;
  2076. var vertical = dir == 2 || dir == 4;
  2077. var negative = dir == 1 || dir == 4;
  2078. foldTemplate(obj, vertical, negative, FALSE, FALSE, blindsEffect);
  2079. }
  2080.  
  2081. function slice(obj, reveal, reverse, dir) {
  2082. var random = reverse == 2;
  2083. var vertical = dir == 1 || dir == 3;
  2084. var negative = dir == 1 || dir == 4;
  2085. foldTemplate(obj, vertical, reverse, random, FALSE, 0, negative ? 1 : 2, reveal);
  2086. }
  2087.  
  2088. function zip(obj, dir) {
  2089. var vertical = dir == 2 || dir == 4;
  2090. var negative = dir == 1 || dir == 4;
  2091. foldTemplate(obj, vertical, negative, FALSE, FALSE, 0, 3);
  2092. }
  2093.  
  2094. function unzip(obj, dir) {
  2095. var vertical = dir == 2 || dir == 4;
  2096. var negative = dir == 1 || dir == 4;
  2097. foldTemplate(obj, vertical, negative, FALSE, FALSE, 0, 3, TRUE);
  2098. }
  2099.  
  2100. function foldTemplate(obj, vertical, reverse, randomize, onlyFade, curtainEffect, upDownEffect, reveal) {
  2101. var options = obj.options;
  2102. var slides = options.slices;
  2103. var speed = options.speed / 2; // To make the actual time spent be equal to options.speed
  2104. var ease = options.ease;
  2105. var objSlider = obj.slider;
  2106. var slicesElement = createBoxes(obj, vertical ? slides : 1, vertical ? 1 : slides, !reveal);
  2107. var count = 0;
  2108. var upDownAlternator = FALSE;
  2109. if (reverse) {
  2110. reverseArray(slicesElement);
  2111. } else {
  2112. $(reverseArray(slicesElement.get())).appendTo(objSlider);
  2113. }
  2114. if (randomize) {
  2115. shuffle(slicesElement);
  2116. }
  2117. slicesElement.each(function (i) {
  2118. var timeout = ((speed / slides) * i);
  2119. var slice = $(this);
  2120. var orgWidth = slice.width();
  2121. var orgHeight = slice.height();
  2122. var goToLeft = slice.css("left");
  2123. var goToTop = slice.css("top");
  2124. var startPosition = vertical ? goToLeft : goToTop;
  2125.  
  2126. var innerBox = slice.children();
  2127. var startAdjustment = innerBox[vertical ? "width" : "height"]();
  2128. if (curtainEffect == 1) {
  2129. startPosition = 0
  2130. } else if (curtainEffect == 2) {
  2131. startPosition = startAdjustment / 2;
  2132. }
  2133. if (reverse) {
  2134. startPosition = startAdjustment - startPosition;
  2135. }
  2136. if (vertical) {
  2137. slice.css({
  2138. width: (onlyFade || upDownEffect ? orgWidth : 0),
  2139. left: startPosition
  2140. });
  2141. } else {
  2142. slice.css({
  2143. height: (onlyFade || upDownEffect ? orgHeight : 0),
  2144. top: startPosition
  2145. });
  2146. }
  2147.  
  2148. if (reveal) {
  2149. var negative = upDownEffect == 1 ? -1 : 1;
  2150. slice.css({
  2151. top: goToTop,
  2152. left: goToLeft,
  2153. width: orgWidth,
  2154. height: orgHeight,
  2155. opacity: 1
  2156. });
  2157. if (vertical) {
  2158. goToTop = negative * orgHeight;
  2159. } else {
  2160. goToLeft = negative * orgWidth;
  2161. }
  2162. }
  2163.  
  2164. if (upDownEffect) {
  2165. var bottom = TRUE;
  2166. if (upDownEffect == 3) {
  2167. if (upDownAlternator) {
  2168. bottom = FALSE;
  2169. upDownAlternator = FALSE;
  2170. } else {
  2171. upDownAlternator = TRUE;
  2172. }
  2173. } else if (upDownEffect == 2) {
  2174. bottom = FALSE;
  2175. }
  2176. if (vertical) {
  2177. if (reveal) {
  2178. goToTop = (bottom ? -1 : 1) * orgHeight;
  2179. } else {
  2180. slice.css({
  2181. bottom: bottom ? 0 : orgHeight,
  2182. top: bottom ? orgHeight : 0,
  2183. height: reveal ? orgHeight : 0
  2184. });
  2185. }
  2186. } else {
  2187. if (reveal) {
  2188. goToLeft = (bottom ? -1 : 1) * orgWidth;
  2189. } else {
  2190. slice.css({
  2191. right: bottom ? 0 : orgWidth,
  2192. left: bottom ? orgWidth : 0,
  2193. width: reveal ? orgWidth : 0
  2194. });
  2195. }
  2196. }
  2197. }
  2198.  
  2199.  
  2200. count++;
  2201. setTimeout(makeCallback(animate, [
  2202. slice, {
  2203. width: orgWidth,
  2204. height: orgHeight,
  2205. opacity: reveal ? 0 : 1,
  2206. left: goToLeft,
  2207. top: goToTop
  2208. }, speed, ease, function () {
  2209. count--;
  2210. if (count == 0) {
  2211. obj.callback();
  2212. }
  2213. }, obj])
  2214. , timeout);
  2215. });
  2216. if (reveal) {
  2217. obj.goToNext();
  2218. }
  2219. }
  2220.  
  2221. function stackTemplate(obj, dir, reverse) {
  2222. var pushIn = obj.diff > 0;
  2223. if (reverse) {
  2224. pushIn = !pushIn;
  2225. }
  2226.  
  2227. pushTemplate(obj, pushIn, ++dir);
  2228. }
  2229.  
  2230. // 1: up, 2: right, 3: down, 4, left:
  2231. function pushTemplate(obj, pushIn, dir) {
  2232. var vertical = dir == 2 || dir == 4;
  2233. var negative = (dir == 2 || dir == 3) ? 1 : -1;
  2234. var options = obj.options;
  2235. var ease = options.ease;
  2236. var speed = options.speed;
  2237. if (pushIn) {
  2238. var fromSlides = obj.fromSlides;
  2239. var toSlides = makeClone(obj, TRUE).hide();
  2240. toSlides.prependTo(obj.slider);
  2241. var height = mathMax(toSlides.height(), fromSlides.height());
  2242. var width = mathMax(toSlides.width(), fromSlides.width());
  2243. toSlides.css(vertical ? {left: negative * width} : {top: negative * height}).show();
  2244. animate(toSlides, {left: 0, top: 0}, speed, ease, obj.callback, obj);
  2245. } else {
  2246. var fromSlides = makeClone(obj, FALSE);
  2247. fromSlides.prependTo(obj.slider);
  2248. obj.goToNext();
  2249. var toSlides = obj.toSlides;
  2250.  
  2251. var measurementSlides = negative == -1 ? fromSlides : toSlides;
  2252. var height = measurementSlides.height();
  2253. var width = measurementSlides.width();
  2254.  
  2255. animate(fromSlides, vertical ? {left: negative * width} : {top: negative * height}, speed, ease, obj.callback, obj);
  2256. }
  2257. }
  2258.  
  2259. function revealTemplate(obj, dir) {
  2260. var vertical = dir == 1 || dir == 3;
  2261. var options = obj.options;
  2262. var ease = options.ease;
  2263. var speed = options.speed;
  2264. var innerBox = makeClone(obj, TRUE);
  2265. var width = innerBox.width();
  2266. var height = innerBox.height();
  2267. var box = makeBox(innerBox, 0, 0, 0, 0, obj)
  2268. .css({opacity: 1})
  2269. .appendTo(obj.slider);
  2270. var both = box.add(innerBox);
  2271. both.hide(); // FF css animation fix
  2272. if (vertical) {
  2273. box.css({width: width});
  2274. if (dir == 1) {
  2275. innerBox.css({top: -height});
  2276. box.css({bottom: 0, top: "auto"});
  2277. }
  2278. } else {
  2279. box.css({height: height});
  2280. if (dir == 4) {
  2281. innerBox.css({left: -width});
  2282. box.css({right: 0, left: "auto"});
  2283. }
  2284. }
  2285. // <FF css animation fix>
  2286. both.show();
  2287. if (vertical) {
  2288. both.width(width);
  2289. } else {
  2290. both.height(height);
  2291. }
  2292. // </FF css animation fix>
  2293. animate(innerBox, {left: 0, top: 0}, speed, ease, FALSE, obj);
  2294. animate(box, {width: width, height: height}, speed, ease, obj.callback, obj);
  2295. }
  2296.  
  2297. function slide(obj) {
  2298. var ul = childrenNotAnimationClones(obj.slider);
  2299. var options = obj.options;
  2300. var ease = options.ease;
  2301. var speed = options.speed;
  2302. var target = obj.target;
  2303.  
  2304. var left = target.left;
  2305. var top = target.top;
  2306.  
  2307. if (obj.options.usecss) {
  2308. animate(ul, {transform: "translate(" + left + "px, " + top + "px)"}, speed, ease, obj.callback, obj, TRUE);
  2309. } else {
  2310. animate(ul, {marginTop: top, marginLeft: left}, speed, ease, obj.callback, obj);
  2311. }
  2312. }
  2313.  
  2314. function animate(elem, properties, speed, ease, callback, obj, doNotResetCss) {
  2315. var usecss = !obj || obj.options.usecss;
  2316. if (CSSVendorPrefix === FALSE || !usecss) {
  2317. elem.animate(properties, speed, ease, callback);
  2318. return;
  2319. }
  2320.  
  2321. var CSSObject = {};
  2322. var transitionProperty = CSSVendorPrefix + "transition";
  2323. var keys = getKeys(properties);
  2324. // Adding vendor prefix, because sometimes it's needed.
  2325. CSSObject[transitionProperty] = keys.join(" ") + (CSSVendorPrefix == "" ? "" : " " + CSSVendorPrefix + keys.join(" " + CSSVendorPrefix));
  2326.  
  2327. var transitionTiming = transitionProperty + "-duration";
  2328. CSSObject[transitionTiming] = speed + "ms";
  2329.  
  2330. var transitionEase = transitionProperty + "-timing-function";
  2331. if (ease == "swing") {
  2332. ease = "ease-in-out";
  2333. }
  2334. CSSObject[transitionEase] = ease;
  2335.  
  2336. function resetCSS() {
  2337. if (!doNotResetCss) {
  2338. var cssObject = {};
  2339. cssObject[transitionTiming] = "0s";
  2340. cssObject[transitionEase] = "";
  2341. cssObject[transitionProperty] = "";
  2342. elem.css(cssObject);
  2343. }
  2344. }
  2345.  
  2346. if (obj) {
  2347. obj.stopCallbacks.push(resetCSS);
  2348. }
  2349.  
  2350. var eventsVendorPrefix = CSSVendorPrefix.replace(/\-/g, ""); // replaces all "-" with "";
  2351. var eventsSuffix = (eventsVendorPrefix ? "T" : "t") + "ransitionend";
  2352. var events = eventsVendorPrefix + eventsSuffix + " t" + "ransitionend";
  2353.  
  2354. var called = FALSE;
  2355. var callbackFunction = function () {
  2356. if (!called) {
  2357. called = TRUE;
  2358. elem.unbind(events);
  2359. resetCSS();
  2360. if (callback) {
  2361. callback();
  2362. }
  2363. }
  2364. };
  2365.  
  2366. callAsync(function () {
  2367. if (speed < 20) { // If instant animation
  2368. elem.css(properties);
  2369. callbackFunction();
  2370. return;
  2371. }
  2372. elem.css(CSSObject);
  2373.  
  2374. callAsync(function () {
  2375. elem.css(properties);
  2376.  
  2377. elem.on(events, function (event) {
  2378. if (elem.is(event.target)) {
  2379. callbackFunction();
  2380. }
  2381. });
  2382. // If the animation doesn't do anything, the bind will never be triggered, so this is a fallback.
  2383. setTimeout(callbackFunction, speed + 100);
  2384. });
  2385. });
  2386. return callbackFunction
  2387. }
  2388.  
  2389. function fadeOutIn(obj) {
  2390. var options = obj.options;
  2391. var fadeSpeed = options.speed;
  2392. var ease = options.ease;
  2393.  
  2394. var fadeinspeed = parseInt10(fadeSpeed * (3 / 5));
  2395. var fadeoutspeed = fadeSpeed - fadeinspeed;
  2396.  
  2397. obj.stopCallbacks.push(function () {
  2398. obj.fromSlides.stop().css({opacity: 1});
  2399. });
  2400.  
  2401. animate(obj.fromSlides, { opacity: 0.0001 }, fadeoutspeed, ease, makeCallback(finishFadeAnimation, [obj, fadeSpeed]), obj);
  2402. }
  2403.  
  2404.  
  2405. function fade(obj) {
  2406. finishFadeAnimation(obj, obj.options.speed);
  2407. }
  2408.  
  2409. function finishFadeAnimation(obj, speed) {
  2410. var options = obj.options;
  2411. options.boxcols = 1;
  2412. options.boxrows = 1;
  2413. options.speed = speed;
  2414. boxTemplate(obj, FALSE);
  2415. }
  2416.  
  2417. // 1: up, 2: right, 3: down, 4, left:
  2418. function getDirFromAnimationObject(obj) {
  2419. var vertical = obj.options.vertical;
  2420. var diff = obj.diff;
  2421. var dir;
  2422. if (vertical) {
  2423. if (diff < 0) {
  2424. dir = 1;
  2425. } else {
  2426. dir = 3;
  2427. }
  2428. } else {
  2429. if (diff < 0) {
  2430. dir = 2;
  2431. } else {
  2432. dir = 4;
  2433. }
  2434. }
  2435. return dir;
  2436. }
  2437.  
  2438.  
  2439. function createBoxes(obj, numberOfCols, numberOfRows, useToSlides) {
  2440. var slider = obj.slider;
  2441. var result = $();
  2442. var boxWidth, boxHeight;
  2443. var first = TRUE;
  2444. for (var rows = 0; rows < numberOfRows; rows++) {
  2445. for (var cols = 0; cols < numberOfCols; cols++) {
  2446. var innerBox = makeClone(obj, useToSlides);
  2447.  
  2448. if (first) {
  2449. first = FALSE;
  2450. boxWidth = Math.ceil(innerBox.width() / numberOfCols);
  2451. boxHeight = Math.ceil(innerBox.height() / numberOfRows);
  2452. }
  2453.  
  2454. var box = makeBox(
  2455. innerBox, // innerBox
  2456. boxHeight * rows, // top
  2457. boxWidth * cols, // left
  2458. boxHeight, // height
  2459. boxWidth, // width
  2460. obj // for options.
  2461. );
  2462. slider.append(box);
  2463. result = result.add(box);
  2464. }
  2465. }
  2466. return result;
  2467. }
  2468.  
  2469. function makeBox(innerBox, top, left, height, width, obj) {
  2470. innerBox.css({
  2471. width: innerBox.width(),
  2472. height: innerBox.height(),
  2473. display: "block",
  2474. top: -top,
  2475. left: -left
  2476. });
  2477. var box = $("<div>").css({
  2478. left: left,
  2479. top: top,
  2480. width: width,
  2481. height: height,
  2482. opacity: 0,
  2483. overflow: HIDDEN_STRING,
  2484. position: ABSOLUTE_STRING,
  2485. zIndex: findCloneZIndex(obj)
  2486. });
  2487. box.append(innerBox).addClass(ANIMATION_CLONE_MARKER_CLASS);
  2488. return box;
  2489. }
  2490.  
  2491. // Makes a single box that contains clones of the toSlides/fromSlides. Positioned correctly relative to each other. And the returned box has the correct height and width.
  2492. function makeClone(obj, useToSlides) {
  2493. var slides = useToSlides ? obj.toSlides : obj.fromSlides;
  2494. var firstSlidePosition = slides.eq(0).position();
  2495. var orgLeft = firstSlidePosition.left;
  2496. var orgTop = firstSlidePosition.top;
  2497. var height = 0;
  2498. var width = 0;
  2499. var result = $("<div>").css({zIndex: findCloneZIndex(obj), position: ABSOLUTE_STRING, top: 0, left: 0}).addClass(ANIMATION_CLONE_MARKER_CLASS);
  2500. slides.each(function (index, elem) {
  2501. var that = $(elem);
  2502. var cloneWidth = that.outerWidth(TRUE);
  2503. var cloneHeight = that.outerHeight(TRUE);
  2504. var clone = that.clone();
  2505. var position = that.position();
  2506. var left = position.left - orgLeft;
  2507. var top = position.top - orgTop;
  2508. clone.css({position: ABSOLUTE_STRING, left: left, top: top, opacity: 1});
  2509. height = mathMax(height, top + cloneHeight);
  2510. width = mathMax(width, left + cloneWidth);
  2511. result.append(clone);
  2512. });
  2513. result.width(width).height(height);
  2514. return result;
  2515. }
  2516.  
  2517. function findCloneZIndex(obj) {
  2518. return (parseInt10(obj.container.css("zIndex")) || 0) + 1;
  2519. }
  2520.  
  2521.  
  2522. /*
  2523. * Util scripts.
  2524. */
  2525.  
  2526. function makeCallback(func, args) {
  2527. return function () {
  2528. func.apply(undefined, args);
  2529. }
  2530. }
  2531.  
  2532. function runOnImagesLoaded(target, waitForAllImages, callback) {
  2533. if (!target) {
  2534. callback();
  2535. return;
  2536. }
  2537. var elems = target.add(target.find("img")).filter("img");
  2538. var numberOfRemainingImages = elems.length;
  2539. if (!numberOfRemainingImages) {
  2540. callback();
  2541. return;
  2542. }
  2543.  
  2544. elems.each(function () {
  2545. var that = this;
  2546. var jQueryThat = $(that);
  2547. var events = "load error";
  2548. var loadFunction = function () {
  2549. jQueryThat.off(events, loadFunction);
  2550. if (waitForAllImages) {
  2551. numberOfRemainingImages--;
  2552. if (numberOfRemainingImages == 0) {
  2553. callback();
  2554. }
  2555. } else {
  2556. callback();
  2557. }
  2558. };
  2559. jQueryThat.on(events, loadFunction);
  2560. /*
  2561. * Start ugly working IE fix.
  2562. */
  2563. if (that.readyState == "complete") {
  2564. jQueryThat.trigger("load");
  2565. } else if (that.readyState) {
  2566. // Sometimes IE doesn't fire the readystatechange, even though the readystate has been changed to complete. AARRGHH!! I HATE IE, I HATE IT, I HATE IE!
  2567. that.src = that.src; // Do not ask me why this works, ask the IE team!
  2568. }
  2569. /*
  2570. * End ugly working IE fix.
  2571. */
  2572. else if (that.complete) {
  2573. jQueryThat.trigger("load");
  2574. }
  2575. else if (that.complete === undefined) {
  2576. var src = that.src;
  2577. // webkit hack from http://groups.google.com/group/jquery-dev/browse_thread/thread/eee6ab7b2da50e1f
  2578. // data uri bypasses webkit log warning (thx doug jones)
  2579. that.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==";
  2580. that.src = src;
  2581. }
  2582. });
  2583. }
  2584.  
  2585. // The minVersion is specified in an array, like [1, 8, 0] for 1.8.0
  2586. // Partially copy-pasted from: https://gist.github.com/dshaw/652870
  2587. function minJQueryVersion(minVersion) {
  2588. var version = $.fn.jquery.split(".");
  2589. var length = version.length
  2590. for (var a = 0; a < length; a++) {
  2591. if (minVersion[a] && +version[a] < +minVersion[a]) {
  2592. return FALSE;
  2593. }
  2594. }
  2595. return TRUE;
  2596. }
  2597.  
  2598. function getVendorPrefixedProperty(property, searchElement) {
  2599. for (var name in searchElement) {
  2600. if (endsWith(name.toLowerCase(), property.toLowerCase())) {
  2601. return name;
  2602. }
  2603. }
  2604. return FALSE;
  2605. }
  2606.  
  2607. function getCSSVendorPrefix() {
  2608. var property = "transition";
  2609. var styleName = getVendorPrefixedProperty(property, $("<div>")[0].style);
  2610. if (styleName === FALSE) {
  2611. return FALSE;
  2612. }
  2613. var prefix = styleName.slice(0, styleName.length - property.length);
  2614. if (prefix.length != 0) {
  2615. return "-" + prefix + "-";
  2616. }
  2617. return "";
  2618. }
  2619.  
  2620. function stringTrim(str) {
  2621. return str.replace(/^\s+|\s+$/g, '');
  2622. }
  2623.  
  2624. function endsWith(string, suffix) {
  2625. return string.indexOf(suffix, string.length - suffix.length) !== -1;
  2626. }
  2627.  
  2628. function getKeys(obj) {
  2629. var keys = [];
  2630. for (var key in obj) {
  2631. keys.push(key);
  2632. }
  2633. return keys;
  2634. }
  2635.  
  2636. // Puts the specified function in a setTimeout([function], 0);
  2637. function callAsync(func) {
  2638. setTimeout(func, 0);
  2639. }
  2640.  
  2641. function startsWith(string, prefix) {
  2642. return string.indexOf(prefix) == 0;
  2643. }
  2644.  
  2645. function cloneArray(arrayToClone) {
  2646. return arrayToClone.slice();
  2647. }
  2648.  
  2649. // This mutates the given array, so that it is reversed.
  2650. // It also returns it.
  2651. function reverseArray(array) {
  2652. return [].reverse.call(array);
  2653. }
  2654.  
  2655. function childrenNotAnimationClones(obj) {
  2656. return obj.children().not("." + ANIMATION_CLONE_MARKER_CLASS);
  2657. }
  2658.  
  2659. function objectToLowercase(obj) {
  2660. var ret = {};
  2661. for (var key in obj)
  2662. ret[key.toLowerCase()] = obj[key];
  2663. return ret;
  2664. }
  2665.  
  2666. // Mutates and returns the array.
  2667. function shuffle(array) {
  2668. for (var j, x, i = array.length; i; j = parseInt(Math.random() * i), x = array[--i], array[i] = array[j], array[j] = x) {
  2669. }
  2670. return array;
  2671. }
  2672.  
  2673. function isFunction(func) {
  2674. return $.isFunction(func);
  2675. }
  2676.  
  2677. function isArray(object) {
  2678. return $.isArray(object);
  2679. }
  2680.  
  2681. function parseInt10(num) {
  2682. return parseInt(num, 10);
  2683. }
  2684.  
  2685. function parseNumber(num) {
  2686. return parseFloat(num);
  2687. }
  2688.  
  2689. function getTimeInMillis() {
  2690. return +new Date();
  2691. }
  2692.  
  2693. // Actual modulo, not remainder. From here: http://stackoverflow.com/questions/4467539/javascript-modulo-not-behaving
  2694. // Added a or zero, to ensure it returns a number.
  2695. function mod(a, n) {
  2696. return (((a % n) + n) % n) || 0;
  2697. }
  2698.  
  2699. function mathAbs(number) {
  2700. return number < 0 ? -number : number;
  2701. }
  2702.  
  2703. function mathMax(a, b) {
  2704. return a > b ? a : b;
  2705. }
  2706.  
  2707. function mathMin(a, b) {
  2708. return a < b ? a : b;
  2709. }
  2710.  
  2711. function getEffectMethod(inputEffect) {
  2712. if (isArray(inputEffect)) {
  2713. return makeRandomEffect(inputEffect);
  2714. } else if (isFunction(inputEffect)) {
  2715. return inputEffect
  2716. } else /* if (typeof inputEffect === "string") */{
  2717. inputEffect = stringTrim(inputEffect);
  2718. if (inputEffect.indexOf(",") != -1) {
  2719. var array = inputEffect.split(",");
  2720. return makeRandomEffect(array);
  2721. } else {
  2722. var effects = objectToLowercase($.fn.sudoSlider.effects);
  2723. var effectName = inputEffect.toLowerCase();
  2724. var result = effects[effectName];
  2725. if (result) {
  2726. return result;
  2727. } else {
  2728. var array = [];
  2729. for (var name in effects) {
  2730. if (startsWith(name, effectName)) {
  2731. array.push(effects[name]);
  2732. }
  2733. }
  2734. if (!array.length) {
  2735. return slide;
  2736. }
  2737. return makeRandomEffect(array);
  2738. }
  2739. }
  2740. }
  2741. }
  2742.  
  2743. function makeRandomEffect(array) {
  2744. return function (obj) {
  2745. var effect = pickRandomValue(array);
  2746. return getEffectMethod(effect)(obj);
  2747. }
  2748. }
  2749.  
  2750. function pickRandomValue(obj) {
  2751. return obj[shuffle(getKeys(obj))[0]];
  2752. }
  2753.  
  2754. // From this guy: https://github.com/rdallasgray/bez
  2755. // Inlined into my own script to make it shorter.
  2756. function makeBezier(coOrdArray) {
  2757. var encodedFuncName = "bez_" + coOrdArray.join("_").replace(/\./g, "p");
  2758. var jqueryEasing = $.easing;
  2759. if (!isFunction(jqueryEasing[encodedFuncName])) {
  2760. var polyBez = function(p1, p2) {
  2761. var A = [0, 0];
  2762. var B = [0, 0];
  2763. var C = [0, 0];
  2764. function bezCoOrd(t, ax) {
  2765. C[ax] = 3 * p1[ax], B[ax] = 3 * (p2[ax] - p1[ax]) - C[ax], A[ax] = 1 - C[ax] - B[ax];
  2766. return t * (C[ax] + t * (B[ax] + t * A[ax]));
  2767. }
  2768. function xDeriv(t) {
  2769. return C[0] + t * (2 * B[0] + 3 * A[0] * t);
  2770. }
  2771. function xForT(t) {
  2772. var x = t, i = 0, z;
  2773. while (++i < 14) {
  2774. z = bezCoOrd(x, 0) - t;
  2775. if (mathAbs(z) < 1e-3) break;
  2776. x -= z / xDeriv(x);
  2777. }
  2778. return x;
  2779. }
  2780.  
  2781. return function(t) {
  2782. return bezCoOrd(xForT(t), 1);
  2783. }
  2784. };
  2785. jqueryEasing[encodedFuncName] = function(x, t, b, c, d) {
  2786. return c * polyBez([coOrdArray[0], coOrdArray[1]], [coOrdArray[2], coOrdArray[3]])(t/d) + b;
  2787. }
  2788. }
  2789. return encodedFuncName;
  2790. }
  2791.  
  2792. })(jQuery, window);
  2793. // If you did just read the entire code, congrats.
  2794. // Did you find a bug? I didn't, so plz tell me if you did. (https://github.com/webbiesdk/SudoSlider/issues)
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!