664 lines
23 KiB
JavaScript
664 lines
23 KiB
JavaScript
'use strict';
|
|
|
|
/*@
|
|
Ox.Element <f> Basic UI element object
|
|
# Arguments ----------------------------------------------------------------
|
|
options <o|s> Options of the element, or just the `element` option
|
|
element <s> Tagname or CSS selector
|
|
tooltip <s|f> Tooltip title, or a function that returns one
|
|
(e) -> <s> Tooltip title
|
|
e <o> Mouse event
|
|
self <o> Shared private variable
|
|
# Usage --------------------------------------------------------------------
|
|
([options[, self]]) -> <o:Ox.JQueryElement> Element object
|
|
# Events ---------------------------------------------------------------
|
|
anyclick <!> anyclick
|
|
Fires on mouseup, but not on any subsequent mouseup within 250 ms
|
|
(this is useful if one wants to listen for singleclicks, but not
|
|
doubleclicks, since it will fire immediately, and won't fire again
|
|
in case of a doubleclick)
|
|
* <*> Original event properties
|
|
doubleclick <!> doubleclick
|
|
Fires on the second mousedown within 250 ms (this is useful if one
|
|
wants to listen for both singleclicks and doubleclicks, since it
|
|
will not trigger a singleclick event)
|
|
* <*> Original event properties
|
|
drag <!> drag
|
|
Fires on mousemove after dragstart, stops firing on mouseup
|
|
clientDX <n> Horizontal drag delta in px
|
|
clientDY <n> Vertical drag delta in px
|
|
* <*> Original event properties
|
|
dragend <!> dragpause
|
|
Fires on mouseup after dragstart
|
|
clientDX <n> Horizontal drag delta in px
|
|
clientDY <n> Vertical drag delta in px
|
|
* <*> Original event properties
|
|
dragenter <!> dragenter
|
|
Fires when entering an element during drag (this fires on the
|
|
element being dragged -- the target element is the event's target
|
|
property)
|
|
clientDX <n> Horizontal drag delta in px
|
|
clientDY <n> Vertical drag delta in px
|
|
* <*> Original event properties
|
|
dragleave <!> dragleave
|
|
Fires when leaving an element during drag (this fires on the element
|
|
being dragged -- the target element is the event's target property)
|
|
clientDX <n> Horizontal drag delta in px
|
|
clientDY <n> Vertical drag delta in px
|
|
* <*> Original event properties
|
|
dragpause <!> dragpause
|
|
Fires once when the mouse doesn't move for 250 ms during drag (this
|
|
is useful in order to execute operations that are too expensive to
|
|
be attached to the drag event)
|
|
clientDX <n> Horizontal drag delta in px
|
|
clientDY <n> Vertical drag delta in px
|
|
* <*> Original event properties
|
|
dragstart <!> dragstart
|
|
Fires when the mouse is down for 250 ms
|
|
* <*> Original event properties
|
|
mousedown <!> mousedown
|
|
Fires on mousedown (this is useful if one wants to listen for
|
|
singleclicks, but not doubleclicks or drag events, and wants the
|
|
event to fire as early as possible)
|
|
* <*> Original event properties
|
|
mouserepeat <!> mouserepeat
|
|
Fires every 50 ms after the mouse was down for 250 ms, stops firing
|
|
on mouseleave or mouseup (this fires like a key that is being
|
|
pressed and held, and is useful for buttons like scrollbars arrows
|
|
that need to react to both clicking and holding)
|
|
mousewheel <!> mousewheel
|
|
Fires on mousewheel scroll or trackpad swipe
|
|
deltaFactor <n> Original delta = normalized delta * delta factor
|
|
deltaX <n> Normalized horizontal scroll delta in px
|
|
deltaY <n> Normalized vertical scroll delta in px
|
|
* <*> Original event properties
|
|
singleclick <!> singleclick
|
|
Fires 250 ms after mouseup, if there was no subsequent mousedown
|
|
(this is useful if one wants to listen for both singleclicks and
|
|
doubleclicks, since it will not fire for doubleclicks)
|
|
* <*> Original event properties
|
|
*/
|
|
|
|
Ox.Element = function(options, self) {
|
|
|
|
// create private object
|
|
self = self || {};
|
|
// create defaults and options objects
|
|
self.defaults = {};
|
|
// allow for Ox.TestElement('<tagname>') or Ox.TestElement('cssSelector')
|
|
self.options = Ox.isString(options) ? {element: options} : options || {};
|
|
// stack of callbacks bound to option updates
|
|
self.updateCallbacks = self.updateCallbacks || [];
|
|
|
|
self.boundTooltipEvents = {};
|
|
|
|
// create public object
|
|
var that = new Ox.JQueryElement($(self.options.element || '<div>'))
|
|
.addClass('OxElement')
|
|
.on(Ox.extend({
|
|
mousedown: mousedown,
|
|
mousewheel: mousewheel
|
|
}, self.options.element == '<iframe>' ? {
|
|
load: function() {
|
|
Ox.Message.post(that, 'init', {id: that.oxid});
|
|
}
|
|
} : {}));
|
|
|
|
setTooltip();
|
|
|
|
function bindTooltipEvents(events) {
|
|
that.off(Ox.filter(self.boundTooltipEvents, function(value, key) {
|
|
return !events[key];
|
|
})).on(self.boundTooltipEvents = Ox.filter(events, function(value, key) {
|
|
return !self.boundTooltipEvents[key];
|
|
}));
|
|
}
|
|
|
|
function mousedown(e) {
|
|
/*
|
|
better mouse events
|
|
mousedown:
|
|
trigger mousedown
|
|
within 250 msec:
|
|
mouseup: trigger anyclick
|
|
mouseup + mousedown: trigger doubleclick
|
|
after 250 msec:
|
|
mouseup + no mousedown within 250 msec: trigger singleclick
|
|
no mouseup within 250 msec:
|
|
trigger mouserepeat every 50 msec
|
|
trigger dragstart
|
|
mousemove: trigger drag
|
|
no mousemove for 250 msec:
|
|
trigger dragpause
|
|
mouseup: trigger dragend
|
|
"anyclick" is not called "click" since this would collide with the click
|
|
events of some widgets
|
|
*/
|
|
var clientX, clientY,
|
|
dragTimeout = 0,
|
|
mouseInterval = 0;
|
|
that.triggerEvent('mousedown', e);
|
|
if (!self._mouseTimeout) {
|
|
// first mousedown
|
|
self._drag = false;
|
|
self._mouseup = false;
|
|
self._mouseTimeout = setTimeout(function() {
|
|
// 250 ms later, no subsequent click
|
|
self._mouseTimeout = 0;
|
|
if (self._mouseup) {
|
|
// mouse went up, trigger singleclick
|
|
that.triggerEvent('singleclick', e);
|
|
} else {
|
|
// mouse is still down, trigger mouserepeat
|
|
// every 50 ms until mouseleave or mouseup
|
|
mouserepeat();
|
|
mouseInterval = setInterval(mouserepeat, 50);
|
|
that.one('mouseleave', function() {
|
|
clearInterval(mouseInterval);
|
|
});
|
|
// trigger dragstart, set up drag events
|
|
that.triggerEvent('dragstart', e);
|
|
$('.OxElement').live({
|
|
mouseenter: dragenter,
|
|
mouseleave: dragleave
|
|
});
|
|
clientX = e.clientX;
|
|
clientY = e.clientY;
|
|
Ox.UI.$window
|
|
.off('mouseup', mouseup)
|
|
.on({mousemove: mousemove})
|
|
.one('mouseup', function(e) {
|
|
// stop checking for mouserepeat
|
|
clearInterval(mouseInterval);
|
|
// stop checking for dragpause
|
|
clearTimeout(dragTimeout);
|
|
// stop checking for drag
|
|
Ox.UI.$window.off({mousemove: mousemove});
|
|
// stop checking for dragenter and dragleave
|
|
$('.OxElement').off({
|
|
mouseenter: dragenter,
|
|
mouseleave: dragleave
|
|
});
|
|
// trigger dragend
|
|
that.triggerEvent('dragend', extend(e));
|
|
});
|
|
self._drag = true;
|
|
}
|
|
}, 250);
|
|
} else {
|
|
// second mousedown within 250 ms, trigger doubleclick
|
|
clearTimeout(self._mouseTimeout);
|
|
self._mouseTimeout = 0;
|
|
that.triggerEvent('doubleclick', e);
|
|
}
|
|
Ox.UI.$window.one({mouseup: mouseup});
|
|
function dragenter(e) {
|
|
that.triggerEvent('dragenter', extend(e));
|
|
}
|
|
function dragleave(e) {
|
|
that.triggerEvent('dragleave', extend(e));
|
|
}
|
|
function extend(e) {
|
|
return Ox.extend({
|
|
clientDX: e.clientX - clientX,
|
|
clientDY: e.clientY - clientY
|
|
}, e);
|
|
}
|
|
function mousemove(e) {
|
|
e = extend(e);
|
|
clearTimeout(dragTimeout);
|
|
dragTimeout = setTimeout(function() {
|
|
// mouse did not move for 250 ms, trigger dragpause
|
|
that.triggerEvent('dragpause', e);
|
|
}, 250);
|
|
that.triggerEvent('drag', e);
|
|
}
|
|
function mouserepeat(e) {
|
|
that.triggerEvent('mouserepeat', e);
|
|
}
|
|
function mouseup(e) {
|
|
if (!self._mouseup && !self._drag) {
|
|
// mouse went up for the first time, trigger anyclick
|
|
that.triggerEvent('anyclick', e);
|
|
self._mouseup = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
function mouseenter(e) {
|
|
if (!that.$tooltip) {
|
|
that.$tooltip = Ox.Tooltip({title: self.options.tooltip});
|
|
}
|
|
that.$tooltip.show(e);
|
|
}
|
|
|
|
function mouseleave(e) {
|
|
that.$tooltip && that.$tooltip.hide();
|
|
}
|
|
|
|
function mousemove(e) {
|
|
that.$tooltip.options({title: self.options.tooltip(e)}).show(e);
|
|
}
|
|
|
|
function mousewheel(e) {
|
|
// see https://github.com/brandonaaron/jquery-mousewheel/blob/master/jquery.mousewheel.js
|
|
e = e.originalEvent;
|
|
var absDelta,
|
|
deltaX = 'deltaX' in e ? e.deltaX
|
|
: 'wheelDeltaX' in e ? -e.wheelDeltaX
|
|
: 0,
|
|
deltaY = 'deltaY' in e ? -e.deltaY
|
|
: 'wheelDeltaY' in e ? e.wheelDeltaY
|
|
: 'wheelDelta' in e ? e.wheelDelta
|
|
: 0;
|
|
// Firefox < 17
|
|
if ('axis' in e && e.axis === e.HORIZONTAL_AXIS) {
|
|
deltaX = -deltaY;
|
|
deltaY = 0;
|
|
}
|
|
if (deltaX || deltaY) {
|
|
absDelta = Math.max(Math.abs(deltaY), Math.abs(deltaX));
|
|
if (!self._deltaFactor || self._deltaFactor > absDelta) {
|
|
self._deltaFactor = absDelta;
|
|
}
|
|
that.triggerEvent('mousewheel', Ox.extend(e, {
|
|
deltaFactor: self._deltaFactor,
|
|
deltaX: Ox.trunc(deltaX / self._deltaFactor),
|
|
deltaY: Ox.trunc(deltaY / self._deltaFactor)
|
|
}));
|
|
clearTimeout(self._deltaTimeout)
|
|
self._deltaTimeout = setTimeout(function() {
|
|
self._deltaFactor = null;
|
|
}, 200);
|
|
}
|
|
}
|
|
|
|
// TODO: in other widgets, use this,
|
|
// rather than some self.$tooltip that
|
|
// will not get garbage collected
|
|
function setTooltip() {
|
|
if (self.options.tooltip) {
|
|
if (Ox.isString(self.options.tooltip)) {
|
|
bindTooltipEvents({
|
|
mouseenter: mouseenter,
|
|
mouseleave: mouseleave
|
|
});
|
|
that.$tooltip && that.$tooltip.options({
|
|
title: self.options.tooltip,
|
|
animate: true
|
|
});
|
|
} else {
|
|
that.$tooltip = Ox.Tooltip({animate: false});
|
|
bindTooltipEvents({
|
|
mousemove: mousemove,
|
|
mouseleave: mouseleave
|
|
});
|
|
}
|
|
} else {
|
|
if (that.$tooltip) {
|
|
that.$tooltip.remove();
|
|
}
|
|
bindTooltipEvents({});
|
|
}
|
|
}
|
|
|
|
function update(key, value) {
|
|
// update is called whenever an option is modified or added
|
|
Ox.loop(self.updateCallbacks.length - 1, -1, -1, function(i) {
|
|
// break if the callback returns false
|
|
return self.updateCallbacks[i](key, value) !== false;
|
|
});
|
|
}
|
|
|
|
/*@
|
|
bindEvent <f> Adds event handler(s)
|
|
(callback) -> <o> This element
|
|
Adds a catch-all handler
|
|
(event, callback) -> <o> This element
|
|
Adds a handler for a single event
|
|
({event: callback, ...}) -> <o> This element
|
|
Adds handlers for one or more events
|
|
callback <f> Callback function
|
|
data <o> event data (key/value pairs)
|
|
event <s> Event name
|
|
Event names can be namespaced, like `'click.foo'`
|
|
@*/
|
|
that.bindEvent = function() {
|
|
Ox.Event.bind.apply(null, [self].concat(Ox.slice(arguments)));
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
bindEventOnce <f> Adds event handler(s) that run(s) only once
|
|
(callback) -> <o> This element
|
|
Adds a catch-all handler
|
|
(event, callback) -> <o> This element
|
|
Adds a handler for a single event
|
|
({event: callback, ...}) -> <o> This element
|
|
Adds handlers for one or more events
|
|
callback <f> Callback function
|
|
data <o> event data (key/value pairs)
|
|
event <s> Event name
|
|
Event names can be namespaced, like `'click.foo'`
|
|
@*/
|
|
that.bindEventOnce = function() {
|
|
Ox.Event.bindOnce.apply(null, [self].concat(Ox.slice(arguments)));
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
bindMessage <f> Adds message handlers (if the element is an iframe)
|
|
(callback) -> <o> This element
|
|
Adds a catch-all handler
|
|
(event, callback) -> <o> This element
|
|
Adds a handler for a single event
|
|
({event: callback, ...}) -> <o> This element
|
|
Adds handlers for on or more events
|
|
callback <f> Callback function
|
|
data <o> event data (key/value pairs)
|
|
event <s> Event name
|
|
@*/
|
|
that.bindMessage = that.onMessage = function() {
|
|
var callback;
|
|
if (self.options.element == '<iframe>') {
|
|
if (Ox.isObject(arguments[0])) {
|
|
Ox.forEach(arguments[0], function(callback, event) {
|
|
Ox.Message.bind(arguments[0], function(event_, data, oxid) {
|
|
if (event_ == event && oxid == that.oxid) {
|
|
callback(data || {});
|
|
}
|
|
});
|
|
});
|
|
} else {
|
|
callback = arguments[0];
|
|
Ox.Message.bind(function(event, data, oxid) {
|
|
if (that.oxid == oxid) {
|
|
callback(event, data || {});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return that;
|
|
};
|
|
|
|
that.bindMessageOnce = function() {
|
|
|
|
};
|
|
|
|
/*@
|
|
bindKeyboard <f> bind keyboard
|
|
() -> <o> object
|
|
@*/
|
|
that.bindKeyboard = function() {
|
|
Ox.Keyboard.bind(that.oxid);
|
|
return that;
|
|
};
|
|
|
|
that.childrenElements = function() {
|
|
return that.children().filter(Ox.UI.isOxElement).map(Ox.UI.getOxElement);
|
|
};
|
|
|
|
/*@
|
|
defaults <function> Gets or sets the default options for an element object
|
|
({key: value, ...}) -> <obj> This element object
|
|
key <str> The name of the default option
|
|
value <*> The value of the default option
|
|
@*/
|
|
that.defaults = function() {
|
|
var ret;
|
|
if (arguments.length == 0) {
|
|
ret = self.defaults;
|
|
} else if (Ox.isString(arguments[0])) {
|
|
ret = self.defaults[arguments[0]];
|
|
} else {
|
|
self.defaults = arguments[0];
|
|
self.options = Ox.clone(self.defaults);
|
|
ret = that;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
that.findElements = function() {
|
|
return Ox.map(that.find('.OxElement'), Ox.UI.getOxElement);
|
|
};
|
|
|
|
/*
|
|
that.forEach = function(f) {
|
|
// ...
|
|
return that;
|
|
};
|
|
*/
|
|
|
|
/*@
|
|
gainFocus <function> Makes an element object gain focus
|
|
() -> <obj> This element object
|
|
@*/
|
|
that.gainFocus = function() {
|
|
Ox.Focus.focus(that.oxid);
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
hasFocus <function> Returns true if an element object has focus
|
|
() -> <boolean> True if the element has focus
|
|
@*/
|
|
that.hasFocus = function() {
|
|
return Ox.Focus.focused() == that.oxid;
|
|
};
|
|
|
|
/*@
|
|
loseFocus <function> Makes an element object lose focus
|
|
() -> <object> This element object
|
|
@*/
|
|
that.loseFocus = function() {
|
|
Ox.Focus.blur(that.oxid);
|
|
return that;
|
|
};
|
|
|
|
that.nextElement = function() {
|
|
return that.nextElements()[0];
|
|
};
|
|
|
|
that.nextElements = function() {
|
|
return that.nextAll().filter(Ox.UI.isOxElement).map(Ox.UI.getOxElement);
|
|
};
|
|
|
|
/*@
|
|
options <f> Gets or sets the options of an element object
|
|
() -> <o> All options
|
|
(key) -> <*> The value of option[key]
|
|
(key, value) -> <o> This element
|
|
Sets options[key] to value and calls update(key, value)
|
|
if the key/value pair was added or modified
|
|
({key: value, ...}) -> <o> This element
|
|
Sets one or more options and calls update(key, value)
|
|
for every key/value pair that was added or modified
|
|
key <s> The name of the option
|
|
value <*> The value of the option
|
|
@*/
|
|
that.options = function() {
|
|
return Ox.getset(self.options, arguments, update, that);
|
|
};
|
|
|
|
that.parentElement = function() {
|
|
return Ox.last(that.parentElements());
|
|
};
|
|
|
|
that.parentElements = function() {
|
|
return that.parents().filter(Ox.UI.isOxElement).map(Ox.UI.getOxElement);
|
|
};
|
|
|
|
/*@
|
|
postMessage <f> Sends a message (if the element is an iframe)
|
|
(event, data) -> This element
|
|
event <s> Event name
|
|
data <o> Event data
|
|
@*/
|
|
that.postMessage = function(event, data) {
|
|
if (self.options.element == '<iframe>') {
|
|
Ox.Message.post(that, event, data);
|
|
}
|
|
return that;
|
|
};
|
|
|
|
that.prevElement = function() {
|
|
return Ox.last(that.prevElements());
|
|
};
|
|
|
|
that.prevElements = function() {
|
|
return that.prevAll().filter(Ox.UI.isOxElement).map(Ox.UI.getOxElement);
|
|
};
|
|
|
|
/*@
|
|
remove <f> Removes an element object and its event handler
|
|
() -> <o> This element
|
|
@*/
|
|
that.remove = function(remove) {
|
|
remove !== false && that.find('.OxElement').each(function() {
|
|
var element = Ox.UI.elements[$(this).data('oxid')];
|
|
element && element.remove(false);
|
|
});
|
|
Ox.Focus.remove(that.oxid);
|
|
Ox.Keyboard.unbind(that.oxid);
|
|
delete Ox.UI.elements[that.oxid];
|
|
that.$tooltip && that.$tooltip.remove();
|
|
remove !== false && that.$element.remove();
|
|
return that;
|
|
};
|
|
|
|
/*
|
|
that.remove = function() {
|
|
[that].concat(that.find('.OxElement'))
|
|
.map(Ox.UI.getOxElement).forEach(function($element) {
|
|
$element.removeElement();
|
|
});
|
|
that[0].parentNode.removeChild(this[0]);
|
|
return that;
|
|
}
|
|
|
|
that.removeElement = function() {
|
|
delete Ox.$elements[that.oxid];
|
|
Ox.Focus.remove(that);
|
|
self.unbindKeyboard();
|
|
return that;
|
|
};
|
|
*/
|
|
|
|
that.removeElement = function() {
|
|
// ...
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
setElement <f> set $element
|
|
($element) -> <o> This element
|
|
@*/
|
|
that.setElement = function($element) {
|
|
$element.addClass('OxElement').data({oxid: that.oxid});
|
|
that.$element.replaceWith($element);
|
|
that.$element = $element;
|
|
that[0] = $element[0];
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
toggleOption <f> Toggle boolean option(s)
|
|
(key[, key[, ...]]) -> <o> This element
|
|
@*/
|
|
that.toggleOption = function() {
|
|
var options = {};
|
|
Ox.slice(arguments).forEach(function(key) {
|
|
options[key] == !self.options[key];
|
|
});
|
|
that.options(options);
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
triggerEvent <f> Triggers one or more events
|
|
(event) -> <o> This element object
|
|
Triggers an event
|
|
(event, data) -> <o> This element object
|
|
Triggers an event with data
|
|
({event: data, ...}) -> <o> This element object
|
|
Triggers one or more events with data
|
|
event <string> Event name
|
|
data <object> Event data (key/value pairs)
|
|
@*/
|
|
that.triggerEvent = function() {
|
|
Ox.Event.trigger.apply(that, [self].concat(Ox.slice(arguments)));
|
|
return that;
|
|
};
|
|
|
|
that.triggerMessage = function() {
|
|
|
|
};
|
|
|
|
/*@
|
|
unbindEvent <f> Removes event handler(s)
|
|
() -> <o> This element
|
|
Removes all handlers.
|
|
(callback) -> <o> This element
|
|
Removes a specific catch-all handler
|
|
(event) -> <o> This element
|
|
Removes all handlers for a single event (to remove all catch-all
|
|
handlers, pass '*' as event)
|
|
(event, callback) -> <o> This element
|
|
Removes a specific handler for a single event
|
|
({event: callback}, ...) -> <o> This element
|
|
Removes specific handlers for one or more events
|
|
event <string> Event name
|
|
@*/
|
|
that.unbindEvent = function() {
|
|
Ox.Event.unbind.apply(null, [self].concat(Ox.slice(arguments)));
|
|
return that;
|
|
};
|
|
|
|
that.unbindMessage = function() {
|
|
|
|
};
|
|
|
|
/*@
|
|
unbindKeyboard <f> unbind keyboard
|
|
() -> <o> object
|
|
@*/
|
|
that.unbindKeyboard = function() {
|
|
Ox.Keyboard.unbind(that.oxid);
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
update <f> Adds one or more handlers for options updates
|
|
(callback) -> <o> that
|
|
(key, callback) -> <o> that
|
|
({key: callback, ...}) -> <o> that
|
|
@*/
|
|
that.update = function() {
|
|
var callbacks;
|
|
if (Ox.isFunction(arguments[0])) {
|
|
self.updateCallbacks.push(arguments[0]);
|
|
} else {
|
|
callbacks = Ox.makeObject(arguments);
|
|
self.updateCallbacks.push(function(key) {
|
|
if (callbacks[key]) {
|
|
return callbacks[key]();
|
|
}
|
|
});
|
|
}
|
|
return that;
|
|
};
|
|
|
|
/*@
|
|
value <f> Shortcut to get or set self.options.value
|
|
@*/
|
|
that.value = function() {
|
|
return that.options(
|
|
arguments.length == 0 ? 'value' : {value: arguments[0]}
|
|
);
|
|
};
|
|
|
|
that.update({tooltip: setTooltip});
|
|
|
|
return that;
|
|
|
|
};
|