API tools faq
paste
Hormold

VK Change (#1391454901)

Hormold
Feb 3rd, 2014
183
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 20.02 KB | None | 0 0
raw download clone embed print report
  1. Файл - qsorter.js (Старый размер - 16128 | Новый - 0):
  2. 0.  - var qsorter = {
  3. 1.  -   sqr: function(x) {
  4. 2.  -     return x * x;
  5. 3.  -   },
  6. 4.  -   evCoords: function(ev) {
  7. 5.  -     return browser.android ? [ev.touches[0].pageX + (ev.pageX || 0), ev.touches[0].pageY + (ev.pageY || 0)] : [ev.pageX, ev.pageY];
  8. 6.  -   },
  9. 7.  -
  10. 8.  -   animstop: function() {
  11. 9.  -     clearInterval(qsorter.animtimer);
  12. 10.  -     qsorter.animtimer = false;
  13. 11.  -   },
  14. 12.  -   animcache: {},
  15. 13.  -   animstep: function() {
  16. 14.  -     var finished = [], all = true, temp;
  17. 15.  -     for (var i in qsorter.animcache) {
  18. 16.  -       if (i == 0) {
  19. 17.  -         all = false;
  20. 18.  -         scrollNode.scrollTop += Math.ceil(qsorter.animcache[i] / 5);
  21. 19.  -         continue;
  22. 20.  -       }
  23. 21.  -       var a = qsorter.animcache[i], e = a.el, f = Fx.Transitions.easeOutQuint, dt = 200;
  24. 22.  -       var prev = vkNow();
  25. 23.  -       a.t += prev - a.prev;
  26. 24.  -       a.prev = prev;
  27. 25.  -       if (a.t < dt) {
  28. 26.  -         all = false;
  29. 27.  -         e.style.left = f(a.t, a.sx, a.dx, dt) + 'px';
  30. 28.  -         e.style.top = f(a.t, a.sy, a.dy, dt) + 'px';
  31. 29.  -         if (browser.msie8) { // force redraw
  32. 30.  -           temp = e.offsetLeft;
  33. 31.  -         }
  34. 32.  -         continue;
  35. 33.  -       }
  36. 34.  -       e.style.left = (a.sx + a.dx) + 'px';
  37. 35.  -       e.style.top = (a.sy + a.dy) + 'px';
  38. 36.  -       if (browser.msie8) { // force redraw
  39. 37.  -         temp = e.offsetLeft;
  40. 38.  -       }
  41. 39.  -       clearInterval(a.timer);
  42. 40.  -       finished.push(e.parentNode.id);
  43. 41.  -       if (a.h) a.h.apply(e);
  44. 42.  -     }
  45. 43.  -     for (var i in finished) {
  46. 44.  -       delete(qsorter.animcache[finished[i]]);
  47. 45.  -     }
  48. 46.  -     if (all) {
  49. 47.  -       qsorter.animstop();
  50. 48.  -     }
  51. 49.  -   },
  52. 50.  -   animdone: function(s) {
  53. 51.  -     if (s.cls) {
  54. 52.  -       domPN(this).className = s.cls;
  55. 53.  -     } else {
  56. 54.  -       removeClass(domPN(this), s.clsUp);
  57. 55.  -     }
  58. 56.  -     this.style.left = this.style.top = '';
  59. 57.  -     if (cur.qsorterSetSize) {
  60. 58.  -       setStyle(this.parentNode, {width: '', height: ''});
  61. 59.  -     }
  62. 60.  -   },
  63. 61.  -   animate: function(e, sx, sy, x, y, handler, s) {
  64. 62.  -     if (browser.msie8) {
  65. 63.  -       if (s.cls) {
  66. 64.  -         domPN(e).className = s.cls;
  67. 65.  -       } else {
  68. 66.  -         removeClass(domPN(e), s.clsUp);
  69. 67.  -       }
  70. 68.  -       e.style.left = e.style.top = '';
  71. 69.  -       if (cur.qsorterSetSize) {
  72. 70.  -         setStyle(e.parentNode, {width: '', height: ''});
  73. 71.  -       }
  74. 72.  -       return;
  75. 73.  -     }
  76. 74.  -     var anim = {t: 0, sx: sx, sy: sy, dx: x - sx, dy: y - sy, h: handler, prev: vkNow()};
  77. 75.  -     if (qsorter.animcache[e.parentNode.id]) {
  78. 76.  -       extend(qsorter.animcache[e.parentNode.id], anim);
  79. 77.  -       return;
  80. 78.  -     }
  81. 79.  -     qsorter.animcache[e.parentNode.id] = extend(anim, {el: e});
  82. 80.  -     if (!qsorter.animtimer) {
  83. 81.  -       qsorter.animtimer = setInterval(qsorter.animstep, 13);
  84. 82.  -     }
  85. 83.  -   },
  86. 84.  -
  87. 85.  -   first: function(obj) {
  88. 86.  -     el = obj.firstChild;
  89. 87.  -     while(el && el.nodeType == 3) {
  90. 88.  -       el = el.nextSibling;
  91. 89.  -     }
  92. 90.  -     return el;
  93. 91.  -   },
  94. 92.  -
  95. 93.  -   mousedown: function(ev) {
  96. 94.  -     var touch = ev && ev.touches && ev.touches.length == 1;
  97. 95.  -     if (ev && (ev.button == 2 || ev.which == 3 || ev.ctrlKey || ev.metaKey) && !touch) {
  98. 96.  -       return true;
  99. 97.  -     }
  100. 98.  -     if (qsorter.current) return;
  101. 99.  -     cur.qsorterOver = false;
  102. 100.  -
  103. 101.  -     var el = this, inner = qsorter.first(el), s = el.parentNode.qsorter, evc = qsorter.evCoords(ev), size;
  104. 102.  -     if (s.canDrag) {
  105. 103.  -       if (!s.canDrag(el)) return;
  106. 104.  -     } else if (ev.target.getAttribute('nosorthandle') || el.getAttribute('nodrag')) return;
  107. 105.  -
  108. 106.  -     qsorter.current = s;
  109. 107.  -     qsorter.nextEl = el.nextSibling;
  110. 108.  -     extend(s, {drag: el});
  111. 109.  -     setStyle(inner, {left: el.x + 'px', top: el.y + s.offset + 'px', zIndex: 150});
  112. 110.  -     if (cur.qsorterSetSize) {
  113. 111.  -       size = getSize(inner);
  114. 112.  -     }
  115. 113.  -     if (s.cls) {
  116. 114.  -       el.className = s.clsUp;
  117. 115.  -     } else {
  118. 116.  -       addClass(el, s.clsUp);
  119. 117.  -     }
  120. 118.  -     if (cur.qsorterSetSize) {
  121. 119.  -       setStyle(el, {width: size[0], height: size[1]});
  122. 120.  -     }
  123. 121.  -
  124. 122.  -     addEvent(document, 'mousemove drag touchmove', qsorter.mousemove);
  125. 123.  -     addEvent(document, 'mouseup touchend touchcancel', qsorter.mouseup);
  126. 124.  -     if (!browser.opera && !browser.msie && !browser.mozilla && !browser.safari_mobile && !browser.android && !s.noscroll) {
  127. 125.  -       addEvent(qsorter.scrollNode, 'scroll', qsorter.mousemove);
  128. 126.  -     }
  129. 127.  -     extend(s, {
  130. 128.  -       startX: evc[0],
  131. 129.  -       startY: evc[1] + (browser.msie6 ? pageNode.scrollTop : 0),
  132. 130.  -       before: el.nextSibling,
  133. 131.  -       after: el.previousSibling
  134. 132.  -     });
  135. 133.  -     extend(qsorter, {lastX: evc[0], lastY: evc[1], lastS: scrollNode.scrollTop});
  136. 134.  -
  137. 135.  -     if (window.Privacy) Privacy.hide(-1);
  138. 136.  -
  139. 137.  -     cur.cancelClick = false;
  140. 138.  -
  141. 139.  -     return touch || cancelEvent(ev);
  142. 140.  -   },
  143. 141.  -
  144. 142.  -   checkOver: function(s, evc) {
  145. 143.  -     for (var i in s.dragEls) {
  146. 144.  -       var d = s.dragEls[i];
  147. 145.  -       if (!d.xy || d.xy[0] == 0) {
  148. 146.  -         d.xy = getXY(d);
  149. 147.  -         d.sz = getSize(d);
  150. 148.  -       }
  151. 149.  -       if (evc[0] > d.xy[0] && evc[1] > d.xy[1] && evc[0] < d.xy[0]+d.sz[0] && evc[1] < d.xy[1]+d.sz[1]) {
  152. 150.  -         if (cur.qsorterOver != d) {
  153. 151.  -           if (cur.qsorterOver) {
  154. 152.  -             s.onDragOut(cur.qsorterOver);
  155. 153.  -           }
  156. 154.  -           cur.qsorterOver = d;
  157. 155.  -           s.onDragOver(d);
  158. 156.  -         }
  159. 157.  -       } else if (cur.qsorterOver && cur.qsorterOver == d) {
  160. 158.  -         cur.qsorterOver = false;
  161. 159.  -         s.onDragOut(d);
  162. 160.  -       }
  163. 161.  -     }
  164. 162.  -   },
  165. 163.  -
  166. 164.  -   mousemove: function(ev) {
  167. 165.  -     if (!qsorter.current) return;
  168. 166.  -
  169. 167.  -     var cancel = true, evc = (ev.type == 'scroll') ? [qsorter.lastX, qsorter.lastY + scrollNode.scrollTop - qsorter.lastS] : qsorter.evCoords(ev);
  170. 168.  -     var s = qsorter.current;
  171. 169.  -     if (ev.type == 'scroll') {
  172. 170.  -       cancel = false;
  173. 171.  -     } else {
  174. 172.  -       qsorter.lastX = evc[0];
  175. 173.  -       qsorter.lastY = evc[1];
  176. 174.  -       qsorter.lastS = scrollNode.scrollTop;
  177. 175.  -       if (!browser.safari_mobile && !browser.android && !s.noscroll) {
  178. 176.  -         var my = evc[1] - (browser.msie6 ? 0 : scrollNode.scrollTop);
  179. 177.  -         if (my < 100) {
  180. 178.  -           qsorter.animcache[0] = my - 100;
  181. 179.  -         } else if (my > lastWindowHeight - 100) {
  182. 180.  -           qsorter.animcache[0] = my + 100 - lastWindowHeight;
  183. 181.  -         } else if (qsorter.animcache[0]) {
  184. 182.  -           delete(qsorter.animcache[0]);
  185. 183.  -         }
  186. 184.  -         if (qsorter.animcache[0] && !qsorter.animtimer) {
  187. 185.  -           qsorter.animtimer = setInterval(qsorter.animstep, 13);
  188. 186.  -         }
  189. 187.  -       }
  190. 188.  -     }
  191. 189.  -
  192. 190.  -     var el = s.drag;
  193. 191.  -     var dx = evc[0] - s.startX;
  194. 192.  -     var dy = evc[1] + (browser.msie6 ? pageNode.scrollTop : 0) - s.startY;
  195. 193.  -     var pageSize = getSize(scrollNode), elPos = getXY(el),
  196. 194.  -         pageW = pageSize[0], pageH = Math.max(window.lastWindowHeight || 0, pageSize[1]);
  197. 195.  -     if (elPos[0] < pageW - s.width && elPos[0] + dx > pageW - s.width) {
  198. 196.  -       dx = pageW - elPos[0] - s.width;
  199. 197.  -     }
  200. 198.  -     if (elPos[1] < pageH - s.height && elPos[1] + dy > pageH - s.height) {
  201. 199.  -       dy = pageH - elPos[1] - s.height;
  202. 200.  -     }
  203. 201.  -     var x = el.x, nx = x + dx, y = el.y, ny = y + dy, w = s.width, h = s.height, temp;
  204. 202.  -     var i = el.i, xsize = s.xsize, p = i % xsize, q = Math.floor((i + 0.1) / xsize);
  205. 203.  -
  206. 204.  -     if (dx > 10 || dx < -10 || dy > 10 || dy < -10) {
  207. 205.  -       cur.cancelClick = true;
  208. 206.  -     }
  209. 207.  -
  210. 208.  -     setStyle(qsorter.first(el), {left: nx, top: ny + s.offset});
  211. 209.  -     if (browser.msie8) { // force redraw
  212. 210.  -       temp = el.offsetLeft;
  213. 211.  -     }
  214. 212.  -
  215. 213.  -     if (s.dragCont && s.dragCont.visible) {
  216. 214.  -       if (evc[0] > s.dragCont.x1 && evc[1] > s.dragCont.y1 && evc[0] < s.dragCont.x2 && evc[1] < s.dragCont.y2) {
  217. 215.  -         if (!cur.sorterDragIn) {
  218. 216.  -           cur.sorterDragIn = 1;
  219. 217.  -           animate(el, {opacity: 0.2}, 400);
  220. 218.  -         }
  221. 219.  -         qsorter.checkOver(s, evc);
  222. 220.  -         return;
  223. 221.  -       } else if (cur.sorterDragIn) {
  224. 222.  -         cur.sorterDragIn = 0;
  225. 223.  -         animate(el, {opacity: 1}, 400);
  226. 224.  -       }
  227. 225.  -       if (cur.qsorterOver) {
  228. 226.  -         qsorter.checkOver(s, evc);
  229. 227.  -       }
  230. 228.  -     }
  231. 229.  -
  232. 230.  -     var newp = Math.floor(p + 0.5 + (dx / w)),
  233. 231.  -         newq = Math.floor(q + 0.5 + (dy / h)),
  234. 232.  -         nodragq = Math.floor(s.noDragCount / xsize),
  235. 233.  -         nodragp = s.noDragCount - nodragq * xsize;
  236. 234.  -     newp = Math.min(Math.max(newp, 0), xsize - 1); newq = Math.max(newq, 0);
  237. 235.  -     if (newq < nodragq) newq = nodragq;
  238. 236.  -     if (newq == Math.ceil(s.noDragCount / xsize) - 1 && newp < nodragp) newp = nodragp;
  239. 237.  -     var newi = newq * xsize + newp;
  240. 238.  -     if (newi > s.count - 1) {
  241. 239.  -       var newd = newi - (s.count - 1);
  242. 240.  -       newq -= Math.floor((newd + 0.1) / xsize);
  243. 241.  -       newp -= newd % xsize;
  244. 242.  -       if (newp < 0) {
  245. 243.  -         newp += xsize;
  246. 244.  -         --newq;
  247. 245.  -       }
  248. 246.  -       newi = s.count - 1;
  249. 247.  -     }
  250. 248.  -     if (newi == i) return cancel ? cancelEvent(ev) : true;
  251. 249.  -
  252. 250.  -     var op = p, oq = q, e = false, d = (newi < i) ? -1 : 1;
  253. 251.  -
  254. 252.  -     for (var j = i; j != newi; j += d) {
  255. 253.  -       var np = p + d, nq = q;
  256. 254.  -       if (np == xsize) {
  257. 255.  -         np = 0;
  258. 256.  -         ++nq;
  259. 257.  -       } else if (np < 0) {
  260. 258.  -         np = xsize - 1;
  261. 259.  -         --nq;
  262. 260.  -       }
  263. 261.  -
  264. 262.  -       e = s.elems[np][nq];
  265. 263.  -
  266. 264.  -       var sx = e.x;
  267. 265.  -       var sy = e.y;
  268. 266.  -       var x = sx + (p - np) * w;
  269. 267.  -       var y = sy + (q - nq) * h;
  270. 268.  -       setStyle(qsorter.first(e), {left: sx, top: sy + s.offset});
  271. 269.  -       if (s.cls) {
  272. 270.  -         e.className = s.clsUp;
  273. 271.  -       } else {
  274. 272.  -         addClass(e, s.clsUp);
  275. 273.  -       }
  276. 274.  -       if (cur.qsorterSetSize) {
  277. 275.  -         var size = getSize(qsorter.first(e));
  278. 276.  -         setStyle(e, {width: size[0], height: size[1]});
  279. 277.  -       }
  280. 278.  -
  281. 279.  -       extend(e, {
  282. 280.  -         i: j,
  283. 281.  -         x: x,
  284. 282.  -         y: y
  285. 283.  -       });
  286. 284.  -       s.elems[p][q] = e;
  287. 285.  -       qsorter.animate(qsorter.first(e), sx, sy+s.offset, x, y+s.offset, qsorter.animdone.bind(qsorter.first(e), s), s);
  288. 286.  -
  289. 287.  -       p = np; q = nq;
  290. 288.  -     }
  291. 289.  -
  292. 290.  -     if (d < 0) {
  293. 291.  -       s.parent.insertBefore(el, e);
  294. 292.  -     } else {
  295. 293.  -       if (e.nextSibling) {
  296. 294.  -         s.parent.insertBefore(el, e.nextSibling);
  297. 295.  -       } else {
  298. 296.  -         s.parent.appendChild(el);
  299. 297.  -       }
  300. 298.  -     }
  301. 299.  -
  302. 300.  -     dx = (p - op) * w;
  303. 301.  -     dy = (q - oq) * h;
  304. 302.  -     s.elems[newp][newq] = el;
  305. 303.  -     extend(el, {
  306. 304.  -       i: newi,
  307. 305.  -       x: el.x + dx,
  308. 306.  -       y: el.y + dy
  309. 307.  -     });
  310. 308.  -
  311. 309.  -     s.startX += dx; s.startY += dy;
  312. 310.  -
  313. 311.  -     if (browser.msie8) { // force redraw
  314. 312.  -       temp = el.offsetLeft;
  315. 313.  -     }
  316. 314.  -
  317. 315.  -     return cancel ? cancelEvent(ev) : true;
  318. 316.  -   },
  319. 317.  -   mouseup: function(ev) {
  320. 318.  -     if (!qsorter.current) return;
  321. 319.  -
  322. 320.  -     var s = qsorter.current;
  323. 321.  -     var el = s.drag, evc = qsorter.evCoords(ev);
  324. 322.  -     var dx = (evc[0] || qsorter.lastX) - s.startX;
  325. 323.  -     var dy = (evc[1] || qsorter.lastY) + (browser.msie6 ? pageNode.scrollTop : 0) - s.startY + s.offset;
  326. 324.  -     setStyle(qsorter.first(el), {zIndex: 125});
  327. 325.  -     qsorter.current = s.drag = false;
  328. 326.  -     if (cur.qsorterOver) {
  329. 327.  -       if (s.onDrop(cur.qsorterOver, el)) {
  330. 328.  -         var f = qsorter.first(el);
  331. 329.  -         setStyle(f, {top: 0, left: 0})
  332. 330.  -         if (qsorter.nextEl) {
  333. 331.  -           el.parentNode.insertBefore(el, qsorter.nextEl);
  334. 332.  -         } else {
  335. 333.  -           el.parentNode.appendChild(el);
  336. 334.  -         }
  337. 335.  -         qsorter.animdone.bind(f)(s);
  338. 336.  -         qsorter.stop();
  339. 337.  -         if (qsorter.animcache[0]) {
  340. 338.  -           delete(qsorter.animcache[0]);
  341. 339.  -           if (isEmpty(qsorter.animcache)) {
  342. 340.  -             qsorter.animstop();
  343. 341.  -           }
  344. 342.  -         }
  345. 343.  -         if (cur.sorterDragIn) {
  346. 344.  -           cur.sorterDragIn = 0;
  347. 345.  -           setStyle(el, {opacity: 1});
  348. 346.  -         }
  349. 347.  -         return cancelEvent(ev);
  350. 348.  -       }
  351. 349.  -     }
  352. 350.  -
  353. 351.  -     qsorter.animate(qsorter.first(el), el.x + dx, el.y + dy, el.x, el.y + s.offset, qsorter.animdone.bind(qsorter.first(el), s), s);
  354. 352.  -
  355. 353.  -     qsorter.stop();
  356. 354.  -
  357. 355.  -     if (qsorter.animcache[0]) {
  358. 356.  -       delete(qsorter.animcache[0]);
  359. 357.  -       if (isEmpty(qsorter.animcache)) {
  360. 358.  -         qsorter.animstop();
  361. 359.  -       }
  362. 360.  -     }
  363. 361.  -
  364. 362.  -     if (cur.sorterDragIn) {
  365. 363.  -       cur.sorterDragIn = 0;
  366. 364.  -       animate(el, {opacity: 1}, 100);
  367. 365.  -     }
  368. 366.  -
  369. 367.  -     var before = el.nextSibling, after = el.previousSibling;
  370. 368.  -     if ((before != s.before || after != s.after) && s.onReorder) {
  371. 369.  -       s.onReorder(el, before, after);
  372. 370.  -     }
  373. 371.  -     delete(s.before);
  374. 372.  -     delete(s.after);
  375. 373.  -
  376. 374.  -     return cancelEvent(ev);
  377. 375.  -   },
  378. 376.  -   stop: function() {
  379. 377.  -     var s = qsorter.current;
  380. 378.  -     removeEvent(document, 'mousemove drag touchmove', qsorter.mousemove);
  381. 379.  -     removeEvent(document, 'mouseup touchend touchcancel', qsorter.mouseup);
  382. 380.  -     s.drag = qsorter.current = false;
  383. 381.  -   },
  384. 382.  -   update: function(parent, opts) {
  385. 383.  -     if (browser.mobile && !browser.safari_mobile && !browser.android) return;
  386. 384.  -     var s = parent.qsorter;
  387. 385.  -     extend(s, opts);
  388. 386.  -     s.count = 0;
  389. 387.  -     s.elems = [];
  390. 388.  -     s.noDragCount = 0;
  391. 389.  -     if (s.dragCont) {
  392. 390.  -       s.updateDragCont();
  393. 391.  -     }
  394. 392.  -     this.added(parent);
  395. 393.  -   },
  396. 394.  -   added: function(parent) {
  397. 395.  -     if (browser.mobile && !browser.safari_mobile && !browser.android) return;
  398. 396.  -     var s = parent.qsorter, l = s.count, xsize = s.xsize, to = l % xsize;
  399. 397.  -     var el = l ? s.elems[(l - 1) % xsize][Math.floor((l - 0.9) / xsize)].nextSibling : qsorter.first(parent);
  400. 398.  -     s.noDragCount = s.noDragCount || 0;
  401. 399.  -     for (var i = l; el; el = el.nextSibling, ++i) {
  402. 400.  -       if (el.nodeType == 3) continue;
  403. 401.  -       var noDrag = el.getAttribute('nodrag');
  404. 402.  -       if (noDrag) s.noDragCount++;
  405. 403.  -       if (!s.elems[to]) {
  406. 404.  -         s.elems[to] = [];
  407. 405.  -       }
  408. 406.  -       s.elems[to].push(el);
  409. 407.  -
  410. 408.  -       var first = qsorter.first(el);
  411. 409.  -       var x = first.offsetLeft, y = first.offsetTop;
  412. 410.  -       if (browser.msie7 || browser.msie6) {
  413. 411.  -         x += el.offsetLeft;
  414. 412.  -         y += el.offsetTop;
  415. 413.  -       }
  416. 414.  -       extend(el, {x: x, y: y, i: i});
  417. 415.  -       addEvent(el, 'mousedown touchstart', qsorter.mousedown);
  418. 416.  -       if (browser.opera && !cur.qsorterNoOperaStyle) {
  419. 417.  -         el.style.display = 'block';
  420. 418.  -         el.style.cssFloat = 'left';
  421. 419.  -       }
  422. 420.  -       if (!noDrag && !s.noMoveCursor) el.style.cursor = 'move';
  423. 421.  -
  424. 422.  -       ++to;
  425. 423.  -       if (to >= xsize) to -= xsize;
  426. 424.  -     }
  427. 425.  -     s.count += (i - l);
  428. 426.  -   },
  429. 427.  -   remove: function(parent, obj) {
  430. 428.  -     var s = parent.qsorter, l = s.count, xsize = s.xsize, to = l % xsize;
  431. 429.  -     debugLog('x', obj.x, obj.y);
  432. 430.  -
  433. 431.  -     if (!s.elems.length) return;
  434. 432.  -     var row = s.elems[0].length;
  435. 433.  -
  436. 434.  -     var lastEl = false;
  437. 435.  -     debugLog('startRow', row);
  438. 436.  -     while(row) {
  439. 437.  -       row -= 1;
  440. 438.  -       var col = s.xsize;
  441. 439.  -       while(col) {
  442. 440.  -         col -= 1;
  443. 441.  -         var tEl = (s.elems[col] || [])[row];
  444. 442.  -
  445. 443.  -         debugLog('col: ', col, ' row: ', row, ' el: ', tEl);
  446. 444.  -         if (!tEl) {
  447. 445.  -           continue;
  448. 446.  -         }
  449. 447.  -
  450. 448.  -         if (lastEl) {
  451. 449.  -           s.elems[col][row] = extend(lastEl, {
  452. 450.  -             x: tEl.x,
  453. 451.  -             y: tEl.y,
  454. 452.  -             i: tEl.i
  455. 453.  -           });
  456. 454.  -           debugLog('G', col, row, tEl.i);
  457. 455.  -         } else {
  458. 456.  -           s.elems[col].pop();
  459. 457.  -         }
  460. 458.  -
  461. 459.  -         if (tEl == obj) {
  462. 460.  -           row = 0;
  463. 461.  -           break;
  464. 462.  -         }
  465. 463.  -
  466. 464.  -         lastEl = tEl;
  467. 465.  -       }
  468. 466.  -     }
  469. 467.  -
  470. 468.  -     re(obj);
  471. 469.  -     s.count -= 1;
  472. 470.  -     return lastEl;
  473. 471.  -   },
  474. 472.  -
  475. 473.  - // needs width,height,xsize
  476. 474.  -   init: function(parent, opts) {
  477. 475.  -     if (browser.mobile && !browser.safari_mobile && !browser.android) return;
  478. 476.  -
  479. 477.  -     qsorter.scrollNode = browser.msie6 ? pageNode : window;
  480. 478.  -     parent = ge(parent);
  481. 479.  -
  482. 480.  -     if (browser.msie7 || browser.msie6) parent.style.position = 'relative';
  483. 481.  -
  484. 482.  -     var result = {
  485. 483.  -       parent: parent,
  486. 484.  -       xsize: opts.xsize,
  487. 485.  -       width: opts.width,
  488. 486.  -       height: opts.height,
  489. 487.  -       canDrag: opts.canDrag,
  490. 488.  -       cls: opts.clsUp ? false : (cur.qsorterRowClass || 'photo_row'),
  491. 489.  -       clsUp: opts.clsUp ? opts.clsUp : (cur.qsorterRowUpClass || 'photo_row photo_row_up'),
  492. 490.  -       count: 0,
  493. 491.  -       offset: 0,
  494. 492.  -       elems: new Array(opts.xsize),
  495. 493.  -       stop: function() {
  496. 494.  -         if (qsorter.current == result) {
  497. 495.  -           qsorter.stop();
  498. 496.  -         }
  499. 497.  -         for (var i in result.elems) {
  500. 498.  -           var els = result.elems[i];
  501. 499.  -           for (var j = 0, n = ((els || {}).length || 0); j < n; ++j) {
  502. 500.  -             var ch = els[j];
  503. 501.  -             if (qsorter.animcache[ch.id]) {
  504. 502.  -               delete(qsorter.animcache[ch.id]);
  505. 503.  -             }
  506. 504.  -           }
  507. 505.  -         }
  508. 506.  -       },
  509. 507.  -       destroy: function() {
  510. 508.  -         result.stop();
  511. 509.  -         var el = result.parent;
  512. 510.  -         removeAttr(el, 'qsorter');
  513. 511.  -         for (var i = 0, l = result.elems.length; i < l; ++i) {
  514. 512.  -           var els = result.elems[i];
  515. 513.  -           for (var j = 0, n = ((els || {}).length || 0); j < n; ++j) {
  516. 514.  -             var ch = els[j];
  517. 515.  -             removeEvent(ch, 'mousedown touchstart', qsorter.mousedown);
  518. 516.  -           }
  519. 517.  -         }
  520. 518.  -       },
  521. 519.  -       updateDragCont: function() {
  522. 520.  -         var xy = getXY(opts.dragCont);
  523. 521.  -         var size= getSize(opts.dragCont);
  524. 522.  -         this.dragCont = {
  525. 523.  -           visible: isVisible(opts.dragCont),
  526. 524.  -           el: opts.dragCont,
  527. 525.  -           x1: xy[0],
  528. 526.  -           y1: xy[1],
  529. 527.  -           x2: xy[0] + size[0],
  530. 528.  -           y2: xy[1] + size[1],
  531. 529.  -         };
  532. 530.  -       },
  533. 531.  -       onReorder: opts.onReorder,
  534. 532.  -       noscroll: opts.noscroll,
  535. 533.  -       dragEls: opts.dragEls,
  536. 534.  -       onDragOver: opts.onDragOver,
  537. 535.  -       onDragOut: opts.onDragOut,
  538. 536.  -       onDrop: opts.onDrop,
  539. 537.  -       noMoveCursor: opts.noMoveCursor
  540. 538.  -     }
  541. 539.  -
  542. 540.  -     if (opts.dragCont) {
  543. 541.  -       result.updateDragCont();
  544. 542.  -     }
  545. 543.  -     parent.qsorter = result;
  546. 544.  -     qsorter.added(parent);
  547. 545.  -     return result;
  548. 546.  -   }
  549. 547.  - }
  550. 548.  -
  551. 549.  - try{stManager.done('qsorter.js');}catch(e){}
  552. ------
Advertisement
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!