App-Alice
view release on metacpan or search on metacpan
lib/App/Alice/History.pm view on Meta::CPAN
);
has dbfile => (
is => 'ro',
isa => 'Str',
#required => 1,
);
sub store {
my ($self, %fields) = @_;
my ($stmt, @bind) = $self->sql->insert("messages", \%fields);
$self->dbi->exec($stmt, @bind, sub {});
}
sub range {
my $cb = pop;
my ($self, $user, $channel, $id, $limit) = @_;
$limit ||=5;
$self->dbi->exec(
"SELECT * FROM messages WHERE id < ? AND channel=? AND user=? ORDER BY id DESC LIMIT ?",
$id, $channel, $user, $limit, sub {
my $before = [ reverse @{$_[1]} ];
lib/App/Alice/History.pm view on Meta::CPAN
);
}
);
}
sub search {
my $cb = pop;
my ($self, %query) = @_;
%query = map {$_ => "%$query{$_}%"} grep {$query{$_}} qw/body channel nick user/;
my ($stmt, @bind) = $self->sql->select("messages", '*', \%query, {-desc => 'id'});
$self->dbi->exec($stmt, @bind, sub {
my ($db, $rows, $rv) = @_;
$cb->($rows);
});
}
__PACKAGE__->meta->make_immutable;
1;
share/static/alice.js view on Meta::CPAN
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: {
share/static/alice.js view on Meta::CPAN
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);
share/static/alice.js view on Meta::CPAN
}
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
}
})());
share/static/alice.js view on Meta::CPAN
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;
share/static/alice.js view on Meta::CPAN
}
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();
}
share/static/alice.js view on Meta::CPAN
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();
share/static/alice.js view on Meta::CPAN
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) {
share/static/alice.js view on Meta::CPAN
});
}
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) ||
share/static/alice.js view on Meta::CPAN
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);
share/static/alice.js view on Meta::CPAN
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;
};
share/static/alice.js view on Meta::CPAN
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);
}
share/static/alice.js view on Meta::CPAN
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;
share/static/alice.js view on Meta::CPAN
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();
share/static/alice.js view on Meta::CPAN
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() {
share/static/alice.js view on Meta::CPAN
}, 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,
share/static/alice.js view on Meta::CPAN
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] || { },
share/static/alice.js view on Meta::CPAN
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) {
share/static/alice.js view on Meta::CPAN
},
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
share/static/alice.js view on Meta::CPAN
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 });
share/static/alice.js view on Meta::CPAN
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;
},
share/static/alice.js view on Meta::CPAN
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);
},
share/static/alice.js view on Meta::CPAN
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
share/static/alice.js view on Meta::CPAN
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;
share/static/alice.js view on Meta::CPAN
'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('');
share/static/alice.js view on Meta::CPAN
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
share/static/alice.js view on Meta::CPAN
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;
share/static/alice.js view on Meta::CPAN
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);
share/static/alice.js view on Meta::CPAN
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 {
share/static/alice.js view on Meta::CPAN
this.window_map = new Hash();
this.previousFocus = 0;
this.connection = new Alice.Connection(this);
this.filters = [];
this.keyboard = new Alice.Keyboard(this);
this.isPhone = window.navigator.platform.match(/(android|iphone)/i) ? 1 : 0;
this.isMobile = this.isPhone || Prototype.Browser.MobileSafari;
window.onload = function () {
setTimeout(this.connection.connect.bind(this.connection), 1000);
}.bind(this);
this.makeSortable();
},
actionHandlers: {
join: function (action) {
var win = this.getWindow(action['window'].id);
if (!win) {
this.insertWindow(action['window'].id, action.html);
win = new Alice.Window(this, action['window'].id, action['window'].title, false, action['window'].hashtag);
share/static/alice.js view on Meta::CPAN
win.messages.down("ul").update("");
win.lastNick = "";
}
},
connect: function (action) {
action.windows.each(function (win_info) {
var win = this.getWindow(win_info.id);
if (win) {
win.enable();
}
}.bind(this));
if ($('servers')) {
Alice.connections.connectServer(action.session);
}
},
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.session);
}
},
focus: function (action) {
if (!action.window_number) return;
if (action.window_number == "next") {
this.nextWindow();
}
else if (action.window_number.match(/^prev/)) {
share/static/alice.js view on Meta::CPAN
toggleHelp: function() {
var help = $('help');
help.visible() ? help.hide() : help.show();
},
toggleConfig: function(e) {
this.connection.getConfig(function (transport) {
alice.activeWindow().input.disabled = true;
$('container').insert(transport.responseText);
}.bind(this));
e.stop();
},
togglePrefs: function(e) {
this.connection.getPrefs(function (transport) {
alice.activeWindow().input.disabled = true;
$('container').insert(transport.responseText);
}.bind(this));
e.stop();
},
toggleLogs: function(e) {
if (this.logWindow && !this.logWindow.closed && this.logWindow.focus) {
this.logWindow.focus();
} else {
this.logWindow = window.open(null, "logs", "resizable=no,scrollbars=no,statusbar=no, toolbar=no,location=no,width=500,height=480");
this.connection.getLog(function (transport) {
this.logWindow.document.write(transport.responseText);
}.bind(this));
}
e.stop();
},
windows: function () {
return this.window_map.values();
},
nth_window: function(n) {
share/static/alice.js view on Meta::CPAN
this.addWindow(win);
if (active) {
win.focus();
}
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) {
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);
share/static/alice.js view on Meta::CPAN
overlap: 'horizontal',
constraint: 'horizontal',
format: /(.+)/,
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);
}.bind(this)
});
},
addMissed: function() {
if (!window.fluid) return;
window.fluid.dockBadge ? window.fluid.dockBadge++ :
window.fluid.dockBadge = 1;
},
clearMissed: function() {
share/static/alice.js view on Meta::CPAN
return;
}
this.closeConnection();
this.len = 0;
this.reconnect_count++;
var now = new Date();
console.log("opening new connection starting at message " + this.msgid);
this.request = new Ajax.Request('/stream', {
method: 'get',
parameters: {msgid: this.msgid, t: now.getTime() / 1000},
onException: this.handleException.bind(this),
onInteractive: this.handleUpdate.bind(this),
onComplete: this.handleComplete.bind(this)
});
},
reconnect: function () {
this.reconnecting = true;
this.reconnect_count = 0;
this.connect();
},
handleException: function(request, exception) {
console.log("encountered an error with stream.");
if (!this.aborting)
setTimeout(this.connect.bind(this), 2000);
},
handleComplete: function(transport) {
console.log("connection was closed cleanly.");
if (!this.aborting)
setTimeout(this.connect.bind(this), 2000);
},
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);
share/static/alice.js view on Meta::CPAN
requestWindow: function(title, windowId, message) {
new Ajax.Request('/say', {
method: 'post',
parameters: {source: windowId, msg: "/create " + title},
onSuccess: function (transport) {
this.handleUpdate(transport);
if (message) {
setTimeout(function() {
this.application.displayMessage(message)
}.bind(this), 1000);
}
}.bind(this)
});
},
closeWindow: function(win) {
new Ajax.Request('/say', {
method: 'post',
parameters: {source: win.id, msg: "/close"}
});
},
share/static/alice.js view on Meta::CPAN
this.topic = $(this.id + "_topic");
if (this.topic) {
var orig_height = this.topic.getStyle("height");
this.topic.observe("click", function(e) {
if (this.topic.getStyle("height") == orig_height) {
this.topic.setStyle({height: "auto"});
} else {
this.topic.setStyle({height: orig_height});
}
}.bind(this));
}
this.messages = this.element.down('.message_wrap');
this.submit = $(this.id + "_submit");
this.nicksVisible = false;
this.visibleNick = "";
this.visibleNickTimeout = "";
this.nicks = [];
this.messageLimit = 250;
this.submit.observe("click", function (e) {this.input.send(); e.stop()}.bind(this));
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) this.close()}.bind(this));
this.messages.observe("mouseover", this.showNick.bind(this));
if (Prototype.Browser.Gecko) {
this.resizeMessagearea();
this.scrollToBottom();
}
else if (this.application.isMobile) {
this.messageLimit = 50;
this.messages.select("li").reverse().slice(50).invoke("remove");
}
if (this.active) this.scrollToBottom(true);
this.makeTopicClickable();
setTimeout(function () {
this.messages.select('li.message div.msg').each(function (msg) {
msg.innerHTML = application.applyFilters(msg.innerHTML);
});
}.bind(this), 1000);
},
isTabWrapped: function() {
return this.tab.offsetTop > 0;
},
unFocus: function() {
this.active = false;
share/static/alice.js view on Meta::CPAN
setTimeout(function(){
if (this.nicksVisible) return;
if (nick) {
nick.style.webkitTransition = "opacity 0.25s ease-in";
nick.style.opacity = 0;
}
if (time) {
time.style.webkitTransition = "opacity 0.25s ease-in";
time.style.opacity = 0;
}
}.bind(this, nick, time) , 1000);
}.bind(this, nick, time), 500);
}
}
else {
this.visibleNick = "";
clearTimeout(this.visibleNickTimeout);
}
},
toggleNicks: function () {
if (this.nicksVisible) {
share/static/alice.js view on Meta::CPAN
this.tab.addClassName("highlight");
}
}
var messages = this.messages.down('ul').childElements();
if (messages.length > this.messageLimit) messages.first().remove();
li.select("span.timestamp").each(function(elem) {
elem.innerHTML = Alice.epochToLocal(elem.innerHTML.strip(), this.application.options.timeformat);
elem.style.opacity = 1;
}.bind(this));
this.element.redraw();
},
scrollToBottom: function(force) {
var bottom, height;
if (!force) {
var lastmsg = this.messages.down('ul.messages > li:last-child');
if (!lastmsg) return;
share/static/alice.js view on Meta::CPAN
return button;
},
observeButtonClick: function(element, handler) {
element.on('click', function(event) {
handler(this.editor, element, this);
this.editor.fire("selection:change");
event.stop();
}.bind(this));
}
});
Alice.Toolbar.ButtonSet = WysiHat.Toolbar.ButtonSets.Basic.concat(
[
{
label: "Colors",
handler: function (editor, button, toolbar) {
var cb = function (color, fg) {
fg ? editor.colorSelection(color) : editor.backgroundColorSelection(color)
share/static/alice.js view on Meta::CPAN
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);
button.up('.window').insert(elem);
elem.observe("mousedown", this.clicked.bind(this));
this.elem = elem;
this.cb = callback;
this.fg = true;
},
clicked: function(e) {
e.stop();
var box = e.findElement("span.color");
share/static/alice.js view on Meta::CPAN
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);
this.toolbar.element.observe("click", function(e) {
if (this.toolbar.element.hasClassName("visible")) return;
this.toolbar.element.addClassName("visible");
this.focus();
}.bind(this));
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.history = [];
this.index = -1;
this.buffer = "";
this.completion = false;
this.focused = false;
this.element.observe("keypress", this.onKeyPress.bind(this));
this.element.observe("blur", this.onBlur.bind(this));
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));
},
setValue: function(value) {
this.editor ? this.editor.update(value) : this.textarea.setValue(value);
},
getValue: function() {
if (this.editor) {
return this.editor.innerHTML;
share/static/alice.js view on Meta::CPAN
this.textarea.setValue(this.editor.innerHTML);
}
(function() {
if (!this.window.active) return;
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: "-1px" });
}
}).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"),
share/static/alice.js view on Meta::CPAN
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);
},
onNumeric: function(event, number) {
var win = this.application.nth_window(number);
if (win) win.focus();
},
onCmdC: function(event) {
if (!this.activeWindow.input.focused)
this.activeWindow.input.cancelNextFocus();
share/static/alice.js view on Meta::CPAN
alice.isFocused = true
alice.clearMissed();
};
window.status = " ";
window.onblur = function () {
if (!alice.isMobile)
window.document.body.addClassName("blurred");
alice.isFocused = false
};
window.onhashchange = alice.focusHash.bind(alice);
window.onorientationchange = function() {
alice.activeWindow().scrollToBottom(true);
};
alice.addFilters([
function(content) {
var filtered = content;
filtered = filtered.replace(
( run in 1.792 second using v1.01-cache-2.11-cpan-2398b32b56e )