| 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 |
|
