tether.js
1444 lines
| 1 | /*! tether 0.6.5 */ |
| 2 | |
| 3 | |
| 4 | (function(root, factory) { |
| 5 | if (typeof define === 'function' && define.amd) { |
| 6 | define(factory); |
| 7 | } else if (typeof exports === 'object') { |
| 8 | module.exports = factory(require,exports,module); |
| 9 | } else { |
| 10 | root.Tether = factory(); |
| 11 | } |
| 12 | }(this, function(require,exports,module) { |
| 13 | |
| 14 | (function() { |
| 15 | var Evented, addClass, defer, deferred, extend, flush, getBounds, getOffsetParent, getOrigin, getScrollBarSize, getScrollParent, hasClass, node, removeClass, uniqueId, updateClasses, zeroPosCache, |
| 16 | __hasProp = {}.hasOwnProperty, |
| 17 | __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }, |
| 18 | __slice = [].slice; |
| 19 | |
| 20 | if (this.Tether == null) { |
| 21 | this.Tether = { |
| 22 | modules: [] |
| 23 | }; |
| 24 | } |
| 25 | |
| 26 | getScrollParent = function(el) { |
| 27 | var parent, position, scrollParent, style, _ref; |
| 28 | position = getComputedStyle(el).position; |
| 29 | if (position === 'fixed') { |
| 30 | return el; |
| 31 | } |
| 32 | scrollParent = void 0; |
| 33 | parent = el; |
| 34 | while (parent = parent.parentNode) { |
| 35 | try { |
| 36 | style = getComputedStyle(parent); |
| 37 | } catch (_error) {} |
| 38 | if (style == null) { |
| 39 | return parent; |
| 40 | } |
| 41 | if (/(auto|scroll)/.test(style['overflow'] + style['overflow-y'] + style['overflow-x'])) { |
| 42 | if (position !== 'absolute' || ((_ref = style['position']) === 'relative' || _ref === 'absolute' || _ref === 'fixed')) { |
| 43 | return parent; |
| 44 | } |
| 45 | } |
| 46 | } |
| 47 | return document.body; |
| 48 | }; |
| 49 | |
| 50 | uniqueId = (function() { |
| 51 | var id; |
| 52 | id = 0; |
| 53 | return function() { |
| 54 | return id++; |
| 55 | }; |
| 56 | })(); |
| 57 | |
| 58 | zeroPosCache = {}; |
| 59 | |
| 60 | getOrigin = function(doc) { |
| 61 | var id, k, node, v, _ref; |
| 62 | node = doc._tetherZeroElement; |
| 63 | if (node == null) { |
| 64 | node = doc.createElement('div'); |
| 65 | node.setAttribute('data-tether-id', uniqueId()); |
| 66 | extend(node.style, { |
| 67 | top: 0, |
| 68 | left: 0, |
| 69 | position: 'absolute' |
| 70 | }); |
| 71 | doc.body.appendChild(node); |
| 72 | doc._tetherZeroElement = node; |
| 73 | } |
| 74 | id = node.getAttribute('data-tether-id'); |
| 75 | if (zeroPosCache[id] == null) { |
| 76 | zeroPosCache[id] = {}; |
| 77 | _ref = node.getBoundingClientRect(); |
| 78 | for (k in _ref) { |
| 79 | v = _ref[k]; |
| 80 | zeroPosCache[id][k] = v; |
| 81 | } |
| 82 | defer(function() { |
| 83 | return zeroPosCache[id] = void 0; |
| 84 | }); |
| 85 | } |
| 86 | return zeroPosCache[id]; |
| 87 | }; |
| 88 | |
| 89 | node = null; |
| 90 | |
| 91 | getBounds = function(el) { |
| 92 | var box, doc, docEl, k, origin, v, _ref; |
| 93 | if (el === document) { |
| 94 | doc = document; |
| 95 | el = document.documentElement; |
| 96 | } else { |
| 97 | doc = el.ownerDocument; |
| 98 | } |
| 99 | docEl = doc.documentElement; |
| 100 | box = {}; |
| 101 | _ref = el.getBoundingClientRect(); |
| 102 | for (k in _ref) { |
| 103 | v = _ref[k]; |
| 104 | box[k] = v; |
| 105 | } |
| 106 | origin = getOrigin(doc); |
| 107 | box.top -= origin.top; |
| 108 | box.left -= origin.left; |
| 109 | if (box.width == null) { |
| 110 | box.width = document.body.scrollWidth - box.left - box.right; |
| 111 | } |
| 112 | if (box.height == null) { |
| 113 | box.height = document.body.scrollHeight - box.top - box.bottom; |
| 114 | } |
| 115 | box.top = box.top - docEl.clientTop; |
| 116 | box.left = box.left - docEl.clientLeft; |
| 117 | box.right = doc.body.clientWidth - box.width - box.left; |
| 118 | box.bottom = doc.body.clientHeight - box.height - box.top; |
| 119 | return box; |
| 120 | }; |
| 121 | |
| 122 | getOffsetParent = function(el) { |
| 123 | return el.offsetParent || document.documentElement; |
| 124 | }; |
| 125 | |
| 126 | getScrollBarSize = function() { |
| 127 | var inner, outer, width, widthContained, widthScroll; |
| 128 | inner = document.createElement('div'); |
| 129 | inner.style.width = '100%'; |
| 130 | inner.style.height = '200px'; |
| 131 | outer = document.createElement('div'); |
| 132 | extend(outer.style, { |
| 133 | position: 'absolute', |
| 134 | top: 0, |
| 135 | left: 0, |
| 136 | pointerEvents: 'none', |
| 137 | visibility: 'hidden', |
| 138 | width: '200px', |
| 139 | height: '150px', |
| 140 | overflow: 'hidden' |
| 141 | }); |
| 142 | outer.appendChild(inner); |
| 143 | document.body.appendChild(outer); |
| 144 | widthContained = inner.offsetWidth; |
| 145 | outer.style.overflow = 'scroll'; |
| 146 | widthScroll = inner.offsetWidth; |
| 147 | if (widthContained === widthScroll) { |
| 148 | widthScroll = outer.clientWidth; |
| 149 | } |
| 150 | document.body.removeChild(outer); |
| 151 | width = widthContained - widthScroll; |
| 152 | return { |
| 153 | width: width, |
| 154 | height: width |
| 155 | }; |
| 156 | }; |
| 157 | |
| 158 | extend = function(out) { |
| 159 | var args, key, obj, val, _i, _len, _ref; |
| 160 | if (out == null) { |
| 161 | out = {}; |
| 162 | } |
| 163 | args = []; |
| 164 | Array.prototype.push.apply(args, arguments); |
| 165 | _ref = args.slice(1); |
| 166 | for (_i = 0, _len = _ref.length; _i < _len; _i++) { |
| 167 | obj = _ref[_i]; |
| 168 | if (obj) { |
| 169 | for (key in obj) { |
| 170 | if (!__hasProp.call(obj, key)) continue; |
| 171 | val = obj[key]; |
| 172 | out[key] = val; |
| 173 | } |
| 174 | } |
| 175 | } |
| 176 | return out; |
| 177 | }; |
| 178 | |
| 179 | removeClass = function(el, name) { |
| 180 | var cls, _i, _len, _ref, _results; |
| 181 | if (el.classList != null) { |
| 182 | _ref = name.split(' '); |
| 183 | _results = []; |
| 184 | for (_i = 0, _len = _ref.length; _i < _len; _i++) { |
| 185 | cls = _ref[_i]; |
| 186 | if (cls.trim()) { |
| 187 | _results.push(el.classList.remove(cls)); |
| 188 | } |
| 189 | } |
| 190 | return _results; |
| 191 | } else { |
| 192 | return el.className = el.className.replace(new RegExp("(^| )" + (name.split(' ').join('|')) + "( |$)", 'gi'), ' '); |
| 193 | } |
| 194 | }; |
| 195 | |
| 196 | addClass = function(el, name) { |
| 197 | var cls, _i, _len, _ref, _results; |
| 198 | if (el.classList != null) { |
| 199 | _ref = name.split(' '); |
| 200 | _results = []; |
| 201 | for (_i = 0, _len = _ref.length; _i < _len; _i++) { |
| 202 | cls = _ref[_i]; |
| 203 | if (cls.trim()) { |
| 204 | _results.push(el.classList.add(cls)); |
| 205 | } |
| 206 | } |
| 207 | return _results; |
| 208 | } else { |
| 209 | removeClass(el, name); |
| 210 | return el.className += " " + name; |
| 211 | } |
| 212 | }; |
| 213 | |
| 214 | hasClass = function(el, name) { |
| 215 | if (el.classList != null) { |
| 216 | return el.classList.contains(name); |
| 217 | } else { |
| 218 | return new RegExp("(^| )" + name + "( |$)", 'gi').test(el.className); |
| 219 | } |
| 220 | }; |
| 221 | |
| 222 | updateClasses = function(el, add, all) { |
| 223 | var cls, _i, _j, _len, _len1, _results; |
| 224 | for (_i = 0, _len = all.length; _i < _len; _i++) { |
| 225 | cls = all[_i]; |
| 226 | if (__indexOf.call(add, cls) < 0) { |
| 227 | if (hasClass(el, cls)) { |
| 228 | removeClass(el, cls); |
| 229 | } |
| 230 | } |
| 231 | } |
| 232 | _results = []; |
| 233 | for (_j = 0, _len1 = add.length; _j < _len1; _j++) { |
| 234 | cls = add[_j]; |
| 235 | if (!hasClass(el, cls)) { |
| 236 | _results.push(addClass(el, cls)); |
| 237 | } else { |
| 238 | _results.push(void 0); |
| 239 | } |
| 240 | } |
| 241 | return _results; |
| 242 | }; |
| 243 | |
| 244 | deferred = []; |
| 245 | |
| 246 | defer = function(fn) { |
| 247 | return deferred.push(fn); |
| 248 | }; |
| 249 | |
| 250 | flush = function() { |
| 251 | var fn, _results; |
| 252 | _results = []; |
| 253 | while (fn = deferred.pop()) { |
| 254 | _results.push(fn()); |
| 255 | } |
| 256 | return _results; |
| 257 | }; |
| 258 | |
| 259 | Evented = (function() { |
| 260 | function Evented() {} |
| 261 | |
| 262 | Evented.prototype.on = function(event, handler, ctx, once) { |
| 263 | var _base; |
| 264 | if (once == null) { |
| 265 | once = false; |
| 266 | } |
| 267 | if (this.bindings == null) { |
| 268 | this.bindings = {}; |
| 269 | } |
| 270 | if ((_base = this.bindings)[event] == null) { |
| 271 | _base[event] = []; |
| 272 | } |
| 273 | return this.bindings[event].push({ |
| 274 | handler: handler, |
| 275 | ctx: ctx, |
| 276 | once: once |
| 277 | }); |
| 278 | }; |
| 279 | |
| 280 | Evented.prototype.once = function(event, handler, ctx) { |
| 281 | return this.on(event, handler, ctx, true); |
| 282 | }; |
| 283 | |
| 284 | Evented.prototype.off = function(event, handler) { |
| 285 | var i, _ref, _results; |
| 286 | if (((_ref = this.bindings) != null ? _ref[event] : void 0) == null) { |
| 287 | return; |
| 288 | } |
| 289 | if (handler == null) { |
| 290 | return delete this.bindings[event]; |
| 291 | } else { |
| 292 | i = 0; |
| 293 | _results = []; |
| 294 | while (i < this.bindings[event].length) { |
| 295 | if (this.bindings[event][i].handler === handler) { |
| 296 | _results.push(this.bindings[event].splice(i, 1)); |
| 297 | } else { |
| 298 | _results.push(i++); |
| 299 | } |
| 300 | } |
| 301 | return _results; |
| 302 | } |
| 303 | }; |
| 304 | |
| 305 | Evented.prototype.trigger = function() { |
| 306 | var args, ctx, event, handler, i, once, _ref, _ref1, _results; |
| 307 | event = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : []; |
| 308 | if ((_ref = this.bindings) != null ? _ref[event] : void 0) { |
| 309 | i = 0; |
| 310 | _results = []; |
| 311 | while (i < this.bindings[event].length) { |
| 312 | _ref1 = this.bindings[event][i], handler = _ref1.handler, ctx = _ref1.ctx, once = _ref1.once; |
| 313 | handler.apply(ctx != null ? ctx : this, args); |
| 314 | if (once) { |
| 315 | _results.push(this.bindings[event].splice(i, 1)); |
| 316 | } else { |
| 317 | _results.push(i++); |
| 318 | } |
| 319 | } |
| 320 | return _results; |
| 321 | } |
| 322 | }; |
| 323 | |
| 324 | return Evented; |
| 325 | |
| 326 | })(); |
| 327 | |
| 328 | this.Tether.Utils = { |
| 329 | getScrollParent: getScrollParent, |
| 330 | getBounds: getBounds, |
| 331 | getOffsetParent: getOffsetParent, |
| 332 | extend: extend, |
| 333 | addClass: addClass, |
| 334 | removeClass: removeClass, |
| 335 | hasClass: hasClass, |
| 336 | updateClasses: updateClasses, |
| 337 | defer: defer, |
| 338 | flush: flush, |
| 339 | uniqueId: uniqueId, |
| 340 | Evented: Evented, |
| 341 | getScrollBarSize: getScrollBarSize |
| 342 | }; |
| 343 | |
| 344 | }).call(this); |
| 345 | |
| 346 | (function() { |
| 347 | var MIRROR_LR, MIRROR_TB, OFFSET_MAP, Tether, addClass, addOffset, attachmentToOffset, autoToFixedAttachment, defer, extend, flush, getBounds, getOffsetParent, getOuterSize, getScrollBarSize, getScrollParent, getSize, now, offsetToPx, parseAttachment, parseOffset, position, removeClass, tethers, transformKey, updateClasses, within, _Tether, _ref, |
| 348 | __slice = [].slice, |
| 349 | __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }; |
| 350 | |
| 351 | if (this.Tether == null) { |
| 352 | throw new Error("You must include the utils.js file before tether.js"); |
| 353 | } |
| 354 | |
| 355 | Tether = this.Tether; |
| 356 | |
| 357 | _ref = Tether.Utils, getScrollParent = _ref.getScrollParent, getSize = _ref.getSize, getOuterSize = _ref.getOuterSize, getBounds = _ref.getBounds, getOffsetParent = _ref.getOffsetParent, extend = _ref.extend, addClass = _ref.addClass, removeClass = _ref.removeClass, updateClasses = _ref.updateClasses, defer = _ref.defer, flush = _ref.flush, getScrollBarSize = _ref.getScrollBarSize; |
| 358 | |
| 359 | within = function(a, b, diff) { |
| 360 | if (diff == null) { |
| 361 | diff = 1; |
| 362 | } |
| 363 | return (a + diff >= b && b >= a - diff); |
| 364 | }; |
| 365 | |
| 366 | transformKey = (function() { |
| 367 | var el, key, _i, _len, _ref1; |
| 368 | el = document.createElement('div'); |
| 369 | _ref1 = ['transform', 'webkitTransform', 'OTransform', 'MozTransform', 'msTransform']; |
| 370 | for (_i = 0, _len = _ref1.length; _i < _len; _i++) { |
| 371 | key = _ref1[_i]; |
| 372 | if (el.style[key] !== void 0) { |
| 373 | return key; |
| 374 | } |
| 375 | } |
| 376 | })(); |
| 377 | |
| 378 | tethers = []; |
| 379 | |
| 380 | position = function() { |
| 381 | var tether, _i, _len; |
| 382 | for (_i = 0, _len = tethers.length; _i < _len; _i++) { |
| 383 | tether = tethers[_i]; |
| 384 | tether.position(false); |
| 385 | } |
| 386 | return flush(); |
| 387 | }; |
| 388 | |
| 389 | now = function() { |
| 390 | var _ref1; |
| 391 | return (_ref1 = typeof performance !== "undefined" && performance !== null ? typeof performance.now === "function" ? performance.now() : void 0 : void 0) != null ? _ref1 : +(new Date); |
| 392 | }; |
| 393 | |
| 394 | (function() { |
| 395 | var event, lastCall, lastDuration, pendingTimeout, tick, _i, _len, _ref1, _results; |
| 396 | lastCall = null; |
| 397 | lastDuration = null; |
| 398 | pendingTimeout = null; |
| 399 | tick = function() { |
| 400 | if ((lastDuration != null) && lastDuration > 16) { |
| 401 | lastDuration = Math.min(lastDuration - 16, 250); |
| 402 | pendingTimeout = setTimeout(tick, 250); |
| 403 | return; |
| 404 | } |
| 405 | if ((lastCall != null) && (now() - lastCall) < 10) { |
| 406 | return; |
| 407 | } |
| 408 | if (pendingTimeout != null) { |
| 409 | clearTimeout(pendingTimeout); |
| 410 | pendingTimeout = null; |
| 411 | } |
| 412 | lastCall = now(); |
| 413 | position(); |
| 414 | return lastDuration = now() - lastCall; |
| 415 | }; |
| 416 | _ref1 = ['resize', 'scroll', 'touchmove']; |
| 417 | _results = []; |
| 418 | for (_i = 0, _len = _ref1.length; _i < _len; _i++) { |
| 419 | event = _ref1[_i]; |
| 420 | _results.push(window.addEventListener(event, tick)); |
| 421 | } |
| 422 | return _results; |
| 423 | })(); |
| 424 | |
| 425 | MIRROR_LR = { |
| 426 | center: 'center', |
| 427 | left: 'right', |
| 428 | right: 'left' |
| 429 | }; |
| 430 | |
| 431 | MIRROR_TB = { |
| 432 | middle: 'middle', |
| 433 | top: 'bottom', |
| 434 | bottom: 'top' |
| 435 | }; |
| 436 | |
| 437 | OFFSET_MAP = { |
| 438 | top: 0, |
| 439 | left: 0, |
| 440 | middle: '50%', |
| 441 | center: '50%', |
| 442 | bottom: '100%', |
| 443 | right: '100%' |
| 444 | }; |
| 445 | |
| 446 | autoToFixedAttachment = function(attachment, relativeToAttachment) { |
| 447 | var left, top; |
| 448 | left = attachment.left, top = attachment.top; |
| 449 | if (left === 'auto') { |
| 450 | left = MIRROR_LR[relativeToAttachment.left]; |
| 451 | } |
| 452 | if (top === 'auto') { |
| 453 | top = MIRROR_TB[relativeToAttachment.top]; |
| 454 | } |
| 455 | return { |
| 456 | left: left, |
| 457 | top: top |
| 458 | }; |
| 459 | }; |
| 460 | |
| 461 | attachmentToOffset = function(attachment) { |
| 462 | var _ref1, _ref2; |
| 463 | return { |
| 464 | left: (_ref1 = OFFSET_MAP[attachment.left]) != null ? _ref1 : attachment.left, |
| 465 | top: (_ref2 = OFFSET_MAP[attachment.top]) != null ? _ref2 : attachment.top |
| 466 | }; |
| 467 | }; |
| 468 | |
| 469 | addOffset = function() { |
| 470 | var left, offsets, out, top, _i, _len, _ref1; |
| 471 | offsets = 1 <= arguments.length ? __slice.call(arguments, 0) : []; |
| 472 | out = { |
| 473 | top: 0, |
| 474 | left: 0 |
| 475 | }; |
| 476 | for (_i = 0, _len = offsets.length; _i < _len; _i++) { |
| 477 | _ref1 = offsets[_i], top = _ref1.top, left = _ref1.left; |
| 478 | if (typeof top === 'string') { |
| 479 | top = parseFloat(top, 10); |
| 480 | } |
| 481 | if (typeof left === 'string') { |
| 482 | left = parseFloat(left, 10); |
| 483 | } |
| 484 | out.top += top; |
| 485 | out.left += left; |
| 486 | } |
| 487 | return out; |
| 488 | }; |
| 489 | |
| 490 | offsetToPx = function(offset, size) { |
| 491 | if (typeof offset.left === 'string' && offset.left.indexOf('%') !== -1) { |
| 492 | offset.left = parseFloat(offset.left, 10) / 100 * size.width; |
| 493 | } |
| 494 | if (typeof offset.top === 'string' && offset.top.indexOf('%') !== -1) { |
| 495 | offset.top = parseFloat(offset.top, 10) / 100 * size.height; |
| 496 | } |
| 497 | return offset; |
| 498 | }; |
| 499 | |
| 500 | parseAttachment = parseOffset = function(value) { |
| 501 | var left, top, _ref1; |
| 502 | _ref1 = value.split(' '), top = _ref1[0], left = _ref1[1]; |
| 503 | return { |
| 504 | top: top, |
| 505 | left: left |
| 506 | }; |
| 507 | }; |
| 508 | |
| 509 | _Tether = (function() { |
| 510 | _Tether.modules = []; |
| 511 | |
| 512 | function _Tether(options) { |
| 513 | this.position = __bind(this.position, this); |
| 514 | var module, _i, _len, _ref1, _ref2; |
| 515 | tethers.push(this); |
| 516 | this.history = []; |
| 517 | this.setOptions(options, false); |
| 518 | _ref1 = Tether.modules; |
| 519 | for (_i = 0, _len = _ref1.length; _i < _len; _i++) { |
| 520 | module = _ref1[_i]; |
| 521 | if ((_ref2 = module.initialize) != null) { |
| 522 | _ref2.call(this); |
| 523 | } |
| 524 | } |
| 525 | this.position(); |
| 526 | } |
| 527 | |
| 528 | _Tether.prototype.getClass = function(key) { |
| 529 | var _ref1, _ref2; |
| 530 | if ((_ref1 = this.options.classes) != null ? _ref1[key] : void 0) { |
| 531 | return this.options.classes[key]; |
| 532 | } else if (((_ref2 = this.options.classes) != null ? _ref2[key] : void 0) !== false) { |
| 533 | if (this.options.classPrefix) { |
| 534 | return "" + this.options.classPrefix + "-" + key; |
| 535 | } else { |
| 536 | return key; |
| 537 | } |
| 538 | } else { |
| 539 | return ''; |
| 540 | } |
| 541 | }; |
| 542 | |
| 543 | _Tether.prototype.setOptions = function(options, position) { |
| 544 | var defaults, key, _i, _len, _ref1, _ref2; |
| 545 | this.options = options; |
| 546 | if (position == null) { |
| 547 | position = true; |
| 548 | } |
| 549 | defaults = { |
| 550 | offset: '0 0', |
| 551 | targetOffset: '0 0', |
| 552 | targetAttachment: 'auto auto', |
| 553 | classPrefix: 'tether' |
| 554 | }; |
| 555 | this.options = extend(defaults, this.options); |
| 556 | _ref1 = this.options, this.element = _ref1.element, this.target = _ref1.target, this.targetModifier = _ref1.targetModifier; |
| 557 | if (this.target === 'viewport') { |
| 558 | this.target = document.body; |
| 559 | this.targetModifier = 'visible'; |
| 560 | } else if (this.target === 'scroll-handle') { |
| 561 | this.target = document.body; |
| 562 | this.targetModifier = 'scroll-handle'; |
| 563 | } |
| 564 | _ref2 = ['element', 'target']; |
| 565 | for (_i = 0, _len = _ref2.length; _i < _len; _i++) { |
| 566 | key = _ref2[_i]; |
| 567 | if (this[key] == null) { |
| 568 | throw new Error("Tether Error: Both element and target must be defined"); |
| 569 | } |
| 570 | if (this[key].jquery != null) { |
| 571 | this[key] = this[key][0]; |
| 572 | } else if (typeof this[key] === 'string') { |
| 573 | this[key] = document.querySelector(this[key]); |
| 574 | } |
| 575 | } |
| 576 | addClass(this.element, this.getClass('element')); |
| 577 | addClass(this.target, this.getClass('target')); |
| 578 | if (!this.options.attachment) { |
| 579 | throw new Error("Tether Error: You must provide an attachment"); |
| 580 | } |
| 581 | this.targetAttachment = parseAttachment(this.options.targetAttachment); |
| 582 | this.attachment = parseAttachment(this.options.attachment); |
| 583 | this.offset = parseOffset(this.options.offset); |
| 584 | this.targetOffset = parseOffset(this.options.targetOffset); |
| 585 | if (this.scrollParent != null) { |
| 586 | this.disable(); |
| 587 | } |
| 588 | if (this.targetModifier === 'scroll-handle') { |
| 589 | this.scrollParent = this.target; |
| 590 | } else { |
| 591 | this.scrollParent = getScrollParent(this.target); |
| 592 | } |
| 593 | if (this.options.enabled !== false) { |
| 594 | return this.enable(position); |
| 595 | } |
| 596 | }; |
| 597 | |
| 598 | _Tether.prototype.getTargetBounds = function() { |
| 599 | var bounds, fitAdj, hasBottomScroll, height, out, scrollBottom, scrollPercentage, style, target; |
| 600 | if (this.targetModifier != null) { |
| 601 | switch (this.targetModifier) { |
| 602 | case 'visible': |
| 603 | if (this.target === document.body) { |
| 604 | return { |
| 605 | top: pageYOffset, |
| 606 | left: pageXOffset, |
| 607 | height: innerHeight, |
| 608 | width: innerWidth |
| 609 | }; |
| 610 | } else { |
| 611 | bounds = getBounds(this.target); |
| 612 | out = { |
| 613 | height: bounds.height, |
| 614 | width: bounds.width, |
| 615 | top: bounds.top, |
| 616 | left: bounds.left |
| 617 | }; |
| 618 | out.height = Math.min(out.height, bounds.height - (pageYOffset - bounds.top)); |
| 619 | out.height = Math.min(out.height, bounds.height - ((bounds.top + bounds.height) - (pageYOffset + innerHeight))); |
| 620 | out.height = Math.min(innerHeight, out.height); |
| 621 | out.height -= 2; |
| 622 | out.width = Math.min(out.width, bounds.width - (pageXOffset - bounds.left)); |
| 623 | out.width = Math.min(out.width, bounds.width - ((bounds.left + bounds.width) - (pageXOffset + innerWidth))); |
| 624 | out.width = Math.min(innerWidth, out.width); |
| 625 | out.width -= 2; |
| 626 | if (out.top < pageYOffset) { |
| 627 | out.top = pageYOffset; |
| 628 | } |
| 629 | if (out.left < pageXOffset) { |
| 630 | out.left = pageXOffset; |
| 631 | } |
| 632 | return out; |
| 633 | } |
| 634 | break; |
| 635 | case 'scroll-handle': |
| 636 | target = this.target; |
| 637 | if (target === document.body) { |
| 638 | target = document.documentElement; |
| 639 | bounds = { |
| 640 | left: pageXOffset, |
| 641 | top: pageYOffset, |
| 642 | height: innerHeight, |
| 643 | width: innerWidth |
| 644 | }; |
| 645 | } else { |
| 646 | bounds = getBounds(target); |
| 647 | } |
| 648 | style = getComputedStyle(target); |
| 649 | hasBottomScroll = target.scrollWidth > target.clientWidth || 'scroll' === [style.overflow, style.overflowX] || this.target !== document.body; |
| 650 | scrollBottom = 0; |
| 651 | if (hasBottomScroll) { |
| 652 | scrollBottom = 15; |
| 653 | } |
| 654 | height = bounds.height - parseFloat(style.borderTopWidth) - parseFloat(style.borderBottomWidth) - scrollBottom; |
| 655 | out = { |
| 656 | width: 15, |
| 657 | height: height * 0.975 * (height / target.scrollHeight), |
| 658 | left: bounds.left + bounds.width - parseFloat(style.borderLeftWidth) - 15 |
| 659 | }; |
| 660 | fitAdj = 0; |
| 661 | if (height < 408 && this.target === document.body) { |
| 662 | fitAdj = -0.00011 * Math.pow(height, 2) - 0.00727 * height + 22.58; |
| 663 | } |
| 664 | if (this.target !== document.body) { |
| 665 | out.height = Math.max(out.height, 24); |
| 666 | } |
| 667 | scrollPercentage = this.target.scrollTop / (target.scrollHeight - height); |
| 668 | out.top = scrollPercentage * (height - out.height - fitAdj) + bounds.top + parseFloat(style.borderTopWidth); |
| 669 | if (this.target === document.body) { |
| 670 | out.height = Math.max(out.height, 24); |
| 671 | } |
| 672 | return out; |
| 673 | } |
| 674 | } else { |
| 675 | return getBounds(this.target); |
| 676 | } |
| 677 | }; |
| 678 | |
| 679 | _Tether.prototype.clearCache = function() { |
| 680 | return this._cache = {}; |
| 681 | }; |
| 682 | |
| 683 | _Tether.prototype.cache = function(k, getter) { |
| 684 | if (this._cache == null) { |
| 685 | this._cache = {}; |
| 686 | } |
| 687 | if (this._cache[k] == null) { |
| 688 | this._cache[k] = getter.call(this); |
| 689 | } |
| 690 | return this._cache[k]; |
| 691 | }; |
| 692 | |
| 693 | _Tether.prototype.enable = function(position) { |
| 694 | if (position == null) { |
| 695 | position = true; |
| 696 | } |
| 697 | addClass(this.target, this.getClass('enabled')); |
| 698 | addClass(this.element, this.getClass('enabled')); |
| 699 | this.enabled = true; |
| 700 | if (this.scrollParent !== document) { |
| 701 | this.scrollParent.addEventListener('scroll', this.position); |
| 702 | } |
| 703 | if (position) { |
| 704 | return this.position(); |
| 705 | } |
| 706 | }; |
| 707 | |
| 708 | _Tether.prototype.disable = function() { |
| 709 | removeClass(this.target, this.getClass('enabled')); |
| 710 | removeClass(this.element, this.getClass('enabled')); |
| 711 | this.enabled = false; |
| 712 | if (this.scrollParent != null) { |
| 713 | return this.scrollParent.removeEventListener('scroll', this.position); |
| 714 | } |
| 715 | }; |
| 716 | |
| 717 | _Tether.prototype.destroy = function() { |
| 718 | var i, tether, _i, _len, _results; |
| 719 | this.disable(); |
| 720 | _results = []; |
| 721 | for (i = _i = 0, _len = tethers.length; _i < _len; i = ++_i) { |
| 722 | tether = tethers[i]; |
| 723 | if (tether === this) { |
| 724 | tethers.splice(i, 1); |
| 725 | break; |
| 726 | } else { |
| 727 | _results.push(void 0); |
| 728 | } |
| 729 | } |
| 730 | return _results; |
| 731 | }; |
| 732 | |
| 733 | _Tether.prototype.updateAttachClasses = function(elementAttach, targetAttach) { |
| 734 | var add, all, side, sides, _i, _j, _len, _len1, _ref1, |
| 735 | _this = this; |
| 736 | if (elementAttach == null) { |
| 737 | elementAttach = this.attachment; |
| 738 | } |
| 739 | if (targetAttach == null) { |
| 740 | targetAttach = this.targetAttachment; |
| 741 | } |
| 742 | sides = ['left', 'top', 'bottom', 'right', 'middle', 'center']; |
| 743 | if ((_ref1 = this._addAttachClasses) != null ? _ref1.length : void 0) { |
| 744 | this._addAttachClasses.splice(0, this._addAttachClasses.length); |
| 745 | } |
| 746 | add = this._addAttachClasses != null ? this._addAttachClasses : this._addAttachClasses = []; |
| 747 | if (elementAttach.top) { |
| 748 | add.push("" + (this.getClass('element-attached')) + "-" + elementAttach.top); |
| 749 | } |
| 750 | if (elementAttach.left) { |
| 751 | add.push("" + (this.getClass('element-attached')) + "-" + elementAttach.left); |
| 752 | } |
| 753 | if (targetAttach.top) { |
| 754 | add.push("" + (this.getClass('target-attached')) + "-" + targetAttach.top); |
| 755 | } |
| 756 | if (targetAttach.left) { |
| 757 | add.push("" + (this.getClass('target-attached')) + "-" + targetAttach.left); |
| 758 | } |
| 759 | all = []; |
| 760 | for (_i = 0, _len = sides.length; _i < _len; _i++) { |
| 761 | side = sides[_i]; |
| 762 | all.push("" + (this.getClass('element-attached')) + "-" + side); |
| 763 | } |
| 764 | for (_j = 0, _len1 = sides.length; _j < _len1; _j++) { |
| 765 | side = sides[_j]; |
| 766 | all.push("" + (this.getClass('target-attached')) + "-" + side); |
| 767 | } |
| 768 | return defer(function() { |
| 769 | if (_this._addAttachClasses == null) { |
| 770 | return; |
| 771 | } |
| 772 | updateClasses(_this.element, _this._addAttachClasses, all); |
| 773 | updateClasses(_this.target, _this._addAttachClasses, all); |
| 774 | return _this._addAttachClasses = void 0; |
| 775 | }); |
| 776 | }; |
| 777 | |
| 778 | _Tether.prototype.position = function(flushChanges) { |
| 779 | var elementPos, elementStyle, height, left, manualOffset, manualTargetOffset, module, next, offset, offsetBorder, offsetParent, offsetParentSize, offsetParentStyle, offsetPosition, ret, scrollLeft, scrollTop, scrollbarSize, side, targetAttachment, targetOffset, targetPos, targetSize, top, width, _i, _j, _len, _len1, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, |
| 780 | _this = this; |
| 781 | if (flushChanges == null) { |
| 782 | flushChanges = true; |
| 783 | } |
| 784 | if (!this.enabled) { |
| 785 | return; |
| 786 | } |
| 787 | this.clearCache(); |
| 788 | targetAttachment = autoToFixedAttachment(this.targetAttachment, this.attachment); |
| 789 | this.updateAttachClasses(this.attachment, targetAttachment); |
| 790 | elementPos = this.cache('element-bounds', function() { |
| 791 | return getBounds(_this.element); |
| 792 | }); |
| 793 | width = elementPos.width, height = elementPos.height; |
| 794 | if (width === 0 && height === 0 && (this.lastSize != null)) { |
| 795 | _ref1 = this.lastSize, width = _ref1.width, height = _ref1.height; |
| 796 | } else { |
| 797 | this.lastSize = { |
| 798 | width: width, |
| 799 | height: height |
| 800 | }; |
| 801 | } |
| 802 | targetSize = targetPos = this.cache('target-bounds', function() { |
| 803 | return _this.getTargetBounds(); |
| 804 | }); |
| 805 | offset = offsetToPx(attachmentToOffset(this.attachment), { |
| 806 | width: width, |
| 807 | height: height |
| 808 | }); |
| 809 | targetOffset = offsetToPx(attachmentToOffset(targetAttachment), targetSize); |
| 810 | manualOffset = offsetToPx(this.offset, { |
| 811 | width: width, |
| 812 | height: height |
| 813 | }); |
| 814 | manualTargetOffset = offsetToPx(this.targetOffset, targetSize); |
| 815 | offset = addOffset(offset, manualOffset); |
| 816 | targetOffset = addOffset(targetOffset, manualTargetOffset); |
| 817 | left = targetPos.left + targetOffset.left - offset.left; |
| 818 | top = targetPos.top + targetOffset.top - offset.top; |
| 819 | _ref2 = Tether.modules; |
| 820 | for (_i = 0, _len = _ref2.length; _i < _len; _i++) { |
| 821 | module = _ref2[_i]; |
| 822 | ret = module.position.call(this, { |
| 823 | left: left, |
| 824 | top: top, |
| 825 | targetAttachment: targetAttachment, |
| 826 | targetPos: targetPos, |
| 827 | attachment: this.attachment, |
| 828 | elementPos: elementPos, |
| 829 | offset: offset, |
| 830 | targetOffset: targetOffset, |
| 831 | manualOffset: manualOffset, |
| 832 | manualTargetOffset: manualTargetOffset, |
| 833 | scrollbarSize: scrollbarSize |
| 834 | }); |
| 835 | if ((ret == null) || typeof ret !== 'object') { |
| 836 | continue; |
| 837 | } else if (ret === false) { |
| 838 | return false; |
| 839 | } else { |
| 840 | top = ret.top, left = ret.left; |
| 841 | } |
| 842 | } |
| 843 | next = { |
| 844 | page: { |
| 845 | top: top, |
| 846 | left: left |
| 847 | }, |
| 848 | viewport: { |
| 849 | top: top - pageYOffset, |
| 850 | bottom: pageYOffset - top - height + innerHeight, |
| 851 | left: left - pageXOffset, |
| 852 | right: pageXOffset - left - width + innerWidth |
| 853 | } |
| 854 | }; |
| 855 | if (document.body.scrollWidth > window.innerWidth) { |
| 856 | scrollbarSize = this.cache('scrollbar-size', getScrollBarSize); |
| 857 | next.viewport.bottom -= scrollbarSize.height; |
| 858 | } |
| 859 | if (document.body.scrollHeight > window.innerHeight) { |
| 860 | scrollbarSize = this.cache('scrollbar-size', getScrollBarSize); |
| 861 | next.viewport.right -= scrollbarSize.width; |
| 862 | } |
| 863 | if (((_ref3 = document.body.style.position) !== '' && _ref3 !== 'static') || ((_ref4 = document.body.parentElement.style.position) !== '' && _ref4 !== 'static')) { |
| 864 | next.page.bottom = document.body.scrollHeight - top - height; |
| 865 | next.page.right = document.body.scrollWidth - left - width; |
| 866 | } |
| 867 | if (((_ref5 = this.options.optimizations) != null ? _ref5.moveElement : void 0) !== false && (this.targetModifier == null)) { |
| 868 | offsetParent = this.cache('target-offsetparent', function() { |
| 869 | return getOffsetParent(_this.target); |
| 870 | }); |
| 871 | offsetPosition = this.cache('target-offsetparent-bounds', function() { |
| 872 | return getBounds(offsetParent); |
| 873 | }); |
| 874 | offsetParentStyle = getComputedStyle(offsetParent); |
| 875 | elementStyle = getComputedStyle(this.element); |
| 876 | offsetParentSize = offsetPosition; |
| 877 | offsetBorder = {}; |
| 878 | _ref6 = ['Top', 'Left', 'Bottom', 'Right']; |
| 879 | for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) { |
| 880 | side = _ref6[_j]; |
| 881 | offsetBorder[side.toLowerCase()] = parseFloat(offsetParentStyle["border" + side + "Width"]); |
| 882 | } |
| 883 | offsetPosition.right = document.body.scrollWidth - offsetPosition.left - offsetParentSize.width + offsetBorder.right; |
| 884 | offsetPosition.bottom = document.body.scrollHeight - offsetPosition.top - offsetParentSize.height + offsetBorder.bottom; |
| 885 | if (next.page.top >= (offsetPosition.top + offsetBorder.top) && next.page.bottom >= offsetPosition.bottom) { |
| 886 | if (next.page.left >= (offsetPosition.left + offsetBorder.left) && next.page.right >= offsetPosition.right) { |
| 887 | scrollTop = offsetParent.scrollTop; |
| 888 | scrollLeft = offsetParent.scrollLeft; |
| 889 | next.offset = { |
| 890 | top: next.page.top - offsetPosition.top + scrollTop - offsetBorder.top, |
| 891 | left: next.page.left - offsetPosition.left + scrollLeft - offsetBorder.left |
| 892 | }; |
| 893 | } |
| 894 | } |
| 895 | } |
| 896 | this.move(next); |
| 897 | this.history.unshift(next); |
| 898 | if (this.history.length > 3) { |
| 899 | this.history.pop(); |
| 900 | } |
| 901 | if (flushChanges) { |
| 902 | flush(); |
| 903 | } |
| 904 | return true; |
| 905 | }; |
| 906 | |
| 907 | _Tether.prototype.move = function(position) { |
| 908 | var css, elVal, found, key, moved, offsetParent, point, same, transcribe, type, val, write, writeCSS, _i, _len, _ref1, _ref2, |
| 909 | _this = this; |
| 910 | if (this.element.parentNode == null) { |
| 911 | return; |
| 912 | } |
| 913 | same = {}; |
| 914 | for (type in position) { |
| 915 | same[type] = {}; |
| 916 | for (key in position[type]) { |
| 917 | found = false; |
| 918 | _ref1 = this.history; |
| 919 | for (_i = 0, _len = _ref1.length; _i < _len; _i++) { |
| 920 | point = _ref1[_i]; |
| 921 | if (!within((_ref2 = point[type]) != null ? _ref2[key] : void 0, position[type][key])) { |
| 922 | found = true; |
| 923 | break; |
| 924 | } |
| 925 | } |
| 926 | if (!found) { |
| 927 | same[type][key] = true; |
| 928 | } |
| 929 | } |
| 930 | } |
| 931 | css = { |
| 932 | top: '', |
| 933 | left: '', |
| 934 | right: '', |
| 935 | bottom: '' |
| 936 | }; |
| 937 | transcribe = function(same, pos) { |
| 938 | var xPos, yPos, _ref3; |
| 939 | if (((_ref3 = _this.options.optimizations) != null ? _ref3.gpu : void 0) !== false) { |
| 940 | if (same.top) { |
| 941 | css.top = 0; |
| 942 | yPos = pos.top; |
| 943 | } else { |
| 944 | css.bottom = 0; |
| 945 | yPos = -pos.bottom; |
| 946 | } |
| 947 | if (same.left) { |
| 948 | css.left = 0; |
| 949 | xPos = pos.left; |
| 950 | } else { |
| 951 | css.right = 0; |
| 952 | xPos = -pos.right; |
| 953 | } |
| 954 | css[transformKey] = "translateX(" + (Math.round(xPos)) + "px) translateY(" + (Math.round(yPos)) + "px)"; |
| 955 | if (transformKey !== 'msTransform') { |
| 956 | return css[transformKey] += " translateZ(0)"; |
| 957 | } |
| 958 | } else { |
| 959 | if (same.top) { |
| 960 | css.top = "" + pos.top + "px"; |
| 961 | } else { |
| 962 | css.bottom = "" + pos.bottom + "px"; |
| 963 | } |
| 964 | if (same.left) { |
| 965 | return css.left = "" + pos.left + "px"; |
| 966 | } else { |
| 967 | return css.right = "" + pos.right + "px"; |
| 968 | } |
| 969 | } |
| 970 | }; |
| 971 | moved = false; |
| 972 | if ((same.page.top || same.page.bottom) && (same.page.left || same.page.right)) { |
| 973 | css.position = 'absolute'; |
| 974 | transcribe(same.page, position.page); |
| 975 | } else if ((same.viewport.top || same.viewport.bottom) && (same.viewport.left || same.viewport.right)) { |
| 976 | css.position = 'fixed'; |
| 977 | transcribe(same.viewport, position.viewport); |
| 978 | } else if ((same.offset != null) && same.offset.top && same.offset.left) { |
| 979 | css.position = 'absolute'; |
| 980 | offsetParent = this.cache('target-offsetparent', function() { |
| 981 | return getOffsetParent(_this.target); |
| 982 | }); |
| 983 | if (getOffsetParent(this.element) !== offsetParent) { |
| 984 | defer(function() { |
| 985 | _this.element.parentNode.removeChild(_this.element); |
| 986 | return offsetParent.appendChild(_this.element); |
| 987 | }); |
| 988 | } |
| 989 | transcribe(same.offset, position.offset); |
| 990 | moved = true; |
| 991 | } else { |
| 992 | css.position = 'absolute'; |
| 993 | transcribe({ |
| 994 | top: true, |
| 995 | left: true |
| 996 | }, position.page); |
| 997 | } |
| 998 | if (!moved && this.element.parentNode.tagName !== 'BODY') { |
| 999 | this.element.parentNode.removeChild(this.element); |
| 1000 | document.body.appendChild(this.element); |
| 1001 | } |
| 1002 | writeCSS = {}; |
| 1003 | write = false; |
| 1004 | for (key in css) { |
| 1005 | val = css[key]; |
| 1006 | elVal = this.element.style[key]; |
| 1007 | if (elVal !== '' && val !== '' && (key === 'top' || key === 'left' || key === 'bottom' || key === 'right')) { |
| 1008 | elVal = parseFloat(elVal); |
| 1009 | val = parseFloat(val); |
| 1010 | } |
| 1011 | if (elVal !== val) { |
| 1012 | write = true; |
| 1013 | writeCSS[key] = css[key]; |
| 1014 | } |
| 1015 | } |
| 1016 | if (write) { |
| 1017 | return defer(function() { |
| 1018 | return extend(_this.element.style, writeCSS); |
| 1019 | }); |
| 1020 | } |
| 1021 | }; |
| 1022 | |
| 1023 | return _Tether; |
| 1024 | |
| 1025 | })(); |
| 1026 | |
| 1027 | Tether.position = position; |
| 1028 | |
| 1029 | this.Tether = extend(_Tether, Tether); |
| 1030 | |
| 1031 | }).call(this); |
| 1032 | |
| 1033 | (function() { |
| 1034 | var BOUNDS_FORMAT, MIRROR_ATTACH, defer, extend, getBoundingRect, getBounds, getOuterSize, getSize, updateClasses, _ref, |
| 1035 | __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }; |
| 1036 | |
| 1037 | _ref = this.Tether.Utils, getOuterSize = _ref.getOuterSize, getBounds = _ref.getBounds, getSize = _ref.getSize, extend = _ref.extend, updateClasses = _ref.updateClasses, defer = _ref.defer; |
| 1038 | |
| 1039 | MIRROR_ATTACH = { |
| 1040 | left: 'right', |
| 1041 | right: 'left', |
| 1042 | top: 'bottom', |
| 1043 | bottom: 'top', |
| 1044 | middle: 'middle' |
| 1045 | }; |
| 1046 | |
| 1047 | BOUNDS_FORMAT = ['left', 'top', 'right', 'bottom']; |
| 1048 | |
| 1049 | getBoundingRect = function(tether, to) { |
| 1050 | var i, pos, side, size, style, _i, _len; |
| 1051 | if (to === 'scrollParent') { |
| 1052 | to = tether.scrollParent; |
| 1053 | } else if (to === 'window') { |
| 1054 | to = [pageXOffset, pageYOffset, innerWidth + pageXOffset, innerHeight + pageYOffset]; |
| 1055 | } |
| 1056 | if (to === document) { |
| 1057 | to = to.documentElement; |
| 1058 | } |
| 1059 | if (to.nodeType != null) { |
| 1060 | pos = size = getBounds(to); |
| 1061 | style = getComputedStyle(to); |
| 1062 | to = [pos.left, pos.top, size.width + pos.left, size.height + pos.top]; |
| 1063 | for (i = _i = 0, _len = BOUNDS_FORMAT.length; _i < _len; i = ++_i) { |
| 1064 | side = BOUNDS_FORMAT[i]; |
| 1065 | side = side[0].toUpperCase() + side.substr(1); |
| 1066 | if (side === 'Top' || side === 'Left') { |
| 1067 | to[i] += parseFloat(style["border" + side + "Width"]); |
| 1068 | } else { |
| 1069 | to[i] -= parseFloat(style["border" + side + "Width"]); |
| 1070 | } |
| 1071 | } |
| 1072 | } |
| 1073 | return to; |
| 1074 | }; |
| 1075 | |
| 1076 | this.Tether.modules.push({ |
| 1077 | position: function(_arg) { |
| 1078 | var addClasses, allClasses, attachment, bounds, changeAttachX, changeAttachY, cls, constraint, eAttachment, height, left, oob, oobClass, p, pin, pinned, pinnedClass, removeClass, side, tAttachment, targetAttachment, targetHeight, targetSize, targetWidth, to, top, width, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _len5, _m, _n, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, |
| 1079 | _this = this; |
| 1080 | top = _arg.top, left = _arg.left, targetAttachment = _arg.targetAttachment; |
| 1081 | if (!this.options.constraints) { |
| 1082 | return true; |
| 1083 | } |
| 1084 | removeClass = function(prefix) { |
| 1085 | var side, _i, _len, _results; |
| 1086 | _this.removeClass(prefix); |
| 1087 | _results = []; |
| 1088 | for (_i = 0, _len = BOUNDS_FORMAT.length; _i < _len; _i++) { |
| 1089 | side = BOUNDS_FORMAT[_i]; |
| 1090 | _results.push(_this.removeClass("" + prefix + "-" + side)); |
| 1091 | } |
| 1092 | return _results; |
| 1093 | }; |
| 1094 | _ref1 = this.cache('element-bounds', function() { |
| 1095 | return getBounds(_this.element); |
| 1096 | }), height = _ref1.height, width = _ref1.width; |
| 1097 | if (width === 0 && height === 0 && (this.lastSize != null)) { |
| 1098 | _ref2 = this.lastSize, width = _ref2.width, height = _ref2.height; |
| 1099 | } |
| 1100 | targetSize = this.cache('target-bounds', function() { |
| 1101 | return _this.getTargetBounds(); |
| 1102 | }); |
| 1103 | targetHeight = targetSize.height; |
| 1104 | targetWidth = targetSize.width; |
| 1105 | tAttachment = {}; |
| 1106 | eAttachment = {}; |
| 1107 | allClasses = [this.getClass('pinned'), this.getClass('out-of-bounds')]; |
| 1108 | _ref3 = this.options.constraints; |
| 1109 | for (_i = 0, _len = _ref3.length; _i < _len; _i++) { |
| 1110 | constraint = _ref3[_i]; |
| 1111 | if (constraint.outOfBoundsClass) { |
| 1112 | allClasses.push(constraint.outOfBoundsClass); |
| 1113 | } |
| 1114 | if (constraint.pinnedClass) { |
| 1115 | allClasses.push(constraint.pinnedClass); |
| 1116 | } |
| 1117 | } |
| 1118 | for (_j = 0, _len1 = allClasses.length; _j < _len1; _j++) { |
| 1119 | cls = allClasses[_j]; |
| 1120 | _ref4 = ['left', 'top', 'right', 'bottom']; |
| 1121 | for (_k = 0, _len2 = _ref4.length; _k < _len2; _k++) { |
| 1122 | side = _ref4[_k]; |
| 1123 | allClasses.push("" + cls + "-" + side); |
| 1124 | } |
| 1125 | } |
| 1126 | addClasses = []; |
| 1127 | tAttachment = extend({}, targetAttachment); |
| 1128 | eAttachment = extend({}, this.attachment); |
| 1129 | _ref5 = this.options.constraints; |
| 1130 | for (_l = 0, _len3 = _ref5.length; _l < _len3; _l++) { |
| 1131 | constraint = _ref5[_l]; |
| 1132 | to = constraint.to, attachment = constraint.attachment, pin = constraint.pin; |
| 1133 | if (attachment == null) { |
| 1134 | attachment = ''; |
| 1135 | } |
| 1136 | if (__indexOf.call(attachment, ' ') >= 0) { |
| 1137 | _ref6 = attachment.split(' '), changeAttachY = _ref6[0], changeAttachX = _ref6[1]; |
| 1138 | } else { |
| 1139 | changeAttachX = changeAttachY = attachment; |
| 1140 | } |
| 1141 | bounds = getBoundingRect(this, to); |
| 1142 | if (changeAttachY === 'target' || changeAttachY === 'both') { |
| 1143 | if (top < bounds[1] && tAttachment.top === 'top') { |
| 1144 | top += targetHeight; |
| 1145 | tAttachment.top = 'bottom'; |
| 1146 | } |
| 1147 | if (top + height > bounds[3] && tAttachment.top === 'bottom') { |
| 1148 | top -= targetHeight; |
| 1149 | tAttachment.top = 'top'; |
| 1150 | } |
| 1151 | } |
| 1152 | if (changeAttachY === 'together') { |
| 1153 | if (top < bounds[1] && tAttachment.top === 'top') { |
| 1154 | if (eAttachment.top === 'bottom') { |
| 1155 | top += targetHeight; |
| 1156 | tAttachment.top = 'bottom'; |
| 1157 | top += height; |
| 1158 | eAttachment.top = 'top'; |
| 1159 | } else if (eAttachment.top === 'top') { |
| 1160 | top += targetHeight; |
| 1161 | tAttachment.top = 'bottom'; |
| 1162 | top -= height; |
| 1163 | eAttachment.top = 'bottom'; |
| 1164 | } |
| 1165 | } |
| 1166 | if (top + height > bounds[3] && tAttachment.top === 'bottom') { |
| 1167 | if (eAttachment.top === 'top') { |
| 1168 | top -= targetHeight; |
| 1169 | tAttachment.top = 'top'; |
| 1170 | top -= height; |
| 1171 | eAttachment.top = 'bottom'; |
| 1172 | } else if (eAttachment.top === 'bottom') { |
| 1173 | top -= targetHeight; |
| 1174 | tAttachment.top = 'top'; |
| 1175 | top += height; |
| 1176 | eAttachment.top = 'top'; |
| 1177 | } |
| 1178 | } |
| 1179 | if (tAttachment.top === 'middle') { |
| 1180 | if (top + height > bounds[3] && eAttachment.top === 'top') { |
| 1181 | top -= height; |
| 1182 | eAttachment.top = 'bottom'; |
| 1183 | } else if (top < bounds[1] && eAttachment.top === 'bottom') { |
| 1184 | top += height; |
| 1185 | eAttachment.top = 'top'; |
| 1186 | } |
| 1187 | } |
| 1188 | } |
| 1189 | if (changeAttachX === 'target' || changeAttachX === 'both') { |
| 1190 | if (left < bounds[0] && tAttachment.left === 'left') { |
| 1191 | left += targetWidth; |
| 1192 | tAttachment.left = 'right'; |
| 1193 | } |
| 1194 | if (left + width > bounds[2] && tAttachment.left === 'right') { |
| 1195 | left -= targetWidth; |
| 1196 | tAttachment.left = 'left'; |
| 1197 | } |
| 1198 | } |
| 1199 | if (changeAttachX === 'together') { |
| 1200 | if (left < bounds[0] && tAttachment.left === 'left') { |
| 1201 | if (eAttachment.left === 'right') { |
| 1202 | left += targetWidth; |
| 1203 | tAttachment.left = 'right'; |
| 1204 | left += width; |
| 1205 | eAttachment.left = 'left'; |
| 1206 | } else if (eAttachment.left === 'left') { |
| 1207 | left += targetWidth; |
| 1208 | tAttachment.left = 'right'; |
| 1209 | left -= width; |
| 1210 | eAttachment.left = 'right'; |
| 1211 | } |
| 1212 | } else if (left + width > bounds[2] && tAttachment.left === 'right') { |
| 1213 | if (eAttachment.left === 'left') { |
| 1214 | left -= targetWidth; |
| 1215 | tAttachment.left = 'left'; |
| 1216 | left -= width; |
| 1217 | eAttachment.left = 'right'; |
| 1218 | } else if (eAttachment.left === 'right') { |
| 1219 | left -= targetWidth; |
| 1220 | tAttachment.left = 'left'; |
| 1221 | left += width; |
| 1222 | eAttachment.left = 'left'; |
| 1223 | } |
| 1224 | } else if (tAttachment.left === 'center') { |
| 1225 | if (left + width > bounds[2] && eAttachment.left === 'left') { |
| 1226 | left -= width; |
| 1227 | eAttachment.left = 'right'; |
| 1228 | } else if (left < bounds[0] && eAttachment.left === 'right') { |
| 1229 | left += width; |
| 1230 | eAttachment.left = 'left'; |
| 1231 | } |
| 1232 | } |
| 1233 | } |
| 1234 | if (changeAttachY === 'element' || changeAttachY === 'both') { |
| 1235 | if (top < bounds[1] && eAttachment.top === 'bottom') { |
| 1236 | top += height; |
| 1237 | eAttachment.top = 'top'; |
| 1238 | } |
| 1239 | if (top + height > bounds[3] && eAttachment.top === 'top') { |
| 1240 | top -= height; |
| 1241 | eAttachment.top = 'bottom'; |
| 1242 | } |
| 1243 | } |
| 1244 | if (changeAttachX === 'element' || changeAttachX === 'both') { |
| 1245 | if (left < bounds[0] && eAttachment.left === 'right') { |
| 1246 | left += width; |
| 1247 | eAttachment.left = 'left'; |
| 1248 | } |
| 1249 | if (left + width > bounds[2] && eAttachment.left === 'left') { |
| 1250 | left -= width; |
| 1251 | eAttachment.left = 'right'; |
| 1252 | } |
| 1253 | } |
| 1254 | if (typeof pin === 'string') { |
| 1255 | pin = (function() { |
| 1256 | var _len4, _m, _ref7, _results; |
| 1257 | _ref7 = pin.split(','); |
| 1258 | _results = []; |
| 1259 | for (_m = 0, _len4 = _ref7.length; _m < _len4; _m++) { |
| 1260 | p = _ref7[_m]; |
| 1261 | _results.push(p.trim()); |
| 1262 | } |
| 1263 | return _results; |
| 1264 | })(); |
| 1265 | } else if (pin === true) { |
| 1266 | pin = ['top', 'left', 'right', 'bottom']; |
| 1267 | } |
| 1268 | pin || (pin = []); |
| 1269 | pinned = []; |
| 1270 | oob = []; |
| 1271 | if (top < bounds[1]) { |
| 1272 | if (__indexOf.call(pin, 'top') >= 0) { |
| 1273 | top = bounds[1]; |
| 1274 | pinned.push('top'); |
| 1275 | } else { |
| 1276 | oob.push('top'); |
| 1277 | } |
| 1278 | } |
| 1279 | if (top + height > bounds[3]) { |
| 1280 | if (__indexOf.call(pin, 'bottom') >= 0) { |
| 1281 | top = bounds[3] - height; |
| 1282 | pinned.push('bottom'); |
| 1283 | } else { |
| 1284 | oob.push('bottom'); |
| 1285 | } |
| 1286 | } |
| 1287 | if (left < bounds[0]) { |
| 1288 | if (__indexOf.call(pin, 'left') >= 0) { |
| 1289 | left = bounds[0]; |
| 1290 | pinned.push('left'); |
| 1291 | } else { |
| 1292 | oob.push('left'); |
| 1293 | } |
| 1294 | } |
| 1295 | if (left + width > bounds[2]) { |
| 1296 | if (__indexOf.call(pin, 'right') >= 0) { |
| 1297 | left = bounds[2] - width; |
| 1298 | pinned.push('right'); |
| 1299 | } else { |
| 1300 | oob.push('right'); |
| 1301 | } |
| 1302 | } |
| 1303 | if (pinned.length) { |
| 1304 | pinnedClass = (_ref7 = this.options.pinnedClass) != null ? _ref7 : this.getClass('pinned'); |
| 1305 | addClasses.push(pinnedClass); |
| 1306 | for (_m = 0, _len4 = pinned.length; _m < _len4; _m++) { |
| 1307 | side = pinned[_m]; |
| 1308 | addClasses.push("" + pinnedClass + "-" + side); |
| 1309 | } |
| 1310 | } |
| 1311 | if (oob.length) { |
| 1312 | oobClass = (_ref8 = this.options.outOfBoundsClass) != null ? _ref8 : this.getClass('out-of-bounds'); |
| 1313 | addClasses.push(oobClass); |
| 1314 | for (_n = 0, _len5 = oob.length; _n < _len5; _n++) { |
| 1315 | side = oob[_n]; |
| 1316 | addClasses.push("" + oobClass + "-" + side); |
| 1317 | } |
| 1318 | } |
| 1319 | if (__indexOf.call(pinned, 'left') >= 0 || __indexOf.call(pinned, 'right') >= 0) { |
| 1320 | eAttachment.left = tAttachment.left = false; |
| 1321 | } |
| 1322 | if (__indexOf.call(pinned, 'top') >= 0 || __indexOf.call(pinned, 'bottom') >= 0) { |
| 1323 | eAttachment.top = tAttachment.top = false; |
| 1324 | } |
| 1325 | if (tAttachment.top !== targetAttachment.top || tAttachment.left !== targetAttachment.left || eAttachment.top !== this.attachment.top || eAttachment.left !== this.attachment.left) { |
| 1326 | this.updateAttachClasses(eAttachment, tAttachment); |
| 1327 | } |
| 1328 | } |
| 1329 | defer(function() { |
| 1330 | updateClasses(_this.target, addClasses, allClasses); |
| 1331 | return updateClasses(_this.element, addClasses, allClasses); |
| 1332 | }); |
| 1333 | return { |
| 1334 | top: top, |
| 1335 | left: left |
| 1336 | }; |
| 1337 | } |
| 1338 | }); |
| 1339 | |
| 1340 | }).call(this); |
| 1341 | |
| 1342 | (function() { |
| 1343 | var defer, getBounds, updateClasses, _ref; |
| 1344 | |
| 1345 | _ref = this.Tether.Utils, getBounds = _ref.getBounds, updateClasses = _ref.updateClasses, defer = _ref.defer; |
| 1346 | |
| 1347 | this.Tether.modules.push({ |
| 1348 | position: function(_arg) { |
| 1349 | var abutted, addClasses, allClasses, bottom, height, left, right, side, sides, targetPos, top, width, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref1, _ref2, _ref3, _ref4, _ref5, |
| 1350 | _this = this; |
| 1351 | top = _arg.top, left = _arg.left; |
| 1352 | _ref1 = this.cache('element-bounds', function() { |
| 1353 | return getBounds(_this.element); |
| 1354 | }), height = _ref1.height, width = _ref1.width; |
| 1355 | targetPos = this.getTargetBounds(); |
| 1356 | bottom = top + height; |
| 1357 | right = left + width; |
| 1358 | abutted = []; |
| 1359 | if (top <= targetPos.bottom && bottom >= targetPos.top) { |
| 1360 | _ref2 = ['left', 'right']; |
| 1361 | for (_i = 0, _len = _ref2.length; _i < _len; _i++) { |
| 1362 | side = _ref2[_i]; |
| 1363 | if ((_ref3 = targetPos[side]) === left || _ref3 === right) { |
| 1364 | abutted.push(side); |
| 1365 | } |
| 1366 | } |
| 1367 | } |
| 1368 | if (left <= targetPos.right && right >= targetPos.left) { |
| 1369 | _ref4 = ['top', 'bottom']; |
| 1370 | for (_j = 0, _len1 = _ref4.length; _j < _len1; _j++) { |
| 1371 | side = _ref4[_j]; |
| 1372 | if ((_ref5 = targetPos[side]) === top || _ref5 === bottom) { |
| 1373 | abutted.push(side); |
| 1374 | } |
| 1375 | } |
| 1376 | } |
| 1377 | allClasses = []; |
| 1378 | addClasses = []; |
| 1379 | sides = ['left', 'top', 'right', 'bottom']; |
| 1380 | allClasses.push(this.getClass('abutted')); |
| 1381 | for (_k = 0, _len2 = sides.length; _k < _len2; _k++) { |
| 1382 | side = sides[_k]; |
| 1383 | allClasses.push("" + (this.getClass('abutted')) + "-" + side); |
| 1384 | } |
| 1385 | if (abutted.length) { |
| 1386 | addClasses.push(this.getClass('abutted')); |
| 1387 | } |
| 1388 | for (_l = 0, _len3 = abutted.length; _l < _len3; _l++) { |
| 1389 | side = abutted[_l]; |
| 1390 | addClasses.push("" + (this.getClass('abutted')) + "-" + side); |
| 1391 | } |
| 1392 | defer(function() { |
| 1393 | updateClasses(_this.target, addClasses, allClasses); |
| 1394 | return updateClasses(_this.element, addClasses, allClasses); |
| 1395 | }); |
| 1396 | return true; |
| 1397 | } |
| 1398 | }); |
| 1399 | |
| 1400 | }).call(this); |
| 1401 | |
| 1402 | (function() { |
| 1403 | this.Tether.modules.push({ |
| 1404 | position: function(_arg) { |
| 1405 | var left, result, shift, shiftLeft, shiftTop, top, _ref; |
| 1406 | top = _arg.top, left = _arg.left; |
| 1407 | if (!this.options.shift) { |
| 1408 | return; |
| 1409 | } |
| 1410 | result = function(val) { |
| 1411 | if (typeof val === 'function') { |
| 1412 | return val.call(this, { |
| 1413 | top: top, |
| 1414 | left: left |
| 1415 | }); |
| 1416 | } else { |
| 1417 | return val; |
| 1418 | } |
| 1419 | }; |
| 1420 | shift = result(this.options.shift); |
| 1421 | if (typeof shift === 'string') { |
| 1422 | shift = shift.split(' '); |
| 1423 | shift[1] || (shift[1] = shift[0]); |
| 1424 | shiftTop = shift[0], shiftLeft = shift[1]; |
| 1425 | shiftTop = parseFloat(shiftTop, 10); |
| 1426 | shiftLeft = parseFloat(shiftLeft, 10); |
| 1427 | } else { |
| 1428 | _ref = [shift.top, shift.left], shiftTop = _ref[0], shiftLeft = _ref[1]; |
| 1429 | } |
| 1430 | top += shiftTop; |
| 1431 | left += shiftLeft; |
| 1432 | return { |
| 1433 | top: top, |
| 1434 | left: left |
| 1435 | }; |
| 1436 | } |
| 1437 | }); |
| 1438 | |
| 1439 | }).call(this); |
| 1440 | |
| 1441 | return this.Tether; |
| 1442 | |
| 1443 | })); |
| 1444 |