Alice
view release on metacpan or search on metacpan
share/static/alice.js view on Meta::CPAN
var Class = (function() {
var IS_DONTENUM_BUGGY = (function(){
for (var p in { toString: 1 }) {
if (p === 'toString') return false;
}
return true;
})();
function subclass() {};
function create() {
var parent = null, properties = $A(arguments);
if (Object.isFunction(properties[0]))
parent = properties.shift();
function klass() {
this.initialize.apply(this, arguments);
}
Object.extend(klass, Class.Methods);
klass.superclass = parent;
klass.subclasses = [];
if (parent) {
subclass.prototype = parent.prototype;
klass.prototype = new subclass;
parent.subclasses.push(klass);
}
for (var i = 0, length = properties.length; i < length; i++)
klass.addMethods(properties[i]);
if (!klass.prototype.initialize)
klass.prototype.initialize = Prototype.emptyFunction;
klass.prototype.constructor = klass;
return klass;
}
function addMethods(source) {
var ancestor = this.superclass && this.superclass.prototype,
properties = Object.keys(source);
if (IS_DONTENUM_BUGGY) {
if (source.toString != Object.prototype.toString)
properties.push("toString");
if (source.valueOf != Object.prototype.valueOf)
properties.push("valueOf");
}
for (var i = 0, length = properties.length; i < length; i++) {
var property = properties[i], value = source[property];
if (ancestor && Object.isFunction(value) &&
value.argumentNames()[0] == "$super") {
var method = value;
value = (function(m) {
return function() { return ancestor[m].apply(this, arguments); };
})(property).wrap(method);
value.valueOf = method.valueOf.bind(method);
value.toString = method.toString.bind(method);
}
this.prototype[property] = value;
}
return this;
}
return {
create: create,
Methods: {
addMethods: addMethods
}
};
})();
(function() {
var _toString = Object.prototype.toString,
NULL_TYPE = 'Null',
UNDEFINED_TYPE = 'Undefined',
BOOLEAN_TYPE = 'Boolean',
NUMBER_TYPE = 'Number',
STRING_TYPE = 'String',
OBJECT_TYPE = 'Object',
FUNCTION_CLASS = '[object Function]',
BOOLEAN_CLASS = '[object Boolean]',
NUMBER_CLASS = '[object Number]',
STRING_CLASS = '[object String]',
ARRAY_CLASS = '[object Array]',
DATE_CLASS = '[object Date]',
NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON &&
typeof JSON.stringify === 'function' &&
JSON.stringify(0) === '0' &&
typeof JSON.stringify(Prototype.K) === 'undefined';
function Type(o) {
switch(o) {
case null: return NULL_TYPE;
case (void 0): return UNDEFINED_TYPE;
}
var type = typeof o;
switch(type) {
case 'boolean': return BOOLEAN_TYPE;
case 'number': return NUMBER_TYPE;
case 'string': return STRING_TYPE;
}
return OBJECT_TYPE;
}
function extend(destination, source) {
for (var property in source)
destination[property] = source[property];
return destination;
}
function inspect(object) {
try {
if (isUndefined(object)) return 'undefined';
if (object === null) return 'null';
return object.inspect ? object.inspect() : String(object);
} catch (e) {
share/static/alice.js view on Meta::CPAN
function isFunction(object) {
return _toString.call(object) === FUNCTION_CLASS;
}
function isString(object) {
return _toString.call(object) === STRING_CLASS;
}
function isNumber(object) {
return _toString.call(object) === NUMBER_CLASS;
}
function isDate(object) {
return _toString.call(object) === DATE_CLASS;
}
function isUndefined(object) {
return typeof object === "undefined";
}
extend(Object, {
extend: extend,
inspect: inspect,
toJSON: NATIVE_JSON_STRINGIFY_SUPPORT ? stringify : toJSON,
toQueryString: toQueryString,
toHTML: toHTML,
keys: Object.keys || keys,
values: values,
clone: clone,
isElement: isElement,
isArray: isArray,
isHash: isHash,
isFunction: isFunction,
isString: isString,
isNumber: isNumber,
isDate: isDate,
isUndefined: isUndefined
});
})();
Object.extend(Function.prototype, (function() {
var slice = Array.prototype.slice;
function update(array, args) {
var arrayLength = array.length, length = args.length;
while (length--) array[arrayLength + length] = args[length];
return array;
}
function merge(array, args) {
array = slice.call(array, 0);
return update(array, args);
}
function argumentNames() {
var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
.replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
.replace(/\s+/g, '').split(',');
return names.length == 1 && !names[0] ? [] : names;
}
function bind(context) {
if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
var __method = this, args = slice.call(arguments, 1);
return function() {
var a = merge(args, arguments);
return __method.apply(context, a);
}
}
function bindAsEventListener(context) {
var __method = this, args = slice.call(arguments, 1);
return function(event) {
var a = update([event || window.event], args);
return __method.apply(context, a);
}
}
function curry() {
if (!arguments.length) return this;
var __method = this, args = slice.call(arguments, 0);
return function() {
var a = merge(args, arguments);
return __method.apply(this, a);
}
}
function delay(timeout) {
var __method = this, args = slice.call(arguments, 1);
timeout = timeout * 1000;
return window.setTimeout(function() {
return __method.apply(__method, args);
}, timeout);
}
function defer() {
var args = update([0.01], arguments);
return this.delay.apply(this, args);
}
function wrap(wrapper) {
var __method = this;
return function() {
var a = update([__method.bind(this)], arguments);
return wrapper.apply(this, a);
}
}
function methodize() {
if (this._methodized) return this._methodized;
var __method = this;
return this._methodized = function() {
var a = update([this], arguments);
return __method.apply(null, a);
};
}
return {
argumentNames: argumentNames,
bind: bind,
bindAsEventListener: bindAsEventListener,
curry: curry,
delay: delay,
defer: defer,
wrap: wrap,
methodize: methodize
}
})());
(function(proto) {
function toISOString() {
return this.getUTCFullYear() + '-' +
(this.getUTCMonth() + 1).toPaddedString(2) + '-' +
this.getUTCDate().toPaddedString(2) + 'T' +
this.getUTCHours().toPaddedString(2) + ':' +
this.getUTCMinutes().toPaddedString(2) + ':' +
this.getUTCSeconds().toPaddedString(2) + 'Z';
}
function toJSON() {
return this.toISOString();
}
if (!proto.toISOString) proto.toISOString = toISOString;
if (!proto.toJSON) proto.toJSON = toJSON;
})(Date.prototype);
RegExp.prototype.match = RegExp.prototype.test;
RegExp.escape = function(str) {
return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};
var PeriodicalExecuter = Class.create({
initialize: function(callback, frequency) {
this.callback = callback;
this.frequency = frequency;
this.currentlyExecuting = false;
this.registerCallback();
},
registerCallback: function() {
this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
},
execute: function() {
this.callback(this);
},
stop: function() {
if (!this.timer) return;
clearInterval(this.timer);
this.timer = null;
},
onTimerEvent: function() {
if (!this.currentlyExecuting) {
try {
this.currentlyExecuting = true;
this.execute();
this.currentlyExecuting = false;
} catch(e) {
this.currentlyExecuting = false;
throw e;
}
}
}
});
Object.extend(String, {
interpret: function(value) {
return value == null ? '' : String(value);
},
specialChar: {
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'\\': '\\\\'
}
});
Object.extend(String.prototype, (function() {
var NATIVE_JSON_PARSE_SUPPORT = window.JSON &&
typeof JSON.parse === 'function' &&
JSON.parse('{"test": true}').test;
function prepareReplacement(replacement) {
if (Object.isFunction(replacement)) return replacement;
var template = new Template(replacement);
return function(match) { return template.evaluate(match) };
}
function gsub(pattern, replacement) {
var result = '', source = this, match;
replacement = prepareReplacement(replacement);
if (Object.isString(pattern))
pattern = RegExp.escape(pattern);
if (!(pattern.length || pattern.source)) {
replacement = replacement('');
return replacement + source.split('').join(replacement) + replacement;
share/static/alice.js view on Meta::CPAN
Object.extend(Ajax.Responders, Enumerable);
Ajax.Responders.register({
onCreate: function() { Ajax.activeRequestCount++ },
onComplete: function() { Ajax.activeRequestCount-- }
});
Ajax.Base = Class.create({
initialize: function(options) {
this.options = {
method: 'post',
asynchronous: true,
contentType: 'application/x-www-form-urlencoded',
encoding: 'UTF-8',
parameters: '',
evalJSON: true,
evalJS: true
};
Object.extend(this.options, options || { });
this.options.method = this.options.method.toLowerCase();
if (Object.isHash(this.options.parameters))
this.options.parameters = this.options.parameters.toObject();
}
});
Ajax.Request = Class.create(Ajax.Base, {
_complete: false,
initialize: function($super, url, options) {
$super(options);
this.transport = Ajax.getTransport();
this.request(url);
},
request: function(url) {
this.url = url;
this.method = this.options.method;
var params = Object.isString(this.options.parameters) ?
this.options.parameters :
Object.toQueryString(this.options.parameters);
if (!['get', 'post'].include(this.method)) {
params += (params ? '&' : '') + "_method=" + this.method;
this.method = 'post';
}
if (params && this.method === 'get') {
this.url += (this.url.include('?') ? '&' : '?') + params;
}
this.parameters = params.toQueryParams();
try {
var response = new Ajax.Response(this);
if (this.options.onCreate) this.options.onCreate(response);
Ajax.Responders.dispatch('onCreate', this, response);
this.transport.open(this.method.toUpperCase(), this.url,
this.options.asynchronous);
if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);
this.transport.onreadystatechange = this.onStateChange.bind(this);
this.setRequestHeaders();
this.body = this.method == 'post' ? (this.options.postBody || params) : null;
this.transport.send(this.body);
/* Force Firefox to handle ready state 4 for synchronous requests */
if (!this.options.asynchronous && this.transport.overrideMimeType)
this.onStateChange();
}
catch (e) {
this.dispatchException(e);
}
},
onStateChange: function() {
var readyState = this.transport.readyState;
if (readyState > 1 && !((readyState == 4) && this._complete))
this.respondToReadyState(this.transport.readyState);
},
setRequestHeaders: function() {
var headers = {
'X-Requested-With': 'XMLHttpRequest',
'X-Prototype-Version': Prototype.Version,
'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
};
if (this.method == 'post') {
headers['Content-type'] = this.options.contentType +
(this.options.encoding ? '; charset=' + this.options.encoding : '');
/* Force "Connection: close" for older Mozilla browsers to work
* around a bug where XMLHttpRequest sends an incorrect
* Content-length header. See Mozilla Bugzilla #246651.
*/
if (this.transport.overrideMimeType &&
(navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
headers['Connection'] = 'close';
}
if (typeof this.options.requestHeaders == 'object') {
var extras = this.options.requestHeaders;
if (Object.isFunction(extras.push))
for (var i = 0, length = extras.length; i < length; i += 2)
headers[extras[i]] = extras[i+1];
else
$H(extras).each(function(pair) { headers[pair.key] = pair.value });
}
for (var name in headers)
this.transport.setRequestHeader(name, headers[name]);
},
success: function() {
var status = this.getStatus();
return !status || (status >= 200 && status < 300) || status == 304;
},
share/static/alice.js view on Meta::CPAN
try {
return this.transport.statusText || '';
} catch (e) { return '' }
},
getHeader: Ajax.Request.prototype.getHeader,
getAllHeaders: function() {
try {
return this.getAllResponseHeaders();
} catch (e) { return null }
},
getResponseHeader: function(name) {
return this.transport.getResponseHeader(name);
},
getAllResponseHeaders: function() {
return this.transport.getAllResponseHeaders();
},
_getHeaderJSON: function() {
var json = this.getHeader('X-JSON');
if (!json) return null;
json = decodeURIComponent(escape(json));
try {
return json.evalJSON(this.request.options.sanitizeJSON ||
!this.request.isSameOrigin());
} catch (e) {
this.request.dispatchException(e);
}
},
_getResponseJSON: function() {
var options = this.request.options;
if (!options.evalJSON || (options.evalJSON != 'force' &&
!(this.getHeader('Content-type') || '').include('application/json')) ||
this.responseText.blank())
return null;
try {
return this.responseText.evalJSON(options.sanitizeJSON ||
!this.request.isSameOrigin());
} catch (e) {
this.request.dispatchException(e);
}
}
});
Ajax.Updater = Class.create(Ajax.Request, {
initialize: function($super, container, url, options) {
this.container = {
success: (container.success || container),
failure: (container.failure || (container.success ? null : container))
};
options = Object.clone(options);
var onComplete = options.onComplete;
options.onComplete = (function(response, json) {
this.updateContent(response.responseText);
if (Object.isFunction(onComplete)) onComplete(response, json);
}).bind(this);
$super(url, options);
},
updateContent: function(responseText) {
var receiver = this.container[this.success() ? 'success' : 'failure'],
options = this.options;
if (!options.evalScripts) responseText = responseText.stripScripts();
if (receiver = $(receiver)) {
if (options.insertion) {
if (Object.isString(options.insertion)) {
var insertion = { }; insertion[options.insertion] = responseText;
receiver.insert(insertion);
}
else options.insertion(receiver, responseText);
}
else receiver.update(responseText);
}
}
});
Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
initialize: function($super, container, url, options) {
$super(options);
this.onComplete = this.options.onComplete;
this.frequency = (this.options.frequency || 2);
this.decay = (this.options.decay || 1);
this.updater = { };
this.container = container;
this.url = url;
this.start();
},
start: function() {
this.options.onComplete = this.updateComplete.bind(this);
this.onTimerEvent();
},
stop: function() {
this.updater.options.onComplete = undefined;
clearTimeout(this.timer);
(this.onComplete || Prototype.emptyFunction).apply(this, arguments);
},
updateComplete: function(response) {
if (this.options.decay) {
this.decay = (response.responseText == this.lastText ?
this.decay * this.options.decay : 1);
this.lastText = response.responseText;
}
this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
},
onTimerEvent: function() {
this.updater = new Ajax.Updater(this.container, this.url, this.options);
}
});
function $(element) {
if (arguments.length > 1) {
for (var i = 0, elements = [], length = arguments.length; i < length; i++)
elements.push($(arguments[i]));
return elements;
}
if (Object.isString(element))
element = document.getElementById(element);
return Element.extend(element);
}
if (Prototype.BrowserFeatures.XPath) {
document._getElementsByXPath = function(expression, parentElement) {
var results = [];
var query = document.evaluate(expression, $(parentElement) || document,
null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
for (var i = 0, length = query.snapshotLength; i < length; i++)
results.push(Element.extend(query.snapshotItem(i)));
return results;
};
}
/*--------------------------------------------------------------------------*/
if (!Node) var Node = { };
if (!Node.ELEMENT_NODE) {
Object.extend(Node, {
ELEMENT_NODE: 1,
ATTRIBUTE_NODE: 2,
TEXT_NODE: 3,
CDATA_SECTION_NODE: 4,
ENTITY_REFERENCE_NODE: 5,
ENTITY_NODE: 6,
PROCESSING_INSTRUCTION_NODE: 7,
COMMENT_NODE: 8,
DOCUMENT_NODE: 9,
DOCUMENT_TYPE_NODE: 10,
DOCUMENT_FRAGMENT_NODE: 11,
NOTATION_NODE: 12
});
}
(function(global) {
function shouldUseCache(tagName, attributes) {
if (tagName === 'select') return false;
if ('type' in attributes) return false;
return true;
}
share/static/alice.js view on Meta::CPAN
isBuggy = false;
try {
s.appendChild(document.createTextNode(""));
isBuggy = !s.firstChild ||
s.firstChild && s.firstChild.nodeType !== 3;
} catch (e) {
isBuggy = true;
}
s = null;
return isBuggy;
})();
function update(element, content) {
element = $(element);
var purgeElement = Element._purgeElement;
var descendants = element.getElementsByTagName('*'),
i = descendants.length;
while (i--) purgeElement(descendants[i]);
if (content && content.toElement)
content = content.toElement();
if (Object.isElement(content))
return element.update().insert(content);
content = Object.toHTML(content);
var tagName = element.tagName.toUpperCase();
if (tagName === 'SCRIPT' && SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING) {
element.text = content;
return element;
}
if (ANY_INNERHTML_BUGGY) {
if (tagName in Element._insertionTranslations.tags) {
while (element.firstChild) {
element.removeChild(element.firstChild);
}
Element._getContentFromAnonymousElement(tagName, content.stripScripts())
.each(function(node) {
element.appendChild(node)
});
} else if (LINK_ELEMENT_INNERHTML_BUGGY && Object.isString(content) && content.indexOf('<link') > -1) {
while (element.firstChild) {
element.removeChild(element.firstChild);
}
var nodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts(), true);
nodes.each(function(node) { element.appendChild(node) });
}
else {
element.innerHTML = content.stripScripts();
}
}
else {
element.innerHTML = content.stripScripts();
}
content.evalScripts.bind(content).defer();
return element;
}
return update;
})(),
replace: function(element, content) {
element = $(element);
if (content && content.toElement) content = content.toElement();
else if (!Object.isElement(content)) {
content = Object.toHTML(content);
var range = element.ownerDocument.createRange();
range.selectNode(element);
content.evalScripts.bind(content).defer();
content = range.createContextualFragment(content.stripScripts());
}
element.parentNode.replaceChild(content, element);
return element;
},
insert: function(element, insertions) {
element = $(element);
if (Object.isString(insertions) || Object.isNumber(insertions) ||
Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
insertions = {bottom:insertions};
var content, insert, tagName, childNodes;
for (var position in insertions) {
content = insertions[position];
position = position.toLowerCase();
insert = Element._insertionTranslations[position];
if (content && content.toElement) content = content.toElement();
if (Object.isElement(content)) {
insert(element, content);
continue;
}
content = Object.toHTML(content);
tagName = ((position == 'before' || position == 'after')
? element.parentNode : element).tagName.toUpperCase();
childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
if (position == 'top' || position == 'after') childNodes.reverse();
childNodes.each(insert.curry(element));
content.evalScripts.bind(content).defer();
}
return element;
},
wrap: function(element, wrapper, attributes) {
element = $(element);
if (Object.isElement(wrapper))
$(wrapper).writeAttribute(attributes || { });
else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
else wrapper = new Element('div', wrapper);
if (element.parentNode)
element.parentNode.replaceChild(wrapper, element);
wrapper.appendChild(element);
return wrapper;
},
inspect: function(element) {
element = $(element);
var result = '<' + element.tagName.toLowerCase();
$H({'id': 'id', 'className': 'class'}).each(function(pair) {
var property = pair.first(),
attribute = pair.last(),
value = (element[property] || '').toString();
if (value) result += ' ' + attribute + '=' + value.inspect(true);
});
return result + '>';
},
recursivelyCollect: function(element, property, maximumLength) {
element = $(element);
maximumLength = maximumLength || -1;
var elements = [];
while (element = element[property]) {
if (element.nodeType == 1)
elements.push(Element.extend(element));
if (elements.length == maximumLength)
break;
}
return elements;
},
ancestors: function(element) {
return Element.recursivelyCollect(element, 'parentNode');
},
descendants: function(element) {
return Element.select(element, "*");
},
firstDescendant: function(element) {
element = $(element).firstChild;
while (element && element.nodeType != 1) element = element.nextSibling;
return $(element);
},
immediateDescendants: function(element) {
var results = [], child = $(element).firstChild;
share/static/alice.js view on Meta::CPAN
return Object.isNumber(expression) ? _descendants(element)[expression] :
Element.select(element, expression)[index || 0];
}
})();
}
}
else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
Element.Methods.setOpacity = function(element, value) {
element = $(element);
element.style.opacity = (value == 1) ? 0.999999 :
(value === '') ? '' : (value < 0.00001) ? 0 : value;
return element;
};
}
else if (Prototype.Browser.WebKit) {
Element.Methods.setOpacity = function(element, value) {
element = $(element);
element.style.opacity = (value == 1 || value === '') ? '' :
(value < 0.00001) ? 0 : value;
if (value == 1)
if (element.tagName.toUpperCase() == 'IMG' && element.width) {
element.width++; element.width--;
} else try {
var n = document.createTextNode(' ');
element.appendChild(n);
element.removeChild(n);
} catch (e) { }
return element;
};
}
if ('outerHTML' in document.documentElement) {
Element.Methods.replace = function(element, content) {
element = $(element);
if (content && content.toElement) content = content.toElement();
if (Object.isElement(content)) {
element.parentNode.replaceChild(content, element);
return element;
}
content = Object.toHTML(content);
var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
if (Element._insertionTranslations.tags[tagName]) {
var nextSibling = element.next(),
fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
parent.removeChild(element);
if (nextSibling)
fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
else
fragments.each(function(node) { parent.appendChild(node) });
}
else element.outerHTML = content.stripScripts();
content.evalScripts.bind(content).defer();
return element;
};
}
Element._returnOffset = function(l, t) {
var result = [l, t];
result.left = l;
result.top = t;
return result;
};
Element._getContentFromAnonymousElement = function(tagName, html, force) {
var div = new Element('div'),
t = Element._insertionTranslations.tags[tagName];
var workaround = false;
if (t) workaround = true;
else if (force) {
workaround = true;
t = ['', '', 0];
}
if (workaround) {
div.innerHTML = ' ' + t[0] + html + t[1];
div.removeChild(div.firstChild);
for (var i = t[2]; i--; ) {
div = div.firstChild;
}
}
else {
div.innerHTML = html;
}
return $A(div.childNodes);
};
Element._insertionTranslations = {
before: function(element, node) {
element.parentNode.insertBefore(node, element);
},
top: function(element, node) {
element.insertBefore(node, element.firstChild);
},
bottom: function(element, node) {
element.appendChild(node);
},
after: function(element, node) {
element.parentNode.insertBefore(node, element.nextSibling);
},
tags: {
TABLE: ['<table>', '</table>', 1],
TBODY: ['<table><tbody>', '</tbody></table>', 2],
TR: ['<table><tbody><tr>', '</tr></tbody></table>', 3],
TD: ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
SELECT: ['<select>', '</select>', 1]
}
};
(function() {
var tags = Element._insertionTranslations.tags;
Object.extend(tags, {
share/static/alice.js view on Meta::CPAN
Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
initialize: function($super, element, frequency, callback) {
$super(callback, frequency);
this.element = $(element);
this.lastValue = this.getValue();
},
execute: function() {
var value = this.getValue();
if (Object.isString(this.lastValue) && Object.isString(value) ?
this.lastValue != value : String(this.lastValue) != String(value)) {
this.callback(this.element, value);
this.lastValue = value;
}
}
});
Form.Element.Observer = Class.create(Abstract.TimedObserver, {
getValue: function() {
return Form.Element.getValue(this.element);
}
});
Form.Observer = Class.create(Abstract.TimedObserver, {
getValue: function() {
return Form.serialize(this.element);
}
});
/*--------------------------------------------------------------------------*/
Abstract.EventObserver = Class.create({
initialize: function(element, callback) {
this.element = $(element);
this.callback = callback;
this.lastValue = this.getValue();
if (this.element.tagName.toLowerCase() == 'form')
this.registerFormCallbacks();
else
this.registerCallback(this.element);
},
onElementEvent: function() {
var value = this.getValue();
if (this.lastValue != value) {
this.callback(this.element, value);
this.lastValue = value;
}
},
registerFormCallbacks: function() {
Form.getElements(this.element).each(this.registerCallback, this);
},
registerCallback: function(element) {
if (element.type) {
switch (element.type.toLowerCase()) {
case 'checkbox':
case 'radio':
Event.observe(element, 'click', this.onElementEvent.bind(this));
break;
default:
Event.observe(element, 'change', this.onElementEvent.bind(this));
break;
}
}
}
});
Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
getValue: function() {
return Form.Element.getValue(this.element);
}
});
Form.EventObserver = Class.create(Abstract.EventObserver, {
getValue: function() {
return Form.serialize(this.element);
}
});
(function() {
var Event = {
KEY_BACKSPACE: 8,
KEY_TAB: 9,
KEY_RETURN: 13,
KEY_ESC: 27,
KEY_LEFT: 37,
KEY_UP: 38,
KEY_RIGHT: 39,
KEY_DOWN: 40,
KEY_DELETE: 46,
KEY_HOME: 36,
KEY_END: 35,
KEY_PAGEUP: 33,
KEY_PAGEDOWN: 34,
KEY_INSERT: 45,
cache: {}
};
var docEl = document.documentElement;
var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl
&& 'onmouseleave' in docEl;
var isIELegacyEvent = function(event) { return false; };
if (window.attachEvent) {
if (window.addEventListener) {
isIELegacyEvent = function(event) {
return !(event instanceof window.Event);
};
} else {
isIELegacyEvent = function(event) { return true; };
}
}
var _isButton;
function _isButtonForDOMEvents(event, code) {
return event.which ? (event.which === code + 1) : (event.button === code);
share/static/alice.js view on Meta::CPAN
break;
}
}
if (!responder) return element;
if (eventName.include(':')) {
if (element.removeEventListener)
element.removeEventListener("dataavailable", responder, false);
else {
element.detachEvent("ondataavailable", responder);
element.detachEvent("onlosecapture", responder);
}
} else {
var actualEventName = _getDOMEventName(eventName);
if (element.removeEventListener)
element.removeEventListener(actualEventName, responder, false);
else
element.detachEvent('on' + actualEventName, responder);
}
registry.set(eventName, responders.without(responder));
return element;
}
function fire(element, eventName, memo, bubble) {
element = $(element);
if (Object.isUndefined(bubble))
bubble = true;
if (element == document && document.createEvent && !element.dispatchEvent)
element = document.documentElement;
var event;
if (document.createEvent) {
event = document.createEvent('HTMLEvents');
event.initEvent('dataavailable', bubble, true);
} else {
event = document.createEventObject();
event.eventType = bubble ? 'ondataavailable' : 'onlosecapture';
}
event.eventName = eventName;
event.memo = memo || { };
if (document.createEvent)
element.dispatchEvent(event);
else
element.fireEvent(event.eventType, event);
return Event.extend(event);
}
Event.Handler = Class.create({
initialize: function(element, eventName, selector, callback) {
this.element = $(element);
this.eventName = eventName;
this.selector = selector;
this.callback = callback;
this.handler = this.handleEvent.bind(this);
},
start: function() {
Event.observe(this.element, this.eventName, this.handler);
return this;
},
stop: function() {
Event.stopObserving(this.element, this.eventName, this.handler);
return this;
},
handleEvent: function(event) {
var element = Event.findElement(event, this.selector);
if (element) this.callback.call(this.element, event, element);
}
});
function on(element, eventName, selector, callback) {
element = $(element);
if (Object.isFunction(selector) && Object.isUndefined(callback)) {
callback = selector, selector = null;
}
return new Event.Handler(element, eventName, selector, callback).start();
}
Object.extend(Event, Event.Methods);
Object.extend(Event, {
fire: fire,
observe: observe,
stopObserving: stopObserving,
on: on
});
Element.addMethods({
fire: fire,
observe: observe,
stopObserving: stopObserving,
on: on
});
Object.extend(document, {
fire: fire.methodize(),
observe: observe.methodize(),
stopObserving: stopObserving.methodize(),
on: on.methodize(),
loaded: false
});
if (window.Event) Object.extend(window.Event, Event);
else window.Event = Event;
share/static/alice.js view on Meta::CPAN
$A(elements).each( function(element, index) {
new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
});
},
PAIRS: {
'slide': ['SlideDown','SlideUp'],
'blind': ['BlindDown','BlindUp'],
'appear': ['Appear','Fade']
},
toggle: function(element, effect, options) {
element = $(element);
effect = (effect || 'appear').toLowerCase();
return Effect[ Effect.PAIRS[ effect ][ element.visible() ? 1 : 0 ] ](element, Object.extend({
queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
}, options || {}));
}
};
Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;
/* ------------- core effects ------------- */
Effect.ScopedQueue = Class.create(Enumerable, {
initialize: function() {
this.effects = [];
this.interval = null;
},
_each: function(iterator) {
this.effects._each(iterator);
},
add: function(effect) {
var timestamp = new Date().getTime();
var position = Object.isString(effect.options.queue) ?
effect.options.queue : effect.options.queue.position;
switch(position) {
case 'front':
this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
e.startOn += effect.finishOn;
e.finishOn += effect.finishOn;
});
break;
case 'with-last':
timestamp = this.effects.pluck('startOn').max() || timestamp;
break;
case 'end':
timestamp = this.effects.pluck('finishOn').max() || timestamp;
break;
}
effect.startOn += timestamp;
effect.finishOn += timestamp;
if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
this.effects.push(effect);
if (!this.interval)
this.interval = setInterval(this.loop.bind(this), 15);
},
remove: function(effect) {
this.effects = this.effects.reject(function(e) { return e==effect });
if (this.effects.length == 0) {
clearInterval(this.interval);
this.interval = null;
}
},
loop: function() {
var timePos = new Date().getTime();
for(var i=0, len=this.effects.length;i<len;i++)
this.effects[i] && this.effects[i].loop(timePos);
}
});
Effect.Queues = {
instances: $H(),
get: function(queueName) {
if (!Object.isString(queueName)) return queueName;
return this.instances.get(queueName) ||
this.instances.set(queueName, new Effect.ScopedQueue());
}
};
Effect.Queue = Effect.Queues.get('global');
Effect.Base = Class.create({
position: null,
start: function(options) {
if (options && options.transition === false) options.transition = Effect.Transitions.linear;
this.options = Object.extend(Object.extend({ },Effect.DefaultOptions), options || { });
this.currentFrame = 0;
this.state = 'idle';
this.startOn = this.options.delay*1000;
this.finishOn = this.startOn+(this.options.duration*1000);
this.fromToDelta = this.options.to-this.options.from;
this.totalTime = this.finishOn-this.startOn;
this.totalFrames = this.options.fps*this.options.duration;
this.render = (function() {
function dispatch(effect, eventName) {
if (effect.options[eventName + 'Internal'])
effect.options[eventName + 'Internal'](effect);
if (effect.options[eventName])
effect.options[eventName](effect);
}
return function(pos) {
if (this.state === "idle") {
this.state = "running";
dispatch(this, 'beforeSetup');
if (this.setup) this.setup();
dispatch(this, 'afterSetup');
}
if (this.state === "running") {
pos = (this.options.transition(pos) * this.fromToDelta) + this.options.from;
this.position = pos;
dispatch(this, 'beforeUpdate');
if (this.update) this.update(pos);
dispatch(this, 'afterUpdate');
share/static/alice.js view on Meta::CPAN
loop: function(timePos) {
if (timePos >= this.startOn) {
if (timePos >= this.finishOn) {
this.render(1.0);
this.cancel();
this.event('beforeFinish');
if (this.finish) this.finish();
this.event('afterFinish');
return;
}
var pos = (timePos - this.startOn) / this.totalTime,
frame = (pos * this.totalFrames).round();
if (frame > this.currentFrame) {
this.render(pos);
this.currentFrame = frame;
}
}
},
cancel: function() {
if (!this.options.sync)
Effect.Queues.get(Object.isString(this.options.queue) ?
'global' : this.options.queue.scope).remove(this);
this.state = 'finished';
},
event: function(eventName) {
if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
if (this.options[eventName]) this.options[eventName](this);
},
inspect: function() {
var data = $H();
for(property in this)
if (!Object.isFunction(this[property])) data.set(property, this[property]);
return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
}
});
Effect.Parallel = Class.create(Effect.Base, {
initialize: function(effects) {
this.effects = effects || [];
this.start(arguments[1]);
},
update: function(position) {
this.effects.invoke('render', position);
},
finish: function(position) {
this.effects.each( function(effect) {
effect.render(1.0);
effect.cancel();
effect.event('beforeFinish');
if (effect.finish) effect.finish(position);
effect.event('afterFinish');
});
}
});
Effect.Tween = Class.create(Effect.Base, {
initialize: function(object, from, to) {
object = Object.isString(object) ? $(object) : object;
var args = $A(arguments), method = args.last(),
options = args.length == 5 ? args[3] : null;
this.method = Object.isFunction(method) ? method.bind(object) :
Object.isFunction(object[method]) ? object[method].bind(object) :
function(value) { object[method] = value };
this.start(Object.extend({ from: from, to: to }, options || { }));
},
update: function(position) {
this.method(position);
}
});
Effect.Event = Class.create(Effect.Base, {
initialize: function() {
this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
},
update: Prototype.emptyFunction
});
Effect.Opacity = Class.create(Effect.Base, {
initialize: function(element) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
this.element.setStyle({zoom: 1});
var options = Object.extend({
from: this.element.getOpacity() || 0.0,
to: 1.0
}, arguments[1] || { });
this.start(options);
},
update: function(position) {
this.element.setOpacity(position);
}
});
Effect.Move = Class.create(Effect.Base, {
initialize: function(element) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({
x: 0,
y: 0,
mode: 'relative'
}, arguments[1] || { });
this.start(options);
},
setup: function() {
this.element.makePositioned();
this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
this.originalTop = parseFloat(this.element.getStyle('top') || '0');
if (this.options.mode == 'absolute') {
this.options.x = this.options.x - this.originalLeft;
this.options.y = this.options.y - this.originalTop;
}
},
update: function(position) {
this.element.setStyle({
left: (this.options.x * position + this.originalLeft).round() + 'px',
top: (this.options.y * position + this.originalTop).round() + 'px'
});
}
});
Effect.MoveBy = function(element, toTop, toLeft) {
return new Effect.Move(element,
Object.extend({ x: toLeft, y: toTop }, arguments[3] || { }));
};
Effect.Scale = Class.create(Effect.Base, {
initialize: function(element, percent) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({
scaleX: true,
scaleY: true,
scaleContent: true,
scaleFromCenter: false,
scaleMode: 'box', // 'box' or 'contents' or { } with provided values
scaleFrom: 100.0,
scaleTo: percent
}, arguments[2] || { });
this.start(options);
},
setup: function() {
this.restoreAfterFinish = this.options.restoreAfterFinish || false;
this.elementPositioning = this.element.getStyle('position');
this.originalStyle = { };
['top','left','width','height','fontSize'].each( function(k) {
this.originalStyle[k] = this.element.style[k];
}.bind(this));
this.originalTop = this.element.offsetTop;
this.originalLeft = this.element.offsetLeft;
var fontSize = this.element.getStyle('font-size') || '100%';
['em','px','%','pt'].each( function(fontSizeType) {
if (fontSize.indexOf(fontSizeType)>0) {
this.fontSize = parseFloat(fontSize);
this.fontSizeType = fontSizeType;
}
}.bind(this));
this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
this.dims = null;
if (this.options.scaleMode=='box')
this.dims = [this.element.offsetHeight, this.element.offsetWidth];
if (/^content/.test(this.options.scaleMode))
this.dims = [this.element.scrollHeight, this.element.scrollWidth];
if (!this.dims)
this.dims = [this.options.scaleMode.originalHeight,
this.options.scaleMode.originalWidth];
},
update: function(position) {
var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
if (this.options.scaleContent && this.fontSize)
this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
},
finish: function(position) {
if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
},
setDimensions: function(height, width) {
var d = { };
if (this.options.scaleX) d.width = width.round() + 'px';
if (this.options.scaleY) d.height = height.round() + 'px';
if (this.options.scaleFromCenter) {
var topd = (height - this.dims[0])/2;
var leftd = (width - this.dims[1])/2;
if (this.elementPositioning == 'absolute') {
if (this.options.scaleY) d.top = this.originalTop-topd + 'px';
if (this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
} else {
if (this.options.scaleY) d.top = -topd + 'px';
if (this.options.scaleX) d.left = -leftd + 'px';
}
}
this.element.setStyle(d);
}
});
Effect.Highlight = Class.create(Effect.Base, {
initialize: function(element) {
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || { });
this.start(options);
},
setup: function() {
if (this.element.getStyle('display')=='none') { this.cancel(); return; }
this.oldStyle = { };
if (!this.options.keepBackgroundImage) {
this.oldStyle.backgroundImage = this.element.getStyle('background-image');
this.element.setStyle({backgroundImage: 'none'});
}
if (!this.options.endcolor)
this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
if (!this.options.restorecolor)
this.options.restorecolor = this.element.getStyle('background-color');
this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
},
update: function(position) {
this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
},
finish: function() {
this.element.setStyle(Object.extend(this.oldStyle, {
backgroundColor: this.options.restorecolor
}));
}
});
Effect.ScrollTo = function(element) {
var options = arguments[1] || { },
scrollOffsets = document.viewport.getScrollOffsets(),
elementOffsets = $(element).cumulativeOffset();
if (options.offset) elementOffsets[1] += options.offset;
return new Effect.Tween(null,
scrollOffsets.top,
elementOffsets[1],
options,
function(p){ scrollTo(scrollOffsets.left, p.round()); }
);
};
/* ------------- combination effects ------------- */
Effect.Fade = function(element) {
element = $(element);
var oldOpacity = element.getInlineOpacity();
var options = Object.extend({
from: element.getOpacity() || 1.0,
to: 0.0,
afterFinishInternal: function(effect) {
if (effect.options.to!=0) return;
effect.element.hide().setStyle({opacity: oldOpacity});
}
}, arguments[1] || { });
return new Effect.Opacity(element,options);
};
Effect.Appear = function(element) {
element = $(element);
var options = Object.extend({
from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
to: 1.0,
afterFinishInternal: function(effect) {
effect.element.forceRerendering();
},
beforeSetup: function(effect) {
effect.element.setOpacity(effect.options.from).show();
}}, arguments[1] || { });
return new Effect.Opacity(element,options);
};
Effect.Puff = function(element) {
element = $(element);
var oldStyle = {
opacity: element.getInlineOpacity(),
position: element.getStyle('position'),
top: element.style.top,
left: element.style.left,
share/static/alice.js view on Meta::CPAN
this.element = $(element);
if (!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({
style: { }
}, arguments[1] || { });
if (!Object.isString(options.style)) this.style = $H(options.style);
else {
if (options.style.include(':'))
this.style = options.style.parseStyle();
else {
this.element.addClassName(options.style);
this.style = $H(this.element.getStyles());
this.element.removeClassName(options.style);
var css = this.element.getStyles();
this.style = this.style.reject(function(style) {
return style.value == css[style.key];
});
options.afterFinishInternal = function(effect) {
effect.element.addClassName(effect.options.style);
effect.transforms.each(function(transform) {
effect.element.style[transform.style] = '';
});
};
}
}
this.start(options);
},
setup: function(){
function parseColor(color){
if (!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
color = color.parseColor();
return $R(0,2).map(function(i){
return parseInt( color.slice(i*2+1,i*2+3), 16 );
});
}
this.transforms = this.style.map(function(pair){
var property = pair[0], value = pair[1], unit = null;
if (value.parseColor('#zzzzzz') != '#zzzzzz') {
value = value.parseColor();
unit = 'color';
} else if (property == 'opacity') {
value = parseFloat(value);
if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
this.element.setStyle({zoom: 1});
} else if (Element.CSS_LENGTH.test(value)) {
var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
value = parseFloat(components[1]);
unit = (components.length == 3) ? components[2] : null;
}
var originalValue = this.element.getStyle(property);
return {
style: property.camelize(),
originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0),
targetValue: unit=='color' ? parseColor(value) : value,
unit: unit
};
}.bind(this)).reject(function(transform){
return (
(transform.originalValue == transform.targetValue) ||
(
transform.unit != 'color' &&
(isNaN(transform.originalValue) || isNaN(transform.targetValue))
)
);
});
},
update: function(position) {
var style = { }, transform, i = this.transforms.length;
while(i--)
style[(transform = this.transforms[i]).style] =
transform.unit=='color' ? '#'+
(Math.round(transform.originalValue[0]+
(transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
(Math.round(transform.originalValue[1]+
(transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
(Math.round(transform.originalValue[2]+
(transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
(transform.originalValue +
(transform.targetValue - transform.originalValue) * position).toFixed(3) +
(transform.unit === null ? '' : transform.unit);
this.element.setStyle(style, true);
}
});
Effect.Transform = Class.create({
initialize: function(tracks){
this.tracks = [];
this.options = arguments[1] || { };
this.addTracks(tracks);
},
addTracks: function(tracks){
tracks.each(function(track){
track = $H(track);
var data = track.values().first();
this.tracks.push($H({
ids: track.keys().first(),
effect: Effect.Morph,
options: { style: data }
}));
}.bind(this));
return this;
},
play: function(){
return new Effect.Parallel(
this.tracks.map(function(track){
var ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
var elements = [$(ids) || $$(ids)].flatten();
return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, options)) });
}).flatten(),
this.options
);
}
});
Element.CSS_PROPERTIES = $w(
'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' +
'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
'fontSize fontWeight height left letterSpacing lineHeight ' +
'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
'right textIndent top width wordSpacing zIndex');
Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;
String.__parseStyleElement = document.createElement('div');
String.prototype.parseStyle = function(){
var style, styleRules = $H();
if (Prototype.Browser.WebKit)
style = new Element('div',{style:this}).style;
else {
String.__parseStyleElement.innerHTML = '<div style="' + this + '"></div>';
style = String.__parseStyleElement.childNodes[0].style;
}
Element.CSS_PROPERTIES.each(function(property){
if (style[property]) styleRules.set(property, style[property]);
});
if (Prototype.Browser.IE && this.include('opacity'))
styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);
return styleRules;
};
if (document.defaultView && document.defaultView.getComputedStyle) {
Element.getStyles = function(element) {
var css = document.defaultView.getComputedStyle($(element), null);
return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
styles[property] = css[property];
return styles;
});
};
} else {
Element.getStyles = function(element) {
element = $(element);
var css = element.currentStyle, styles;
styles = Element.CSS_PROPERTIES.inject({ }, function(results, property) {
share/static/alice.js view on Meta::CPAN
Position.within(drop.element, point[0], point[1]) );
},
deactivate: function(drop) {
if(drop.hoverclass)
Element.removeClassName(drop.element, drop.hoverclass);
this.last_active = null;
},
activate: function(drop) {
if(drop.hoverclass)
Element.addClassName(drop.element, drop.hoverclass);
this.last_active = drop;
},
show: function(point, element) {
if(!this.drops.length) return;
var drop, affected = [];
this.drops.each( function(drop) {
if(Droppables.isAffected(point, element, drop))
affected.push(drop);
});
if(affected.length>0)
drop = Droppables.findDeepestChild(affected);
if(this.last_active && this.last_active != drop) this.deactivate(this.last_active);
if (drop) {
Position.within(drop.element, point[0], point[1]);
if(drop.onHover)
drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
if (drop != this.last_active) Droppables.activate(drop);
}
},
fire: function(event, element) {
if(!this.last_active) return;
Position.prepare();
if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
if (this.last_active.onDrop) {
this.last_active.onDrop(element, this.last_active.element, event);
return true;
}
},
reset: function() {
if(this.last_active)
this.deactivate(this.last_active);
}
};
var Draggables = {
drags: [],
observers: [],
register: function(draggable) {
if(this.drags.length == 0) {
this.eventMouseUp = this.endDrag.bindAsEventListener(this);
this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
this.eventKeypress = this.keyPress.bindAsEventListener(this);
Event.observe(document, "mouseup", this.eventMouseUp);
Event.observe(document, "mousemove", this.eventMouseMove);
Event.observe(document, "keypress", this.eventKeypress);
}
this.drags.push(draggable);
},
unregister: function(draggable) {
this.drags = this.drags.reject(function(d) { return d==draggable });
if(this.drags.length == 0) {
Event.stopObserving(document, "mouseup", this.eventMouseUp);
Event.stopObserving(document, "mousemove", this.eventMouseMove);
Event.stopObserving(document, "keypress", this.eventKeypress);
}
},
activate: function(draggable) {
if(draggable.options.delay) {
this._timeout = setTimeout(function() {
Draggables._timeout = null;
window.focus();
Draggables.activeDraggable = draggable;
}.bind(this), draggable.options.delay);
} else {
window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
this.activeDraggable = draggable;
}
},
deactivate: function() {
this.activeDraggable = null;
},
updateDrag: function(event) {
if(!this.activeDraggable) return;
var pointer = [Event.pointerX(event), Event.pointerY(event)];
if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
this._lastPointer = pointer;
this.activeDraggable.updateDrag(event, pointer);
},
endDrag: function(event) {
if(this._timeout) {
clearTimeout(this._timeout);
this._timeout = null;
}
if(!this.activeDraggable) return;
this._lastPointer = null;
this.activeDraggable.endDrag(event);
this.activeDraggable = null;
},
keyPress: function(event) {
if(this.activeDraggable)
this.activeDraggable.keyPress(event);
},
addObserver: function(observer) {
this.observers.push(observer);
this._cacheObserverCallbacks();
},
removeObserver: function(element) { // element instead of observer fixes mem leaks
this.observers = this.observers.reject( function(o) { return o.element==element });
this._cacheObserverCallbacks();
},
notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
if(this[eventName+'Count'] > 0)
this.observers.each( function(o) {
if(o[eventName]) o[eventName](eventName, draggable, event);
});
if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
},
_cacheObserverCallbacks: function() {
['onStart','onEnd','onDrag'].each( function(eventName) {
Draggables[eventName+'Count'] = Draggables.observers.select(
function(o) { return o[eventName]; }
).length;
});
}
share/static/alice.js view on Meta::CPAN
/*--------------------------------------------------------------------------*/
var Draggable = Class.create({
initialize: function(element) {
var defaults = {
handle: false,
reverteffect: function(element, top_offset, left_offset) {
var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
queue: {scope:'_draggable', position:'end'}
});
},
endeffect: function(element) {
var toOpacity = Object.isNumber(element._opacity) ? element._opacity : 1.0;
new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
queue: {scope:'_draggable', position:'end'},
afterFinish: function(){
Draggable._dragging[element] = false
}
});
},
zindex: 1000,
revert: false,
quiet: false,
scroll: false,
scrollSensitivity: 20,
scrollSpeed: 15,
snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
delay: 0
};
if(!arguments[1] || Object.isUndefined(arguments[1].endeffect))
Object.extend(defaults, {
starteffect: function(element) {
element._opacity = Element.getOpacity(element);
Draggable._dragging[element] = true;
new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
}
});
var options = Object.extend(defaults, arguments[1] || { });
this.element = $(element);
if(options.handle && Object.isString(options.handle))
this.handle = this.element.down('.'+options.handle, 0);
if(!this.handle) this.handle = $(options.handle);
if(!this.handle) this.handle = this.element;
if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
options.scroll = $(options.scroll);
this._isScrollChild = Element.childOf(this.element, options.scroll);
}
Element.makePositioned(this.element); // fix IE
this.options = options;
this.dragging = false;
this.eventMouseDown = this.initDrag.bindAsEventListener(this);
Event.observe(this.handle, "mousedown", this.eventMouseDown);
Draggables.register(this);
},
destroy: function() {
Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
Draggables.unregister(this);
},
currentDelta: function() {
return([
parseInt(Element.getStyle(this.element,'left') || '0'),
parseInt(Element.getStyle(this.element,'top') || '0')]);
},
initDrag: function(event) {
if(!Object.isUndefined(Draggable._dragging[this.element]) &&
Draggable._dragging[this.element]) return;
if(Event.isLeftClick(event)) {
var src = Event.element(event);
if((tag_name = src.tagName.toUpperCase()) && (
tag_name=='INPUT' ||
tag_name=='SELECT' ||
tag_name=='OPTION' ||
tag_name=='BUTTON' ||
tag_name=='TEXTAREA')) return;
var pointer = [Event.pointerX(event), Event.pointerY(event)];
var pos = this.element.cumulativeOffset();
this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
Draggables.activate(this);
Event.stop(event);
}
},
startDrag: function(event) {
this.dragging = true;
if(!this.delta)
this.delta = this.currentDelta();
if(this.options.zindex) {
this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
this.element.style.zIndex = this.options.zindex;
}
if(this.options.ghosting) {
this._clone = this.element.cloneNode(true);
this._originallyAbsolute = (this.element.getStyle('position') == 'absolute');
if (!this._originallyAbsolute)
Position.absolutize(this.element);
this.element.parentNode.insertBefore(this._clone, this.element);
}
if(this.options.scroll) {
if (this.options.scroll == window) {
var where = this._getWindowScroll(this.options.scroll);
this.originalScrollLeft = where.left;
this.originalScrollTop = where.top;
share/static/alice.js view on Meta::CPAN
var dropped = false;
if(success) {
dropped = Droppables.fire(event, this.element);
if (!dropped) dropped = false;
}
if(dropped && this.options.onDropped) this.options.onDropped(this.element);
Draggables.notify('onEnd', this, event);
var revert = this.options.revert;
if(revert && Object.isFunction(revert)) revert = revert(this.element);
var d = this.currentDelta();
if(revert && this.options.reverteffect) {
if (dropped == 0 || revert != 'failure')
this.options.reverteffect(this.element,
d[1]-this.delta[1], d[0]-this.delta[0]);
} else {
this.delta = d;
}
if(this.options.zindex)
this.element.style.zIndex = this.originalZ;
if(this.options.endeffect)
this.options.endeffect(this.element);
Draggables.deactivate(this);
Droppables.reset();
},
keyPress: function(event) {
if(event.keyCode!=Event.KEY_ESC) return;
this.finishDrag(event, false);
Event.stop(event);
},
endDrag: function(event) {
if(!this.dragging) return;
this.stopScrolling();
this.finishDrag(event, true);
Event.stop(event);
},
draw: function(point) {
var pos = this.element.cumulativeOffset();
if(this.options.ghosting) {
var r = Position.realOffset(this.element);
pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
}
var d = this.currentDelta();
pos[0] -= d[0]; pos[1] -= d[1];
if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
}
var p = [0,1].map(function(i){
return (point[i]-pos[i]-this.offset[i])
}.bind(this));
if(this.options.snap) {
if(Object.isFunction(this.options.snap)) {
p = this.options.snap(p[0],p[1],this);
} else {
if(Object.isArray(this.options.snap)) {
p = p.map( function(v, i) {
return (v/this.options.snap[i]).round()*this.options.snap[i] }.bind(this));
} else {
p = p.map( function(v) {
return (v/this.options.snap).round()*this.options.snap }.bind(this));
}
}}
var style = this.element.style;
if((!this.options.constraint) || (this.options.constraint=='horizontal'))
style.left = p[0] + "px";
if((!this.options.constraint) || (this.options.constraint=='vertical'))
style.top = p[1] + "px";
if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
},
stopScrolling: function() {
if(this.scrollInterval) {
clearInterval(this.scrollInterval);
this.scrollInterval = null;
Draggables._lastScrollPointer = null;
}
},
startScrolling: function(speed) {
if(!(speed[0] || speed[1])) return;
this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
this.lastScrolled = new Date();
this.scrollInterval = setInterval(this.scroll.bind(this), 10);
},
scroll: function() {
var current = new Date();
var delta = current - this.lastScrolled;
this.lastScrolled = current;
if(this.options.scroll == window) {
with (this._getWindowScroll(this.options.scroll)) {
if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
var d = delta / 1000;
this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
}
}
} else {
this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
}
Position.prepare();
Droppables.show(Draggables._lastPointer, this.element);
Draggables.notify('onDrag', this);
if (this._isScrollChild) {
Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
if (Draggables._lastScrollPointer[0] < 0)
Draggables._lastScrollPointer[0] = 0;
if (Draggables._lastScrollPointer[1] < 0)
Draggables._lastScrollPointer[1] = 0;
this.draw(Draggables._lastScrollPointer);
}
if(this.options.change) this.options.change(this);
},
_getWindowScroll: function(w) {
var T, L, W, H;
with (w.document) {
if (w.document.documentElement && documentElement.scrollTop) {
T = documentElement.scrollTop;
L = documentElement.scrollLeft;
} else if (w.document.body) {
T = body.scrollTop;
L = body.scrollLeft;
}
if (w.innerWidth) {
W = w.innerWidth;
H = w.innerHeight;
} else if (w.document.documentElement && documentElement.clientWidth) {
W = documentElement.clientWidth;
H = documentElement.clientHeight;
} else {
W = body.offsetWidth;
H = body.offsetHeight;
}
}
return { top: T, left: L, width: W, height: H };
}
});
share/static/alice.js view on Meta::CPAN
modifiers.ctrl.wanted = true;
} else if(k == 'shift') {
kp++;
modifiers.shift.wanted = true;
} else if(k == 'alt') {
kp++;
modifiers.alt.wanted = true;
} else if(k == 'meta') {
kp++;
modifiers.meta.wanted = true;
} else if(k.length > 1) { //If it is a special key
if(special_keys[k] == code) kp++;
} else if(opt['keycode']) {
if(opt['keycode'] == code) kp++;
} else { //The special keys did not match
if(character == k) kp++;
else {
if(shift_nums[character] && e.shiftKey) { //Stupid Shift key bug created by using lowercase
character = shift_nums[character];
if(character == k) kp++;
}
}
}
}
if(kp == keys.length &&
modifiers.ctrl.pressed == modifiers.ctrl.wanted &&
modifiers.shift.pressed == modifiers.shift.wanted &&
modifiers.alt.pressed == modifiers.alt.wanted &&
modifiers.meta.pressed == modifiers.meta.wanted) {
callback(e);
if(!opt['propagate']) { //Stop the event
e.cancelBubble = true;
e.returnValue = false;
if (e.stopPropagation) {
e.stopPropagation();
e.preventDefault();
}
return false;
}
}
}
this.all_shortcuts[shortcut_combination] = {
'callback':func,
'target':ele,
'event': opt['type']
};
if(ele.addEventListener) ele.addEventListener(opt['type'], func, false);
else if(ele.attachEvent) ele.attachEvent('on'+opt['type'], func);
else ele['on'+opt['type']] = func;
},
'remove':function(shortcut_combination) {
shortcut_combination = shortcut_combination.toLowerCase();
var binding = this.all_shortcuts[shortcut_combination];
delete(this.all_shortcuts[shortcut_combination])
if(!binding) return;
var type = binding['event'];
var ele = binding['target'];
var callback = binding['callback'];
if(ele.detachEvent) ele.detachEvent('on'+type, callback);
else if(ele.removeEventListener) ele.removeEventListener(type, callback, false);
else ele['on'+type] = false;
}
};
function str_repeat(i, m) {
for (var o = []; m > 0; o[--m] = i);
return o.join('');
}
function sprintf() {
var i = 0, a, f = arguments[i++], o = [], m, p, c, x, s = '';
while (f) {
if (m = /^[^\x25]+/.exec(f)) {
o.push(m[0]);
}
else if (m = /^\x25{2}/.exec(f)) {
o.push('%');
}
else if (m = /^\x25(?:(\d+)\$)?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(f)) {
if (((a = arguments[m[1] || i++]) == null) || (a == undefined)) {
throw('Too few arguments.');
}
if (/[^s]/.test(m[7]) && (typeof(a) != 'number')) {
throw('Expecting number but found ' + typeof(a));
}
switch (m[7]) {
case 'b': a = a.toString(2); break;
case 'c': a = String.fromCharCode(a); break;
case 'd': a = parseInt(a); break;
case 'e': a = m[6] ? a.toExponential(m[6]) : a.toExponential(); break;
case 'f': a = m[6] ? parseFloat(a).toFixed(m[6]) : parseFloat(a); break;
case 'o': a = a.toString(8); break;
case 's': a = ((a = String(a)) && m[6] ? a.substring(0, m[6]) : a); break;
case 'u': a = Math.abs(a); break;
case 'x': a = a.toString(16); break;
case 'X': a = a.toString(16).toUpperCase(); break;
}
a = (/[def]/.test(m[7]) && m[2] && a >= 0 ? '+'+ a : a);
c = m[3] ? m[3] == '0' ? '0' : m[3].charAt(1) : ' ';
x = m[5] - String(a).length - s.length;
p = m[5] ? str_repeat(c, x) : '';
o.push(s + (m[4] ? a + p : p + a));
}
else {
throw('Huh ?!');
}
f = f.substring(m[0].length);
}
return o.join('');
}
/* WysiHat - WYSIWYG JavaScript framework, version 0.2.1
* (c) 2008-2010 Joshua Peek
*
* WysiHat is freely distributable under the terms of an MIT-style license.
*--------------------------------------------------------------------------*/
share/static/alice.js view on Meta::CPAN
getRangeAt: function(index) {
var textRange = this._document.selection.createRange();
if (this._selectionExists(textRange))
return Range._fromTextRange(textRange, this._document);
return null;
},
toString: function() {
return this._document.selection.createRange().text;
}
};
return Selection;
})();
window.getSelection = (function() {
var selection = new Selection(document);
return function() { return selection; };
})();
}
Object.extend(Range.prototype, (function() {
function beforeRange(range) {
if (!range || !range.compareBoundaryPoints) return false;
return (this.compareBoundaryPoints(this.START_TO_START, range) == -1 &&
this.compareBoundaryPoints(this.START_TO_END, range) == -1 &&
this.compareBoundaryPoints(this.END_TO_END, range) == -1 &&
this.compareBoundaryPoints(this.END_TO_START, range) == -1);
}
function afterRange(range) {
if (!range || !range.compareBoundaryPoints) return false;
return (this.compareBoundaryPoints(this.START_TO_START, range) == 1 &&
this.compareBoundaryPoints(this.START_TO_END, range) == 1 &&
this.compareBoundaryPoints(this.END_TO_END, range) == 1 &&
this.compareBoundaryPoints(this.END_TO_START, range) == 1);
}
function betweenRange(range) {
if (!range || !range.compareBoundaryPoints) return false;
return !(this.beforeRange(range) || this.afterRange(range));
}
function equalRange(range) {
if (!range || !range.compareBoundaryPoints) return false;
return (this.compareBoundaryPoints(this.START_TO_START, range) == 0 &&
this.compareBoundaryPoints(this.START_TO_END, range) == 1 &&
this.compareBoundaryPoints(this.END_TO_END, range) == 0 &&
this.compareBoundaryPoints(this.END_TO_START, range) == -1);
}
function getNode() {
var parent = this.commonAncestorContainer;
while (parent.nodeType == Node.TEXT_NODE)
parent = parent.parentNode;
var child = parent.childElements().detect(function(child) {
var range = document.createRange();
range.selectNodeContents(child);
return this.betweenRange(range);
}.bind(this));
return $(child || parent);
}
return {
beforeRange: beforeRange,
afterRange: afterRange,
betweenRange: betweenRange,
equalRange: equalRange,
getNode: getNode
};
})());
if (Prototype.Browser.IE) {
Object.extend(Selection.prototype, (function() {
function getNode() {
var range = this._document.selection.createRange();
return $(range.parentElement());
}
function selectNode(element) {
var range = this._document.body.createTextRange();
range.moveToElementText(element);
range.select();
}
return {
getNode: getNode,
selectNode: selectNode
}
})());
} else {
if (typeof Selection == 'undefined') {
var Selection = {}
Selection.prototype = window.getSelection().__proto__;
}
Object.extend(Selection.prototype, (function() {
function getNode() {
if (this.rangeCount > 0)
return this.getRangeAt(0).getNode();
else
return null;
}
function selectNode(element) {
var range = document.createRange();
range.selectNode(element);
this.removeAllRanges();
this.addRange(range);
}
return {
getNode: getNode,
selectNode: selectNode
}
})());
}
document.on("dom:loaded", function() {
function fieldChangeHandler(event, element) {
share/static/alice.js view on Meta::CPAN
} else if (this.unorderedListSelected()) {
selection.selectNode(node.up("ul"));
}
this.execCommand('insertorderedlist', false, null);
}
function insertOrderedList() {
this.toggleOrderedList();
}
function orderedListSelected() {
var element = window.getSelection().getNode();
if (element) return element.match('*[contenteditable=""] ol, *[contenteditable=true] ol, *[contenteditable=""] ol *, *[contenteditable=true] ol *');
return false;
}
function toggleUnorderedList() {
var selection, node;
selection = window.getSelection();
node = selection.getNode();
if (this.unorderedListSelected() && !node.match("ul li:last-child, ul li:last-child *")) {
selection.selectNode(node.up("ul"));
} else if (this.orderedListSelected()) {
selection.selectNode(node.up("ol"));
}
this.execCommand('insertunorderedlist', false, null);
}
function insertUnorderedList() {
this.toggleUnorderedList();
}
function unorderedListSelected() {
var element = window.getSelection().getNode();
if (element) return element.match('*[contenteditable=""] ul, *[contenteditable=true] ul, *[contenteditable=""] ul *, *[contenteditable=true] ul *');
return false;
}
function insertImage(url) {
this.execCommand('insertImage', false, url);
}
function insertHTML(html) {
if (Prototype.Browser.IE) {
var range = window.document.selection.createRange();
range.pasteHTML(html);
range.collapse(false);
range.select();
} else {
this.execCommand('insertHTML', false, html);
}
}
function execCommand(command, ui, value) {
var handler = this.commands.get(command);
if (handler) {
handler.bind(this)(value);
} else {
try {
window.document.execCommand(command, ui, value);
} catch(e) { return null; }
}
document.activeElement.fire("field:change");
}
function queryCommandState(state) {
var handler = this.queryCommands.get(state);
if (handler) {
return handler.bind(this)();
} else {
try {
return window.document.queryCommandState(state);
} catch(e) { return null; }
}
}
function getSelectedStyles() {
var styles = $H({});
var editor = this;
editor.styleSelectors.each(function(style){
var node = editor.selection.getNode();
styles.set(style.first(), Element.getStyle(node, style.last()));
});
return styles;
}
return {
boldSelection: boldSelection,
boldSelected: boldSelected,
underlineSelection: underlineSelection,
underlineSelected: underlineSelected,
italicSelection: italicSelection,
italicSelected: italicSelected,
strikethroughSelection: strikethroughSelection,
indentSelection: indentSelection,
outdentSelection: outdentSelection,
toggleIndentation: toggleIndentation,
indentSelected: indentSelected,
fontSelection: fontSelection,
fontSizeSelection: fontSizeSelection,
colorSelection: colorSelection,
backgroundColorSelection: backgroundColorSelection,
alignSelection: alignSelection,
alignSelected: alignSelected,
linkSelection: linkSelection,
unlinkSelection: unlinkSelection,
linkSelected: linkSelected,
formatblockSelection: formatblockSelection,
toggleOrderedList: toggleOrderedList,
insertOrderedList: insertOrderedList,
orderedListSelected: orderedListSelected,
toggleUnorderedList: toggleUnorderedList,
insertUnorderedList: insertUnorderedList,
unorderedListSelected: unorderedListSelected,
insertImage: insertImage,
insertHTML: insertHTML,
execCommand: execCommand,
queryCommandState: queryCommandState,
getSelectedStyles: getSelectedStyles,
commands: $H({}),
queryCommands: $H({
link: linkSelected,
orderedlist: orderedListSelected,
unorderedlist: unorderedListSelected
}),
styleSelectors: $H({
share/static/alice.js view on Meta::CPAN
}
function accumulate(node) {
if (mode != EXPECTING_LIST_ITEM) {
if (!line) line = lineContainer = createLine();
previousAccumulation = node;
lineContainer.appendChild(node);
}
}
function getPreviouslyAccumulatedTagName() {
if (previousAccumulation && previousAccumulation.nodeType == Node.ELEMENT_NODE) {
return previousAccumulation.tagName.toLowerCase();
}
}
function flush() {
if (line && line.childNodes.length) {
container.appendChild(line);
line = lineContainer = null;
}
}
function createLine() {
if (mode == ACCUMULATING_LINE) {
return new Element("div");
} else if (mode == ACCUMULATING_LIST_ITEM) {
return new Element("li");
}
}
function insertList(tagName) {
var list = new Element(tagName);
result.appendChild(list);
return list;
}
result = container = new Element("div");
walk(element.childNodes);
flush();
return result.innerHTML;
}
};
})();
WysiHat.Toolbar = Class.create((function() {
function initialize(editor) {
this.editor = editor;
this.element = this.createToolbarElement();
}
function createToolbarElement() {
var toolbar = new Element('div', { 'class': 'editor_toolbar' });
this.editor.insert({before: toolbar});
return toolbar;
}
function addButtonSet(set) {
$A(set).each(function(button){
this.addButton(button);
}.bind(this));
}
function addButton(options, handler) {
options = $H(options);
if (!options.get('name'))
options.set('name', options.get('label').toLowerCase());
var name = options.get('name');
var button = this.createButtonElement(this.element, options);
var handler = this.buttonHandler(name, options);
this.observeButtonClick(button, handler);
var handler = this.buttonStateHandler(name, options);
this.observeStateChanges(button, name, handler);
}
function createButtonElement(toolbar, options) {
var button = new Element('a', {
'class': 'button', 'href': '#'
});
button.update('<span>' + options.get('label') + '</span>');
button.addClassName(options.get('name'));
toolbar.appendChild(button);
return button;
}
function buttonHandler(name, options) {
if (options.handler)
return options.handler;
else if (options.get('handler'))
return options.get('handler');
else
return function(editor) { editor.execCommand(name); };
}
function observeButtonClick(element, handler) {
element.on('click', function(event) {
handler(this.editor);
event.stop();
}.bind(this));
}
function buttonStateHandler(name, options) {
if (options.query)
return options.query;
else if (options.get('query'))
return options.get('query');
else
return function(editor) { return editor.queryCommandState(name); };
}
function observeStateChanges(element, name, handler) {
var previousState;
this.editor.on("selection:change", function(event) {
var state = handler(this.editor);
if (state != previousState) {
previousState = state;
this.updateButtonState(element, name, state);
}
}.bind(this));
}
function updateButtonState(element, name, state) {
if (state)
element.addClassName('selected');
else
element.removeClassName('selected');
}
return {
initialize: initialize,
createToolbarElement: createToolbarElement,
addButtonSet: addButtonSet,
addButton: addButton,
createButtonElement: createButtonElement,
buttonHandler: buttonHandler,
observeButtonClick: observeButtonClick,
buttonStateHandler: buttonStateHandler,
observeStateChanges: observeStateChanges,
updateButtonState: updateButtonState
};
})());
WysiHat.Toolbar.ButtonSets = {};
WysiHat.Toolbar.ButtonSets.Basic = $A([
{ label: "Bold" },
{ label: "Underline" },
{ label: "Italic" }
]);
/* SWFObject v2.2 <http://code.google.com/p/swfobject/>
is released under the MIT License <http://www.opensource.org/licenses/mit-license.php>
*/
var swfobject=function(){var D="undefined",r="object",S="Shockwave Flash",W="ShockwaveFlash.ShockwaveFlash",q="application/x-shockwave-flash",R="SWFObjectExprInst",x="onreadystatechange",O=window,j=document,t=navigator,T=false,U=[h],o=[],N=[],I=[],l,...
(function() {
if (window.WebSocket && !window.WEB_SOCKET_FORCE_FLASH) return;
var logger;
if (window.WEB_SOCKET_LOGGER) {
logger = WEB_SOCKET_LOGGER;
} else if (window.console && window.console.log && window.console.error) {
logger = window.console;
} else {
logger = {log: function(){ }, error: function(){ }};
}
if (swfobject.getFlashPlayerVersion().major < 10) {
logger.error("Flash Player >= 10.0.0 is required.");
return;
}
if (location.protocol == "file:") {
logger.error(
"WARNING: web-socket-js doesn't work in file:///... URL " +
"unless you set Flash Security Settings properly. " +
"Open the page via Web server i.e. http://...");
}
/**
share/static/alice.js view on Meta::CPAN
msg: '/' + action + ' ' + alias,
source: alice.activeWindow().id,
});
return false;
}
}
});
Element.addMethods({
redraw: function(element){
element = $(element);
var n = document.createTextNode(' ');
element.appendChild(n);
(function(){n.parentNode.removeChild(n)}).defer();
return element;
}
});
Alice.Application = Class.create({
initialize: function() {
this.options = {};
this.isFocused = true;
this.window_map = new Hash();
this.previousFocus = 0;
this.selectedSet = '';
this.tabs = $('tabs');
this.topic = $('topic');
this.nicklist = $('nicklist');
this.overlayVisible = false;
this.lastnotify = 0;
this.topic_height = "14px";
this.beep = new Audio("/static/beep.mp3");
this.oembeds = [];
this.jsonp_callbacks = {};
this.connection = window.WebSocket && !window.location.search.match(/&?stream=xhr/) ?
new Alice.Connection.WebSocket(this)
: new Alice.Connection.XHR(this);
this.tabs_width = $('tabs_container').getWidth();
this.tabs_layout = this.tabs.getLayout();
this.base_filters = this.baseFilters();
this.message_filters = [];
this.supportsTouch = 'createTouch' in document;
this.isPhone = window.navigator.userAgent.match(/(android|iphone|wosbrowser)/i) ? true : false;
this.isMobile = this.isPhone || Prototype.Browser.MobileSafari;
this.loadDelay = this.isMobile ? 3000 : 1000;
if (window.navigator.standalone || window.navigator.userAgent.match(/Fluid/)) this.loadDelay = 0;
this.keyboard = new Alice.Keyboard(this);
this.input = new Alice.Input(this, "msg");
this.submit = $("submit");
this.submit.observe("click", function (e) {
this.input.send(); e.stop()}.bind(this));
this.tabs.observe("webkitTransitionEnd", this.shiftEnd.bind(this));
this.tabs.observe("transitionend", this.shiftEnd.bind(this));
this.makeSortable();
this.setupTopic();
this.setupNicklist();
this.setupMenus();
},
getBacklog: function (win, max, limit) {
this.connection.requestChunk(win.id, limit, max);
},
fetchOembeds: function(cb) {
var req = new XMLHttpRequest();
req.open("GET", "https://noembed.com/providers");
req.onreadystatechange = function(){
if (req.readyState == 4) {
try {
var providers = req.responseText.evalJSON();
this.oembeds = providers.inject([], function(acc, site){
return acc.concat(site.patterns.map(function(pat){return new RegExp(pat)}));
});
} catch (e) {}
setTimeout(this.fetchOembeds.bind(this), 1000 * 60 * 5);
if (cb) cb();
}
}.bind(this);
req.send();
},
embed: function(a, win) {
var params = {
url: a.href,
maxheight: 300,
};
var req = new XMLHttpRequest();
req.open("GET", "https://www.noembed.com/embed?" + Object.toQueryString(params));
req.onreadystatechange = function(){
if (req.readyState == 4) {
var data = req.responseText.evalJSON();
this.embedContent(a, win, data);
}
}.bind(this);
req.send();
},
embedContent: function(a, win, data) {
if (!data || !data.html) return;
var html = data.html;
var elem = new Element("DIV", {"class": "oembed"});
if (data.provider_name == "Twitter") {
var position = win.captureScrollPosition();
elem.setStyle({display: "block"});
elem.update(html);
a.replace(elem);
win.scrollToPosition(position);
Alice.makeLinksClickable(elem);
return;
}
var position = win.captureScrollPosition();
a.update(data.title);
a.insert({
after: '<sup class="external"><a target="_blank" href="'+data.url+'">'
+data.provider_name+'</a></sup>'
});
a.up("div.msg").insert(elem);
win.scrollToPosition(position);
a.observe('click', function(e) {
e.stop();
var position = win.captureScrollPosition();
if (elem.innerHTML) {
elem.innerHTML = "";
elem.style.display = "none";
return;
}
elem.style.display = "block";
elem.innerHTML = html;
Alice.makeLinksClickable(elem);
var images = elem.select("img");
if (images.length) {
images.each(function(img) {
img.observe("load", function(e) {
win.scrollToPosition(position);
img.stopObserving(img, "load");
});
});
}
win.scrollToPosition(position);
});
},
actionHandlers: {
join: function (action) {
var win = this.getWindow(action['window'].id);
if (!win) {
this.insertWindow(action['window'].id, action.html);
win = this.openWindow(action['window']);
this.updateOverflowMenus();
if (this.selectedSet && !this.currentSetContains(win)) {
if (confirm("You joined "+win.title+" which is not in the '"+this.selectedSet+"' set. Do you want to add it?")) {
this.tabsets[this.selectedSet].push(win.id);
win.show();
Alice.tabsets.submit(this.tabsets);
}
else {
win.hide();
}
}
}
else {
win.enable();
}
},
part: function (action) {
this.closeWindow(action['window'].id);
},
trim: function (action) {
var win = this.getWindow(action['window'].id);
if (win) {
win.messageLimit = action['lines'];
win.trimMessages();
}
},
nicks: function (action) {
var win = this.getWindow(action['window'].id);
if (win) win.updateNicks(action.nicks);
},
alert: function (action) {
this.activeWindow().showAlert(action['body']);
},
clear: function (action) {
var win = this.getWindow(action['window'].id);
if (win) win.clearMessages();
},
announce: function (action) {
this.activeWindow().announce(action['body']);
},
connect: function (action) {
if ($('servers')) {
Alice.connections.connectServer(action.network);
}
},
disconnect: function (action) {
action.windows.each(function (win_info) {
var win = this.getWindow(win_info.id);
if (win) {
win.disable();
}
}.bind(this));
if ($('servers')) {
Alice.connections.disconnectServer(action.network);
}
},
focus: function (action) {
if (!action.window_number) return;
if (action.window_number == "next") {
this.nextWindow();
}
else if (action.window_number.match(/^prev/)) {
this.previousWindow();
}
else if (action.window_number.match(/^\d+$/)) {
var tab = this.tabs.down('li', action.window_number);
if (tab) {
var window_id = tab.id.replace('_tab','');
this.getWindow(window_id).focus();
}
}
}
},
toggleHelp: function() {
var help = $('help');
help.visible() ? help.hide() : help.show();
},
toggleJoin: function() {
this.connection.get("/join", function (transport) {
this.input.disabled = true;
$('windows').insert(transport.responseText);
}.bind(this));
},
toggleConfig: function(e) {
this.connection.get("/config", function (transport) {
this.input.disabled = true;
$('windows').insert(transport.responseText);
}.bind(this));
if (e) e.stop();
},
togglePrefs: function(e) {
this.connection.get("/prefs", function (transport) {
this.input.disabled = true;
$('windows').insert(transport.responseText);
}.bind(this));
if (e) e.stop();
},
toggleTabsets: function(e) {
this.connection.get("/tabsets", function (transport) {
this.input.disabled = true;
$('windows').insert(transport.responseText);
Alice.tabsets.focusIndex(0);
}.bind(this));
},
windows: function () {
return this.window_map.values();
},
nth_window: function(n) {
var tab = this.tabs.down('.visible:not(.info_tab)', n - 1);
if (tab) {
var m = tab.id.match(/([^_]+)_tab/);
if (m) {
return this.window_map.get(m[1]);
}
}
},
info_window: function(n) {
return this.windows().find(function(win) {
if (win.type == "info") return win;
});
},
openWindow: function(serialized, msgid) {
if (!msgid) msgid = this.msgid();
var win = new Alice.Window(this, serialized, msgid);
this.addWindow(win);
return win;
},
addWindow: function(win) {
this.window_map.set(win.id, win);
if (window.fluid)
window.fluid.addDockMenuItem(win.title, win.focus.bind(win));
},
removeWindow: function(win) {
this.tabs_layout = this.tabs.getLayout();
this.windows().invoke("updateTabLayout");
if (win.active) this.focusLast();
if (window.fluid)
window.fluid.removeDockMenuItem(win.title);
if (win.id == this.previousFocus.id) {
this.previousFocus = 0;
}
this.window_map.unset(win.id);
this.connection.closeWindow(win);
win = null;
},
getWindow: function(windowId) {
return this.window_map.get(windowId);
},
activeWindow: function() {
var windows = this.windows();
for (var i=0; i < windows.length; i++) {
if (windows[i].active) return windows[i];
}
for (var i=0; i < windows.length; i++) {
if (windows[i].type != "info") return windows[i];
}
if (windows[0]) return windows[0];
},
addFilters: function(list) {
this.message_filters = this.message_filters.concat(list);
},
applyFilters: function(li, win) {
if (li.hasClassName("filtered")) return;
var length = this.base_filters.length;
for (var i=0; i < length; i++) {
this.base_filters[i].call(this, li, win);
}
li.addClassName("filtered");
if (li.hasClassName("message")) {
var msg = li.down("div.msg");
var length = this.message_filters.length;
for (var i=0; i < length; i++) {
var stop = this.message_filters[i].call(this, msg, win);
if (stop) return;
}
}
},
nextWindow: function() {
var active = this.activeWindow();
var nextTab = active.tab.next('.visible');
if (!nextTab) nextTab = this.tabs.down('.visible');
if (!nextTab) return;
var id = nextTab.id.replace('_tab','');
if (id != active.id) {
var win = this.getWindow(id);
win.focus();
return win;
}
},
updateOverflowMenus: function() {
var left = $('tab_menu_left');
var right = $('tab_menu_right');
left.removeClassName("unread");
left.removeClassName("highlight");
right.removeClassName("unread");
right.removeClassName("highlight");
var left_menu = left.down('ul');
var right_menu = right.down('ul');
left_menu.innerHTML = "";
right_menu.innerHTML = "";
this.windows().each(function(win) {
if (!win.visible) return;
var pos = win.getTabPosition();
if (pos.left) {
var classes = win.statuses;
classes.each(function(c){left.addClassName(c)});
left_menu.innerHTML += sprintf('<li rel="%s" class="%s"><span>%s</span></a>', win.id, classes.join(" "), win.title)
}
else if (pos.right) {
var classes = win.statuses;
classes.each(function(c){right.addClassName(c)});
right_menu.innerHTML += sprintf('<li rel="%s" class="%s"><span>%s</span></a>', win.id, classes.join(" "), win.title)
}
}.bind(this));
this.toggleMenu(left, !!left_menu.innerHTML);
this.toggleMenu(right, !!right_menu.innerHTML);
},
toggleMenu: function(menu, active) {
if (active) {
menu.addClassName("active");
}
else {
menu.removeClassName("active");
}
},
nextUnreadWindow: function() {
var active = this.activeWindow();
var tabs = active.tab.nextSiblings().concat(active.tab.previousSiblings().reverse());
var unread = tabs.find(function(tab) {
return tab.hasClassName("unread") && tab.hasClassName("visible")
});
if (unread) {
var id = unread.id.replace("_tab","");
if (id) {
this.getWindow(id).focus();
}
}
},
focusLast: function() {
if (this.previousFocus && this.previousFocus.id != this.activeWindow().id)
this.previousFocus.focus();
else
this.previousWindow();
},
previousWindow: function() {
var active = this.activeWindow();
var previousTab = this.activeWindow().tab.previous('.visible');
if (!previousTab) previousTab = this.tabs.select('.visible').last();
if (!previousTab) return;
var id = previousTab.id.replace('_tab','');
if (id != active.id) this.getWindow(id).focus();
},
closeWindow: function(windowId) {
var win = this.getWindow(windowId);
if (win) win.close();
},
insertWindow: function(windowId, html) {
if (!$(windowId)) {
$('windows').insert(html['window']);
$('tabs').insert(html.tab);
this.makeSortable();
}
},
share/static/alice.js view on Meta::CPAN
}
}
return false;
},
tabShift: function() {
return this.tabs_layout.get('left');
},
tabsWidth: function() {
return this.tabs_width;
},
freeze: function() {
$('windows').setStyle({
width: document.viewport.getWidth()+"px",
right: "auto",
});
},
thaw: function() {
$('windows').setStyle({
width: "auto",
right: "0px",
});
},
shiftTabs: function(shift) {
var current = this.tabShift();
var left = current + shift;
var time = Math.min(Math.max(0.1, Math.abs(shift) / 100), 0.5);
this.tabs.style.webkitTransitionDuration = time+"s";
this.tabs.setStyle({left: left+"px"});
this.tabs_layout = this.tabs.getLayout();
},
shiftEnd: function(e) {
this.tabs_layout = this.tabs.getLayout();
this.updateOverflowMenus();
},
makeSortable: function() {
Sortable.create('tabs', {
overlap: 'horizontal',
constraint: 'horizontal',
format: /(.+)/,
only: ["info_tab", "channel_tab", "privmsg_tab"],
onUpdate: function (res) {
var tabs = res.childElements();
var order = tabs.collect(function(t){
var m = t.id.match(/([^_]+)_tab/);
if (m) return m[1]
});
if (order.length) this.connection.sendTabOrder(order);
setTimeout(function(){
this.windows().invoke("updateTabLayout");
this.activeWindow().shiftTab();
}.bind(this), 100);
}.bind(this)
});
},
addMissed: function() {
if (!window.fluid) return;
window.fluid.dockBadge ? window.fluid.dockBadge++ :
window.fluid.dockBadge = 1;
},
clearMissed: function() {
if (!window.fluid) return;
window.fluid.dockBadge = "";
},
ready: function() {
this.freeze();
setTimeout(this.updateOverflowMenus.bind(this), 1000);
this.fetchOembeds(function() {
this.connection.connect(function() {
this.focusHash() || this.activeWindow().focus();
}.bind(this));
}.bind(this));
},
log: function () {
var win = this.activeWindow();
for (var i=0; i < arguments.length; i++) {
if (window.console && window.console.log) {
console.log(arguments[i]);
}
if (this.options.debug == "true") {
if (win) {
win.addMessage({
html: '<li class="message monospace"><div class="left">console</div><div class="msg">'+arguments[i].toString()+'</div></li>'
});
}
}
}
},
msgid: function() {
var ids = this.windows().map(function(w){return w.msgid});
return Math.max.apply(Math, ids);
},
setSource: function(id) {
$('source').value = id;
},
showSet: function(name) {
var ids = this.tabsets[name];
if (ids) {
var elem = $('tabset_menu').select('li').find(function(li) {
return li.innerHTML.unescapeHTML() == name;
});
elem.up('ul').select('li').invoke('removeClassName', 'selectedset');
elem.addClassName('selectedset');
this.windows().each(function(win) {
ids.indexOf(win.id) >= 0 || win.type == "privmsg" ? win.show() : win.hide();
});
this.selectSet(name);
var active = this.activeWindow();
if (!active.visible) {
active = this.nextWindow();
}
if (active) active.shiftTab();
setTimeout(this.updateOverflowMenus.bind(this), 2000);
}
},
selectSet: function(name) {
var hash = window.location.hash;
hash = hash.replace(/^[^\/]*/, name);
window.location.hash = hash;
window.location = window.location.toString();
this.selectedSet = name;
},
clearSet: function(elem) {
elem.up('ul').select('li').invoke('removeClassName', 'selectedset');
elem.addClassName('selectedset');
this.windows().invoke("show");
this.selectSet('');
this.updateOverflowMenus();
this.activeWindow().shiftTab();
},
currentSetContains: function(win) {
var set = this.selectedSet;
if (win.type == "channel" && set && this.tabsets[set]) {
return (this.tabsets[set].indexOf(win.id) >= 0);
}
return true;
},
displayTopic: function(new_topic) {
this.topic.update(new_topic || "no topic set");
Alice.makeLinksClickable(this.topic);
},
displayNicks: function(nicks) {
this.nicklist.innerHTML = nicks.sort(function(a, b) {
a = a.toLowerCase();
b = b.toLowerCase();
if (a > b)
return 1
if (a < b)
return -1
return 0;
}).map(function(nick) {
return '<li><a>'+nick.escapeHTML()+'</a></li>';
}).join("");
},
toggleNicklist: function() {
var windows = $('windows');
var win = this.activeWindow();
var position = win.captureScrollPosition();
if (windows.hasClassName('nicklist'))
windows.removeClassName('nicklist');
else
windows.addClassName('nicklist');
win.scrollToPosition(position);
},
setupNicklist: function() {
this.nicklist.observe("click", function(e) {
var li = e.findElement('a');
if (li) {
var nick = a.innerHTML;
this.connection.requestWindow(nick, this.activeWindow().id);
}
}.bind(this));
},
setupTopic: function() {
this.topic.observe(this.supportsTouch ? "touchstart" : "click", function(e) {
if (this.supportsTouch) e.stop();
if (this.topic.getStyle("height") == this.topic_height) {
this.topic.setStyle({height: "auto"});
} else {
this.topic.setStyle({height: this.topic_height});
}
}.bind(this));
},
setupMenus: function() {
var click = this.supportsTouch ? "touchend" : "mouseup";
$('join_button').observe(click, function (e) {
e.stop();
this.toggleJoin();
}.bind(this));
$('config_menu').on(click, ".dropdown li", function(e,li) {
e.stop();
var text = li.textContent;
if (text.match(/Help/)) {
this.toggleHelp();
} else if (text.match(/Preferences/)) {
this.togglePrefs();
} else if (text.match(/Connections/)) {
this.toggleConfig();
}
$$('.dropdown.open').invoke("removeClassName", "open");
}.bind(this));
$('tabset_dropdown').on(click, ".dropdown li span", function(e,li) {
e.stop();
var name = li.innerHTML.unescapeHTML();
if (name == "Edit Sets")
this.toggleTabsets();
else if (name == "All tabs")
this.clearSet(li);
else if (this.tabsets[name])
this.showSet(name);
$$('.dropdown.open').invoke("removeClassName", "open");
}.bind(this));
['tab_menu_left', 'tab_menu_right'].each(function(side) {
$(side).on(click, ".dropdown li", function(e, li) {
e.stop();
if (li.getAttribute("rel")) {
$(side).removeClassName("open");
var win = this.getWindow(li.getAttribute("rel"));
if (win) win.focus();
}
}.bind(this));
}.bind(this));
},
baseFilters: function() {
return [
function(li, win) {
Alice.makeLinksClickable(li.down("div.msg"));
},
function(li, win) {
if (li.hasClassName("avatar")) {
if (this.options.avatars == "show") {
var avatar = li.getAttribute("avatar");
if (avatar)
li.down("a.nick").insert('<img src="'+alice.options.image_prefix+avatar+'" />');
}
else {
li.removeClassName("avatar");
}
}
},
function(li, win) {
if (li.hasClassName("consecutive")) {
var prev = li.previous();
if (!prev) return;
if (prev && prev.hasClassName("avatar") && !prev.hasClassName("consecutive"))
prev.down('div.msg').setStyle({minHeight: '0px'});
if (prev && prev.hasClassName("monospaced"))
prev.down('div.msg').setStyle({paddingBottom: '0px'});
}
},
function(li, win) {
var stamp = li.down('.timestamp');
if (!stamp) return;
var remove = false;
var seconds = stamp.innerHTML.strip();
if (li.hasClassName("message")) {
var time = new Date(seconds * 1000);
var diff = (time - win.lasttimestamp) / 1000;
remove = !(diff >= 300 || (diff > 60 && time.getMinutes() % 5 == 0));
if (!remove) win.lasttimestamp = time;
}
if (remove) {
stamp.remove();
}
else {
stamp.update(Alice.epochToLocal(seconds, this.options.timeformat));
stamp.style.opacity = 1;
}
},
function(li, win) {
if (!this.overlayVisible || !li.hasClassName("avatar")) return;
var nick = li.down('span.nick');
share/static/alice.js view on Meta::CPAN
this.addMissed();
}
}
];
},
toggleOverlay: function () {
this.overlayVisible = !this.overlayVisible;
var opacity = this.overlayVisible ? 1 : 0;
$$("li.avatar span.nick").each(function(span){
span.style.opacity = opacity;
});
}
});
Alice.Connection = {
gotoLogin: function() {
window.location = "/login";
},
connect: function(cb) {
if (this.reconnect_count > 3) {
this.aborting = true;
this.changeStatus("ok");
if (this.type == "websocket") {
this.application.activeWindow().showAlert("WebSocket connection failed, falling back...");
this.application.connection = new Alice.Connection.XHR(this.application);
this.application.connection.connect();
return;
}
this.application.activeWindow().showAlert("Alice server is not responding (<a href='javascript:alice.connection.reconnect()'>reconnect</a>)");
return;
}
this.pings = [];
this.closeConnection();
this.len = 0;
this.reconnect_count++;
this.changeStatus("loading");
this._connect(cb);
},
changeStatus: function(classname) {
$('connection_status').className = classname;
},
reconnect: function () {
this.reconnecting = true;
this.reconnect_count = 0;
this.connect();
},
handleException: function(request, exception) {
this.application.log("encountered an error with stream.");
this.application.log(exception);
this.connected = false;
if (!this.aborting)
setTimeout(this.connect.bind(this), 2000);
else
this.changeStatus("ok");
},
handleComplete: function(transport) {
this.application.log("connection was closed cleanly.");
this.connected = false;
if (!this.aborting)
setTimeout(this.connect.bind(this), 2000);
else
this.changeStatus("ok");
},
processQueue: function(data) {
try {
var queue = data.queue;
var length = queue.length;
for (var i=0; i<length; i++) {
if (queue[i].type == "identify") {
this.id = queue[i].id;
}
else if (queue[i].type == "action")
this.application.handleAction(queue[i]);
else if (queue[i].type == "message") {
if (queue[i].timestamp)
queue[i].timestamp = Alice.epochToLocal(queue[i].timestamp, this.application.options.timeformat);
this.application.displayMessage(queue[i]);
}
else if (queue[i].type == "chunk") {
this.application.displayChunk(queue[i]);
}
}
}
catch (e) {
this.application.log(e.toString());
}
},
get: function(path, callback) {
new Ajax.Request(path, {
method: 'get',
on401: this.gotoLogin,
onSuccess: callback
});
},
sendTabOrder: function (windows) {
new Ajax.Request('/tabs', {
method: 'post',
on401: this.gotoLogin,
parameters: {tabs: windows}
});
},
requestChunk: function (win, limit, max) {
if (!this.connected) return;
this.sendMessage({
source: win,
msg: "/chunk " + limit + " " + max,
});
}
};
Alice.Connection.WebSocket = Class.create(Alice.Connection, {
initialize: function(application) {
this.type = "websocket";
this.application = application;
this.connected = false;
this.aborting = false;
this.request = null;
this.reconnect_count = 0;
this.reconnecting = false;
},
_connect: function(cb) {
var now = new Date();
this.application.log("opening new websocket stream");
this.changeStatus("ok");
var parameters = Object.toQueryString({
t: now.getTime() / 1000,
tab: this.application.activeWindow().id
});
var protocol = (window.location.protocol.match(/^https/) ? "wss://" : "ws://");
var url = protocol + window.location.host + "/wsstream?" + parameters;
this.request = new WebSocket(url);
this.request.onopen = function(){
this.connected = true;
setTimeout(cb, 100);
}.bind(this);
this.request.onmessage = this.handleUpdate.bind(this);
this.request.onerror = this.handleException.bind(this);
this.request.onclose = this.handleComplete.bind(this);
},
handleUpdate: function(e) {
var data = e.data.evalJSON();
this.processQueue(data);
},
sendMessage: function(form) {
if (!this.connected) return false;
var params = form;
if (form.nodeName && form.nodeName == "FORM") {
params = Form.serialize(form, true);
}
params['stream'] = this.id;
this.request.send(Object.toJSON(params));
return true;
},
closeConnection: function() {
this.aborting = true;
if (this.request) this.request.close();
this.aborting = false;
},
closeWindow: function(win) {
this.sendMessage({source: win.id, msg: "/close"});
},
handleException: function(exception) {
this.application.log("encountered an error with stream.");
this.application.log(exception);
this.connected = false;
if (!this.aborting)
setTimeout(this.connect.bind(this), 2000);
else
this.changeStatus("ok");
},
requestWindow: function(title, windowId, message) {
this.sendMessage({source: windowId, msg: "/create " + title});
if (message) {
setTimeout(function() {
this.application.displayMessage(message)
}.bind(this), 1000);
}
}
});
Alice.Connection.XHR = Class.create(Alice.Connection, {
initialize: function(application) {
this.type = "xhr";
this.pings = [];
this.pingLimit = 10;
this.seperator = "--xalicex\n";
this.len = 0;
this.application = application;
this.connected = false;
this.aborting = false;
this.request = null;
this.reconnect_count = 0;
this.reconnecting = false;
},
_connect: function(cb) {
setTimeout(function () {
var now = new Date();
this.application.log("opening new xhr stream");
this.changeStatus("ok");
this.request = new Ajax.Request('/stream', {
method: 'get',
parameters: {
t: now.getTime() / 1000,
tab: this.application.activeWindow().id
},
on401: this.gotoLogin,
on500: this.gotoLogin,
on502: this.gotoLogin,
on503: this.gotoLogin,
onException: this.handleException.bind(this),
onInteractive: function(transport) {
if (!this.connected) {
this.connected = true;
setTimeout(cb, 0);
}
this.handleUpdate(transport);
}.bind(this),
onComplete: this.handleComplete.bind(this)
});
}.bind(this), this.application.loadDelay);
},
handleUpdate: function(transport) {
if (this.reconnecting) {
this.application.activeWindow().showHappyAlert("Reconnected to the Alice server");
this.reconnecting = false;
}
this.reconnect_count = 0;
var time = new Date();
var data = transport.responseText.slice(this.len);
var start, end;
start = data.indexOf(this.seperator);
if (start > -1) {
start += this.seperator.length;
end = data.indexOf(this.seperator, start);
if (end == -1) return;
}
else return;
this.len += (end + this.seperator.length) - start;
data = data.slice(start, end);
var data = data.evalJSON();
this.processQueue(data);
if (data.time) {
var lag = this.addPing(time / 1000 - data.time);
if (lag > 5) {
this.application.log("lag is over 5s, reconnecting.");
this.connect();
}
}
},
addPing: function(ping) {
this.pings.push(ping);
if (this.pings.length > this.pingLimit)
this.pings.shift();
var lag = this.lag();
return lag;
},
lag: function() {
if (!this.pings.length) return 0;
return this.pings.inject(0, function (acc, n) {return acc + n}) / this.pings.length;
},
sendMessage: function(form) {
if (!this.connected) return false;
var params;
if (form.nodeName && form.nodeName == "FORM") {
params = Form.serialize(form);
}
else {
params = form;
}
params['stream'] = this.id;
new Ajax.Request('/say', {
method: 'post',
parameters: params,
on401: this.gotoLogin,
onException: function (request, exception) {
alert("There was an error sending a message.");
}
});
return true;
},
closeConnection: function() {
this.aborting = true;
if (this.request && this.request.transport)
this.request.transport.abort();
this.aborting = false;
},
closeWindow: function(win) {
new Ajax.Request('/say', {
method: 'post',
on401: this.gotoLogin,
parameters: {
source: win.id,
msg: "/close",
stream: this.id
}
});
},
requestWindow: function(title, windowId, message) {
new Ajax.Request('/say', {
method: 'post',
parameters: {
source: windowId,
msg: "/create " + title,
stream: this.id
},
on401: this.gotoLogin,
onSuccess: function (transport) {
this.handleUpdate(transport);
if (message) {
setTimeout(function() {
this.application.displayMessage(message)
}.bind(this), 1000);
}
}.bind(this)
});
}
});
Alice.Window = Class.create({
initialize: function(application, serialized, msgid) {
this.application = application;
this.element = $(serialized['id']);
this.title = serialized['title'];
this.type = serialized['type'];
this.hashtag = serialized['hashtag'];
this.id = this.element.identify();
this.active = false;
this.topic = serialized['topic'];
this.tab = $(this.id + "_tab");
this.tab_layout = this.tab.getLayout();
this.tabButton = $(this.id + "_tab_button");
this.messages = this.element.down('.messages');
this.visibleNick = "";
this.visibleNickTimeout = "";
this.lasttimestamp = new Date(0);
this.nicks = [];
this.nicks_order = [];
this.statuses = [];
this.messageLimit = this.application.isMobile ? 50 : 100;
this.chunkSize = this.messageLimit / 2;
this.msgid = msgid || 0;
this.visible = true;
this.forceScroll = false;
this.lastScrollPosition = 0;
this.setupEvents();
},
hide: function() {
this.element.hide();
this.tab.addClassName('hidden');
this.tab.removeClassName('visible');
this.visible = false;
},
show: function() {
this.element.show();
this.tab.addClassName('visible');
this.tab.removeClassName('hidden');
this.visible = true;
this.updateTabLayout();
},
setupEvents: function() {
this.application.supportsTouch ? this.setupTouchEvents() : this.setupMouseEvents();
},
setupTouchEvents: function() {
this.messages.observe("touchstart", function (e) {
this.showNick(e);
}.bind(this));
this.tab.observe("touchstart", function (e) {
e.stop();
if (!this.active) this.focus();
}.bind(this));
this.tabButton.observe("touchstart", function(e) {
if (this.active) {
e.stop();
confirm("Are you sure you want to close this tab?") && this.close()
}
}.bind(this));
},
setupMouseEvents: function() {
this.tab.observe("mousedown", function(e) {
if (!this.active) {this.focus(); this.focusing = true}
}.bind(this));
this.tab.observe("click", function(e) {this.focusing = false}.bind(this));
this.tabButton.observe("click", function(e) {
if (this.active && !this.focusing)
if (this.type != "channel" || confirm("Are you sure you want to leave "+this.title+"?"))
this.close()
}.bind(this));
this.messages.observe("mouseover", this.showNick.bind(this));
},
checkScrollBack: function() {
if (this.active && this.element.scrollTop == 0) {
clearInterval(this.scrollListener);
var first = this.messages.down("li[id]");
if (first) {
first = first.id.replace("msg-", "") - 1;
this.messageLimit += this.chunkSize;
}
else {
first = this.msgid;
}
this.application.log("requesting chunk" + first);
this.tab.addClassName("loading");
this.application.getBacklog(this, first, this.chunkSize);
}
else {
clearTimeout(this.scrollListener);
this.scrollListener = setTimeout(this.checkScrollBack.bind(this), 1000);
}
},
clearMessages: function() {
clearTimeout(this.scrollListener);
this.messages.update("");
this.lastNick = "";
},
updateTabLayout: function() {
this.tab_layout = this.tab.getLayout();
},
getTabPosition: function() {
var shift = this.application.tabShift();
var tabs_width = this.application.tabsWidth();
var tab_width = this.tab_layout.get("width");
var offset_left = this.tab_layout.get("left") + shift;
var offset_right = tabs_width - (offset_left + tab_width);
var overflow_right = Math.abs(Math.min(0, offset_right));
var overflow_left = Math.abs(Math.min(0, offset_left));
return {
right: overflow_right,
left: overflow_left
};
},
shiftTab: function() {
var left = null
, time = 0
, pos = this.getTabPosition();
if (pos.left) {
this.application.shiftTabs(pos.left);
}
else if (pos.right) {
this.application.shiftTabs(-pos.right);
}
},
unFocus: function() {
this.lastScrollPosition = this.captureScrollPosition();
this.active = false;
this.element.removeClassName('active');
this.tab.removeClassName('active');
clearTimeout(this.scrollListener);
this.addFold();
},
addFold: function() {
this.messages.select("li.fold").invoke("removeClassName", "fold");
var last = this.messages.childElements().last();
if (last) last.addClassName("fold");
},
showNick: function (e) {
var li = e.findElement("li.message");
if (li && li.hasClassName("avatar")) {
if (this.application.overlayVisible || li == this.visibleNick) return;
clearTimeout(this.visibleNickTimeout);
this.visibleNick = li;
var nick;
if (li.hasClassName("consecutive")) {
var stem = li.previous("li:not(.consecutive)");
if (!stem) return;
nick = stem.down("span.nick");
} else {
nick = li.down("span.nick");
}
if (nick) {
this.visibleNickTimeout = setTimeout(function(nick) {
if (nick) nick.style.opacity = 1;
setTimeout(function(){
if (this.application.overlayVisible) return;
if (nick) nick.style.opacity = 0;
}.bind(this, nick) , 1000);
}.bind(this, nick), 500);
}
}
else {
this.visibleNick = "";
clearTimeout(this.visibleNickTimeout);
}
},
focus: function(event) {
if (!this.application.currentSetContains(this)) return;
this.application.previousFocus = this.application.activeWindow();
if (this != this.application.previousFocus)
this.application.previousFocus.unFocus();
this.element.addClassName('active');
this.tab.addClassName('active');
if (!this.active) {
this.active = true;
setTimeout(function(){
this.scrollToPosition(this.lastScrollPosition);
if (!this.scrollBackEmpty) this.checkScrollBack();
}.bind(this), 0);
}
this.application.setSource(this.id);
this.application.displayNicks(this.nicks);
this.markRead();
this.setWindowHash();
this.shiftTab();
var last = this.messages.childElements().last();
if (last && last.hasClassName("fold"))
last.removeClassName("fold");
this.application.displayTopic(this.topic);
document.title = this.title;
return this;
},
setWindowHash: function () {
var new_hash = "#" + this.application.selectedSet + this.hashtag;
if (new_hash != window.location.hash) {
window.location.hash = encodeURI(new_hash);
window.location = window.location.toString();
}
},
markRead: function () {
this.tab.removeClassName("unread");
this.tab.removeClassName("highlight");
this.statuses = [];
this.application.unHighlightChannelSelect(this.id);
},
markUnread: function(classname) {
var classes = ["unread"];
if (classname) classes.push(classname);
classes.each(function(c){this.tab.addClassName(c)}.bind(this));
this.application.highlightChannelSelect(this.id, classes);
this.statuses = classes;
},
disable: function () {
this.markRead();
this.tab.addClassName('disabled');
},
enable: function () {
this.tab.removeClassName('disabled');
},
close: function(event) {
this.tab.remove();
this.element.remove();
this.application.removeWindow(this);
},
showHappyAlert: function (message) {
this.messages.insert(
"<li class='event happynotice'><div class='msg'>"+message+"</div></li>"
);
this.scrollToPosition(0);
},
showAlert: function (message) {
this.messages.insert(
"<li class='event notice'><div class='msg'>"+message+"</div></li>"
);
this.scrollToPosition(0);
},
announce: function (message) {
message = message.escapeHTML();
this.messages.insert(
"<li class='message monospaced announce'><div class='msg'>"+message+"</div></li>"
);
this.scrollToPosition(0);
},
trimMessages: function() {
this.messages.select("li").reverse().slice(this.messageLimit).invoke("remove");
},
addChunk: function(chunk) {
if (chunk.nicks) this.updateNicks(chunk.nicks);
clearTimeout(this.scrollListener);
if (chunk.range.length == 0) {
this.scrollBackEmpty = true;
this.tab.removeClassName("loading");
return;
}
var position = this.captureScrollPosition();
if (chunk['range'][0] > this.msgid) {
this.messages.insert({"bottom": chunk['html']});
this.trimMessages();
this.msgid = chunk['range'][1];
}
else {
this.bulk_insert = true;
this.messages.insert({"top": chunk['html']});
}
this.messages.select("li:not(.filtered)").each(function (li) {
this.application.applyFilters(li, this);
}.bind(this));
this.bulk_insert = false;
this.scrollToPosition(position);
setTimeout(function(){this.removeClassName("loading")}.bind(this.tab), 1000);
this.scrollListener = setTimeout(this.checkScrollBack.bind(this), 1000);
},
addMessage: function(message) {
if (!message.html || message.msgid <= this.msgid) return;
if (message.msgid) this.msgid = message.msgid;
if (message.nicks) this.updateNicks(message.nicks);
var position = this.captureScrollPosition();
this.messages.insert(message.html);
this.trimMessages();
this.scrollToPosition(position);
var li = this.messages.select("li").last();
this.application.applyFilters(li, this);
this.scrollToPosition(position);
if (message.event == "topic") {
this.topic = message.body;
if (this.active) this.application.displayTopic(this.topic);
}
this.element.redraw();
this.promoteNick(message.nick);
},
promoteNick: function(nick) {
if (this.nicks_order.last() == nick) return;
var index = this.nicks_order.indexOf(nick);
if (index > -1) this.nicks_order.splice(index, 1);
this.nicks_order.push(nick);
},
captureScrollPosition: function() {
if (!this.active) return;
if (this.forceScroll) return 0;
var bottom = this.element.scrollTop + this.element.offsetHeight;
var height = this.element.scrollHeight;
return height - bottom;
},
scrollToPosition: function(position) {
if (!this.active) return;
this.element.scrollTop = this.element.scrollHeight - this.element.offsetHeight - position;
},
getNicknames: function () {
return this.nicks.sort(function(a, b) {
var pos_a = this.nicks_order.indexOf(a),
pos_b = this.nicks_order.indexOf(b);
if (pos_a == pos_b)
return a.toLowerCase().localeCompare(b.toLowerCase());
else if (pos_a > pos_b)
return -1;
else if (pos_a < pos_b)
return 1;
}.bind(this));
},
updateNicks: function(nicks) {
this.nicks = nicks;
if (this.active) this.application.displayNicks(this.nicks);
},
removeImage: function(e) {
e.stop();
var div = e.findElement('div.image');
if (div) {
var a = div.down("a");
var id = a.identify();
a.update(a.href);
a.style.display = "inline";
div.replace(a);
var contain = a.up();
contain.innerHTML = contain.innerHTML.replace("\n", "");
var a = $(id);
a.observe("click", function(e){e.stop();this.inlineImage(a)}.bind(this));
}
},
inlineImage: function(a) {
a.stopObserving("click");
var src = a.readAttribute("img") || a.innerHTML;
var prefix = alice.options.image_prefix;
var img = new Element("IMG", {src: prefix + src});
img.hide();
img.observe("load", function(){
var wrap = new Element("DIV", {"class": "image"});
var hide = new Element("A", {"class": "hideimg"});
var position = this.captureScrollPosition();
img.show();
a.replace(wrap);
wrap.insert(a);
a.update(img);
a.insert(hide);
a.style.display = "inline-block";
hide.observe("click", this.removeImage.bind(this));
hide.update("hide");
this.scrollToPosition(position);
}.bind(this));
a.insert({after: img});
}
});
Alice.Toolbar = Class.create(WysiHat.Toolbar, {
createButtonElement: function(toolbar, options) {
var button = Element('button');
button.update(options.get('label'));
button.addClassName(options.get('name'));
toolbar.appendChild(button);
return button;
},
observeButtonClick: function(element, handler) {
element.on('click', function(e) {e.stop()});
element.on('mouseup', function(event) {
alice.input.focus();
handler(this.editor, element, this);
this.editor.fire("selection:change");
event.stop();
}.bind(this));
},
});
Object.extend(Alice.Toolbar, {
updateColors: function (editor) {
var range = alice.input.range || editor;
if (range) {
var node = range.getNode();
var fg = node.getStyle("color");
var bg = node.getStyle("background-color");
var button = alice.input.toolbar.element.down("button.colors");
button.setStyle({"border-color": fg, "background-color": bg});
}
return 1;
}
});
Alice.Toolbar.ButtonSet = [
{
label: "",
name: "colors",
query: Alice.Toolbar.updateColors,
handler: function (editor, button, toolbar) {
var cb = function (color, fg) {
if (fg) {
button.setStyle({"border-color": color})
editor.colorSelection(color);
} else {
button.setStyle({"background-color": color});
editor.backgroundColorSelection(color);
}
};
if (toolbar.picker) {
toolbar.picker.remove();
toolbar.picker = undefined;
} else {
toolbar.picker = new Alice.Colorpicker(button, cb);
}
}
},
{
label: "b",
name: "bold",
handler: function (editor, button, toolbar) {
editor.boldSelection();
}
},
{
label: "i",
name: "italic",
handler: function (editor, button, toolbar) {
editor.italicSelection();
}
},
{
label: "u",
name: "underline",
handler: function (editor, button, toolbar) {
var elem = toolbar.element.down(".underline");
if (elem.hasClassName("selected"))
elem.removeClassName("selected");
else
elem.addClassName("selected");
editor.underlineSelection();
}
}
];
Alice.Colorpicker = Class.create({
initialize: function(button, callback) {
var elem = new Element("div").addClassName("color_picker");
var toggle = new Element("div").addClassName("toggle");
var blank = new Element("span").addClassName("blank").addClassName("color");
blank.setStyle({"background-color": "none"});
blank.insert("⃠");
toggle.insert('<span id="fg" class="active">fg</span><span id="bg">bg</span>');
toggle.insert(blank);
elem.insert(toggle);
var colorcontainer = new Element("div").addClassName("colors");
this.colors().each(function(color) {
var box = new Element("span").addClassName("color");
box.setStyle({"background-color": color});
colorcontainer.insert(box);
});
elem.insert(colorcontainer);
document.body.insert(elem);
elem.observe("mousedown", this.clicked.bind(this));
elem.observe("mouseup", function(e) {e.stop()});
this.button = button;
this.elem = elem;
this.cb = callback;
this.fg = true;
},
clicked: function(e) {
e.stop();
var box = e.findElement("span.color");
if (box) {
var color = box.getStyle("background-color");
if (color) this.cb(color, this.fg);
return;
}
if (e.findElement("span#fg")) {
this.elem.down("#bg").removeClassName("active");
this.elem.down("#fg").addClassName("active");
this.fg = true;
return;
}
if (e.findElement("span#bg")) {
this.elem.down("#fg").removeClassName("active");
this.elem.down("#bg").addClassName("active");
this.fg = false;
return;
}
},
remove: function() {
this.elem.remove();
},
colors: function() {
return ["#fff", "#000", "#008", "#080", "#f00", "#800", "#808", "#f80",
"#ff0", "#0f0", "#088", "#0ff", "#00f", "#f0f", "#888", "#ccc"];
}
});
Alice.Input = Class.create({
initialize: function(application, element) {
this.application = application;
this.textarea = $(element);
this.disabled = false;
if (this.canContentEditable()) {
this.editor = WysiHat.Editor.attach(this.textarea);
this.element = this.editor;
this.toolbar = new Alice.Toolbar(this.element)
this.toolbar.addButtonSet(Alice.Toolbar.ButtonSet);
var input = new Element("input", {type: "hidden", name: "html", value: 1});
this.textarea.form.appendChild(input);
document.observe("mousedown", function(e) {
if (!e.findElement(".editor")) this.uncancelNextFocus();
}.bind(this));
this.editor.observe("keydown", function(){this.cancelNextFocus()}.bind(this));
this.editor.observe("keyup", this.updateRange.bind(this));
this.editor.observe("mouseup", this.updateRange.bind(this));
this.editor.observe("paste", this.pasteHandler.bind(this));
this.toolbar.element.on("mouseup","button",function(){
this.cancelNextFocus();
}.bind(this));
} else {
this.element = this.textarea;
this.element.observe("keydown", this.resize.bind(this));
this.element.observe("cut", this.resize.bind(this));
this.element.observe("paste", this.resize.bind(this));
this.element.observe("change", this.resize.bind(this));
}
this.history = [];
this.index = -1;
this.buffer = "";
this.completion = false;
this.focused = false;
if (!this.application.isMobile) this.focus();
this.element.observe("blur", this.onBlur.bind(this));
},
setValue: function(value) {
this.textarea.setValue(value);
if (this.editor) {
this.editor.update(value);
var text = document.createElement("BR");
this.editor.appendChild(text);
}
},
getValue: function() {
if (this.editor) {
return this.editor.innerHTML;
}
return this.textarea.getValue();
},
onKeyPress: function(event) {
if (event.keyCode != Event.KEY_TAB) {
this.completion = false;
this.element.stopObserving("keypress");
}
},
uncancelNextFocus: function() {
this.skipThisFocus = false;
},
cancelNextFocus: function() {
this.skipThisFocus = true;
},
focus: function(force) {
if (this.disabled) return;
if (!force) {
if (this.focused) return;
if (this.skipThisFocus) {
this.skipThisFocus = false;
return;
}
}
this.focused = true;
if (this.editor) {
var selection = window.getSelection();
selection.removeAllRanges();
if (this.range) {
selection.addRange(this.range);
} else {
var text = document.createTextNode("");
this.editor.appendChild(text);
selection.selectNode(text);
this.range = selection.getRangeAt(0);
}
this.editor.focus();
} else {
this.textarea.focus();
}
},
onBlur: function(e) {
this.focused = false;
},
previousCommand: function() {
if (this.index-- == -1) {
this.index = this.history.length - 1;
this.stash();
}
this.update();
},
nextCommand: function() {
if (this.index++ == -1) {
this.stash();
} else if (this.index == this.history.length) {
this.index = -1;
}
this.update();
},
newLine: function() {
this.application.log("newLine");
},
send: function() {
var msg = this.getValue();
if (msg.length > 1024*2) {
alert("That message is way too long, dude.");
return;
}
if (this.editor) this.textarea.value = msg;
var success = this.application.connection.sendMessage(this.textarea.form);
if (success) {
this.history.push(msg);
this.setValue("");
if (this.editor) this.editor.update();
this.index = -1;
this.stash();
this.update();
this.focus(1);
}
else {
alert("Could not send message, not connected!");
}
},
completeNickname: function(prev) {
if (this.disabled) return;
if (!this.completion) {
this.completion = new Alice.Completion(this.application.activeWindow().getNicknames(), this.editor);
this.element.observe("keypress", this.onKeyPress.bind(this));
}
if (prev)
this.completion.prev();
else
this.completion.next();
},
stopCompletion: function() {
if (this.completion) {
this.completion.restore();
this.completion = false;
this.element.stopObserving("keypress");
}
},
stash: function() {
this.buffer = this.getValue();
},
update: function() {
this.setValue(this.getCommand(this.index));
},
getCommand: function(index) {
if (index == -1) {
return this.buffer;
} else {
return this.history[index];
}
},
resize: function() {
(function() {
var height = this.getContentHeight();
if (height == 0) {
this.element.setStyle({ height: null, top: 0 });
} else if (height <= 150) {
this.element.setStyle({ height: height + "px", top: "0px" });
}
}).bind(this).defer();
},
getContentHeight: function() {
var element = new Element("div").setStyle({
position: "absolute",
visibility: "hidden",
left: "-" + this.element.getWidth() + "px",
width: this.element.getWidth() - 7 + "px",
fontFamily: this.element.getStyle("fontFamily"),
fontSize: this.element.getStyle("fontSize"),
lineHeight: this.element.getStyle("lineHeight"),
whiteSpace: "pre-wrap",
wordWrap: "break-word"
});
if (this.editor) element.addClassName("editor");
var value = this.getValue();
element.update(value.replace(/\n$/, "\n\n").replace("\n", "<br>"));
$(document.body).insert(element);
var height = element.getHeight();
element.remove();
return height;
},
canContentEditable: function() {
var element = new Element("div", {contentEditable: "true"});
return ! (element.contentEditable == null || this.application.isMobile || Prototype.Browser.IE);
},
updateRange: function (e) {
var selection = window.getSelection();
if (selection.rangeCount > 0) {
var range = selection.getRangeAt(0);
this.range = range;
}
},
pasteHandler: function(e) {
if (!e.clipboardData) return;
var items = e.clipboardData.items;
if (items) {
var output = "";
for (var i=0; i < items.length; i++) {
var blob = items[i].getAsFile();
if (blob && blob.type.match(/image/)) {
e.stop();
var fd = new FormData();
fd.append("image", blob);
fd.append("key", "f1f60f1650a07bfe5f402f35205dffd4");
var xhr = new XMLHttpRequest();
xhr.open("POST", "http://api.imgur.com/2/upload.json");
xhr.onload = function() {
var url = xhr.responseText.evalJSON();
this.editor.insertHTML(url.upload.links.original);
this.updateRange();
}.bind(this);
xhr.send(fd);
return;
}
}
}
var text = e.clipboardData.getData("Text");
if (text) {
e.preventDefault();
text = text.escapeHTML().replace(/\n+/g, "<br>\n");
this.editor.insertHTML(text);
this.updateRange();
return;
}
var url = e.clipboardData.getData("URL");
if (url) {
e.preventDefault();
this.editor.insertHTML(url);
this.updateRange();
return;
}
}
});
Alice.Keyboard = Class.create({
initialize: function(application) {
this.application = application;
this.isMac = navigator.platform.match(/mac/i);
this.lastCycle = 0;
this.cycleDelay = 300;
this.enable();
if (!this.application.isMobile) {
this.shortcut("Cmd+C", { propagate: true });
this.shortcut("Ctrl+C", { propagate: true });
this.shortcut("Cmd+B");
this.shortcut("Cmd+I");
this.shortcut("Cmd+Shift+U");
this.shortcut("Opt+Up");
this.shortcut("Opt+Down");
this.shortcut("Cmd+Shift+M");
this.shortcut("Cmd+Shift+J");
this.shortcut("Cmd+Shift+K");
this.shortcut("Cmd+K");
this.shortcut("Cmd+Shift+Left");
this.shortcut("Cmd+Shift+Right");
this.shortcut("Cmd+Shift+H");
this.shortcut("Cmd+Shift+L");
this.shortcut("Cmd+U");
this.shortcut("Esc");
this.shortcut("Cmd", { propagate: true });
this.shortcut("Tab", { propagate: true });
this.shortcut("Shift+Tab", { propagate: true });
for (var i = 0; i < 10; i++) {
this.shortcut("Cmd+"+i);
if (!this.isMac) this.shortcut("Opt+"+i);
}
}
this.shortcut("Enter");
},
shortcut: function(name, options) {
var meta = this.isMac ? "Meta" : "Ctrl";
var keystroke = name.replace("Cmd", meta).replace("Opt", "Alt"),
method = "on" + name.replace(/\+/g, "");
window.shortcut.add(keystroke, function(event) {
if (this.enabled) {
this.activeWindow = this.application.activeWindow();
if (method.match(/\d$/)) {
this.onNumeric.call(this, event, method.substr(-1));
}
else {
this[method].call(this, event);
}
delete this.activeWindow;
}
}.bind(this), options);
},
onCmd: function(e) {
if (e.keyCode == 186) {
e.stop();
this.application.nextUnreadWindow();
}
},
onNumeric: function(event, number) {
var win = this.application.nth_window(number);
if (number == 0) {
win = this.application.info_window();
}
if (win) win.focus();
},
onCmdC: function(event) {
this.application.input.cancelNextFocus();
},
onCtrlC: function(event) {
this.onCmdC(event);
},
onCmdK: function() {
this.activeWindow.clearMessages();
this.application.connection.sendMessage({
msg: "/clear",
source: this.activeWindow.id,
});
},
onCmdB: function() {
if (this.application.input.editor) {
this.application.input.focus();
this.application.input.editor.boldSelection();
}
},
onCmdShiftU: function() {
if (this.application.input.editor) {
this.application.input.focus();
this.application.input.editor.underlineSelection();
}
},
onCmdI: function() {
if (this.application.input.editor) {
this.application.input.focus();
this.application.input.editor.italicSelection();
}
},
onCmdU: function() {
this.application.nextUnreadWindow();
},
onCmdShiftM: function() {
this.application.windows().invoke('markRead');
( run in 1.633 second using v1.01-cache-2.11-cpan-2398b32b56e )