Alice
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
}
sub autoload {
my $self = shift;
my $who = $self->_caller;
my $cwd = Cwd::cwd();
my $sym = "${who}::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
Unknown function is found at $file line $line.
lib/Alice/HTTP/Request.pm view on Meta::CPAN
package Alice::HTTP::Request;
use Alice::HTTP::Response;
use Encode;
use parent 'Plack::Request';
sub new {
my($class, $env, $cb) = @_;
Carp::croak(q{$env is required})
unless defined $env && ref($env) eq 'HASH';
Carp::croak(q{$cb is required})
unless defined $cb && ref($cb) eq 'CODE';
bless { env => $env, cb => $cb }, $class;
lib/Alice/HTTP/Response.pm view on Meta::CPAN
package Alice::HTTP::Response;
use parent 'Plack::Response';
use Encode;
sub new {
my($class, $cb, $rc, $headers, $content) = @_;
Carp::croak(q{$cb is required})
unless defined $cb && ref($cb) eq 'CODE';
my $self = bless {cb => $cb}, $class;
$self->status($rc) if defined $rc;
lib/Alice/HTTP/WebSocket.pm view on Meta::CPAN
package Alice::HTTP::WebSocket;
use strict;
use warnings;
use parent 'Plack::Middleware';
our $VERSION = '0.01';
my $MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
sub call {
my ($self, $env) = @_;
$env->{'websocket.impl'} = Alice::HTTP::WebSocket::Impl->new($env);
return $self->app->($env);
share/static/alice-dark.css view on Meta::CPAN
li.fold + li div.msg {
border-top: 1px solid #333333 !important; }
li.event div.msg {
padding: 5px; }
li.monospaced div.msg {
padding: 7px 5px; }
li.event + li.message div.msg {
border-top: 1px solid transparent; }
ul.messages li:first-child div.msg {
border-top: 1px solid transparent; }
/* so the last avatar doesn't hang off the edge */
ul.messages li.avatar:not(.consecutive) div.msg {
min-height: 35px; }
ul.messages li.monospaced.avatar:not(.consecutive) div.msg {
min-height: 24px; }
.noavatars ul.messages li.avatar:not(.consecutive) div.msg {
min-height: 0px; }
share/static/alice-default.css view on Meta::CPAN
li.fold + li div.msg {
border-top: 1px solid #cccccc !important; }
li.event div.msg {
padding: 5px; }
li.monospaced div.msg {
padding: 7px 5px; }
li.event + li.message div.msg {
border-top: 1px solid transparent; }
ul.messages li:first-child div.msg {
border-top: 1px solid transparent; }
/* so the last avatar doesn't hang off the edge */
ul.messages li.avatar:not(.consecutive) div.msg {
min-height: 35px; }
ul.messages li.monospaced.avatar:not(.consecutive) div.msg {
min-height: 24px; }
.noavatars ul.messages li.avatar:not(.consecutive) div.msg {
min-height: 0px; }
share/static/alice-solarized.css view on Meta::CPAN
div#connection_status {
display: none;
width: 24px;
height: 24px;
position: absolute;
bottom: 0px;
left: 0px;
z-index: 904;
background-color: #586e75;
border-top: 1px solid transparent; }
body {
font-family: "Lucida Grande", Helvetica, sans-serif;
text-rendering: optimizeLegibility;
background: #fdf6e3; }
a:link, a:visited, a:active {
color: #fdf6e3; }
a:hover {
share/static/alice-solarized.css view on Meta::CPAN
div#nicklist_toggle {
position: absolute;
text-align: center;
width: 0px;
height: 50px;
margin-top: -25px;
top: 50%;
right: 15px;
background: url(image/slider.png) center center no-repeat;
background-color: #586e75;
border: 1px solid transparent;
-webkit-box-shadow: 1px 1px 3px rgba(0, 0, 0, 0.2);
-webkit-transition-property: opacity, width;
-webkit-transition-duration: 0.3s, 0.2s;
-webkit-transition-timing-function: ease-in-out;
-moz-transition-property: opacity, width;
-moz-transition-duration: 0.3s, 0.2s;
-moz-transition-timing-function: ease-in-out;
border-radius: 2px;
color: white;
font-size: 14px;
share/static/alice-solarized.css view on Meta::CPAN
background: url(image/sprites.png) 0px -300px repeat-x #586e75;
opacity: 1 !important; }
ul#tabs li.hidden {
display: none; }
ul#tabs li.visible {
display: block; }
ul#tabs li div.hit_area {
border: 1px solid transparent;
border-bottom: none;
border-top: none;
float: left;
height: 14px;
padding: 4px 10px 7px 4px; }
ul#tabs li.active div.hit_area {
border: 1px solid #44555a;
border-top: none;
background: #657b83;
share/static/alice-solarized.css view on Meta::CPAN
li.fold + li div.msg {
border-top: 1px solid #93a1a1 !important; }
li.event div.msg {
padding: 5px; }
li.monospaced div.msg {
padding: 7px 5px; }
li.event + li.message div.msg {
border-top: 1px solid transparent; }
ul.messages li:first-child div.msg {
border-top: 1px solid transparent; }
/* so the last avatar doesn't hang off the edge */
ul.messages li.avatar:not(.consecutive) div.msg {
min-height: 35px; }
ul.messages li.monospaced.avatar:not(.consecutive) div.msg {
min-height: 24px; }
.noavatars ul.messages li.avatar:not(.consecutive) div.msg {
min-height: 0px; }
share/static/alice.js view on Meta::CPAN
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;
share/static/alice.js view on Meta::CPAN
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 = { };
share/static/alice.js view on Meta::CPAN
},
show: function(element) {
element = $(element);
element.style.display = '';
return element;
},
remove: function(element) {
element = $(element);
element.parentNode.removeChild(element);
return element;
},
update: (function(){
var SELECT_ELEMENT_INNERHTML_BUGGY = (function(){
var el = document.createElement("select"),
isBuggy = true;
el.innerHTML = "<option value=\"test\">test</option>";
if (el.options && el.options[0]) {
share/static/alice.js view on Meta::CPAN
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};
share/static/alice.js view on Meta::CPAN
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(),
share/static/alice.js view on Meta::CPAN
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);
share/static/alice.js view on Meta::CPAN
match: function(element, selector) {
element = $(element);
if (Object.isString(selector))
return Prototype.Selector.match(element, selector);
return selector.match(element);
},
up: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(element.parentNode);
var ancestors = Element.ancestors(element);
return Object.isNumber(expression) ? ancestors[expression] :
Prototype.Selector.find(ancestors, expression, index);
},
down: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return Element.firstDescendant(element);
return Object.isNumber(expression) ? Element.descendants(element)[expression] :
Element.select(element, expression)[index || 0];
share/static/alice.js view on Meta::CPAN
select: function(element) {
element = $(element);
var expressions = Array.prototype.slice.call(arguments, 1).join(', ');
return Prototype.Selector.select(expressions, element);
},
adjacent: function(element) {
element = $(element);
var expressions = Array.prototype.slice.call(arguments, 1).join(', ');
return Prototype.Selector.select(expressions, element.parentNode).without(element);
},
identify: function(element) {
element = $(element);
var id = Element.readAttribute(element, 'id');
if (id) return id;
do { id = 'anonymous_element_' + Element.idCounter++ } while ($(id));
Element.writeAttribute(element, 'id', id);
return id;
},
share/static/alice.js view on Meta::CPAN
descendantOf: function(element, ancestor) {
element = $(element), ancestor = $(ancestor);
if (element.compareDocumentPosition)
return (element.compareDocumentPosition(ancestor) & 8) === 8;
if (ancestor.contains)
return ancestor.contains(element) && ancestor !== element;
while (element = element.parentNode)
if (element == ancestor) return true;
return false;
},
scrollTo: function(element) {
element = $(element);
var pos = Element.cumulativeOffset(element);
window.scrollTo(pos[0], pos[1]);
return element;
share/static/alice.js view on Meta::CPAN
var options = Object.extend({
setLeft: true,
setTop: true,
setWidth: true,
setHeight: true,
offsetTop: 0,
offsetLeft: 0
}, arguments[2] || { });
source = $(source);
var p = Element.viewportOffset(source), delta = [0, 0], parent = null;
element = $(element);
if (Element.getStyle(element, 'position') == 'absolute') {
parent = Element.getOffsetParent(element);
delta = Element.viewportOffset(parent);
}
if (parent == document.body) {
delta[0] -= document.body.offsetLeft;
delta[1] -= document.body.offsetTop;
}
if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
if (options.setWidth) element.style.width = source.offsetWidth + 'px';
if (options.setHeight) element.style.height = source.offsetHeight + 'px';
return element;
}
share/static/alice.js view on Meta::CPAN
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];
share/static/alice.js view on Meta::CPAN
}
}
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]
}
};
share/static/alice.js view on Meta::CPAN
element.runtimeStyle.left = element.currentStyle.left;
element.style.left = value || 0;
value = element.style.pixelLeft;
element.style.left = style;
element.runtimeStyle.left = rStyle;
return value;
}
if (element && isPercentage) {
context = context || element.parentNode;
var decimal = toDecimal(value);
var whole = null;
var position = element.getStyle('position');
var isHorizontal = property.include('left') || property.include('right') ||
property.include('width');
var isVertical = property.include('top') || property.include('bottom') ||
property.include('height');
share/static/alice.js view on Meta::CPAN
function toCSSPixels(number) {
if (Object.isString(number) && number.endsWith('px')) {
return number;
}
return number + 'px';
}
function isDisplayed(element) {
var originalElement = element;
while (element && element.parentNode) {
var display = element.getStyle('display');
if (display === 'none') {
return false;
}
element = $(element.parentNode);
}
return true;
}
var hasLayout = Prototype.K;
if ('currentStyle' in document.documentElement) {
hasLayout = function(element) {
if (!element.currentStyle.hasLayout) {
element.style.zoom = 1;
}
share/static/alice.js view on Meta::CPAN
var position = element.getStyle('position'),
width = element.getStyle('width');
if (width === "0px" || width === null) {
element.style.display = 'block';
width = element.getStyle('width');
}
var context = (position === 'fixed') ? document.viewport :
element.parentNode;
element.setStyle({
position: 'absolute',
visibility: 'hidden',
display: 'block'
});
var positionedWidth = element.getStyle('width');
var newWidth;
if (width && (positionedWidth === width)) {
newWidth = getPixelValue(element, 'width', context);
} else if (position === 'absolute' || position === 'fixed') {
newWidth = getPixelValue(element, 'width', context);
} else {
var parent = element.parentNode, pLayout = $(parent).getLayout();
newWidth = pLayout.get('width') -
this.get('margin-left') -
this.get('border-left') -
this.get('padding-left') -
this.get('padding-right') -
this.get('border-right') -
this.get('margin-right');
}
share/static/alice.js view on Meta::CPAN
return bWidth + mLeft + mRight;
},
'top': function(element) {
var offset = element.positionedOffset();
return offset.top;
},
'bottom': function(element) {
var offset = element.positionedOffset(),
parent = element.getOffsetParent(),
pHeight = parent.measure('height');
var mHeight = this.get('border-box-height');
return pHeight - mHeight - offset.top;
},
'left': function(element) {
var offset = element.positionedOffset();
return offset.left;
},
'right': function(element) {
var offset = element.positionedOffset(),
parent = element.getOffsetParent(),
pWidth = parent.measure('width');
var mWidth = this.get('border-box-width');
return pWidth - mWidth - offset.left;
},
'padding-top': function(element) {
return getPixelValue(element, 'paddingTop');
},
share/static/alice.js view on Meta::CPAN
'margin-right': function(element) {
return getPixelValue(element, 'marginRight');
}
}
});
if ('getBoundingClientRect' in document.documentElement) {
Object.extend(Element.Layout.COMPUTATIONS, {
'right': function(element) {
var parent = hasLayout(element.getOffsetParent());
var rect = element.getBoundingClientRect(),
pRect = parent.getBoundingClientRect();
return (pRect.right - rect.right).round();
},
'bottom': function(element) {
var parent = hasLayout(element.getOffsetParent());
var rect = element.getBoundingClientRect(),
pRect = parent.getBoundingClientRect();
return (pRect.bottom - rect.bottom).round();
}
});
}
Element.Offset = Class.create({
initialize: function(left, top) {
this.left = left.round();
this.top = top.round();
share/static/alice.js view on Meta::CPAN
function getOffsetParent(element) {
element = $(element);
if (isDocument(element) || isDetached(element) || isBody(element) || isHtml(element))
return $(document.body);
var isInline = (Element.getStyle(element, 'display') === 'inline');
if (!isInline && element.offsetParent) return $(element.offsetParent);
while ((element = element.parentNode) && element !== document.body) {
if (Element.getStyle(element, 'position') !== 'static') {
return isHtml(element) ? $(document.body) : $(element);
}
}
return $(document.body);
}
function cumulativeOffset(element) {
element = $(element);
var valueT = 0, valueL = 0;
if (element.parentNode) {
do {
valueT += element.offsetTop || 0;
valueL += element.offsetLeft || 0;
element = element.offsetParent;
} while (element);
}
return new Element.Offset(valueL, valueT);
}
function positionedOffset(element) {
share/static/alice.js view on Meta::CPAN
valueT -= layout.get('margin-left');
return new Element.Offset(valueL, valueT);
}
function cumulativeScrollOffset(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.scrollTop || 0;
valueL += element.scrollLeft || 0;
element = element.parentNode;
} while (element);
return new Element.Offset(valueL, valueT);
}
function viewportOffset(forElement) {
element = $(element);
var valueT = 0, valueL = 0, docBody = document.body;
var element = forElement;
do {
share/static/alice.js view on Meta::CPAN
if (element.offsetParent == docBody &&
Element.getStyle(element, 'position') == 'absolute') break;
} while (element = element.offsetParent);
element = forElement;
do {
if (element != docBody) {
valueT -= element.scrollTop || 0;
valueL -= element.scrollLeft || 0;
}
} while (element = element.parentNode);
return new Element.Offset(valueL, valueT);
}
function absolutize(element) {
element = $(element);
if (Element.getStyle(element, 'position') === 'absolute') {
return element;
}
share/static/alice.js view on Meta::CPAN
element.setStyle({ position: 'relative' });
var value = proceed(element);
element.setStyle({ position: position });
return value;
}
);
positionedOffset = positionedOffset.wrap(function(proceed, element) {
element = $(element);
if (!element.parentNode) return new Element.Offset(0, 0);
var position = element.getStyle('position');
if (position !== 'static') return proceed(element);
var offsetParent = element.getOffsetParent();
if (offsetParent && offsetParent.getStyle('position') === 'fixed')
hasLayout(offsetParent);
element.setStyle({ position: 'relative' });
var value = proceed(element);
element.setStyle({ position: position });
share/static/alice.js view on Meta::CPAN
} else {
if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
var ret = Sizzle.find( parts.shift(), context, contextXML );
context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
}
if ( context ) {
var ret = seed ?
{ expr: parts.pop(), set: makeArray(seed) } :
Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
if ( parts.length > 0 ) {
checkSet = makeArray(set);
} else {
prune = false;
}
while ( parts.length ) {
var cur = parts.pop(), pop = cur;
share/static/alice.js view on Meta::CPAN
},
">": function(checkSet, part, isXML){
var isPartStr = typeof part === "string";
if ( isPartStr && !/\W/.test(part) ) {
part = isXML ? part : part.toUpperCase();
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
var parent = elem.parentNode;
checkSet[i] = parent.nodeName === part ? parent : false;
}
}
} else {
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
checkSet[i] = isPartStr ?
elem.parentNode :
elem.parentNode === part;
}
}
if ( isPartStr ) {
Sizzle.filter( part, checkSet, true );
}
}
},
"": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( !/\W/.test(part) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
},
"~": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( typeof part === "string" && !/\W/.test(part) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
share/static/alice.js view on Meta::CPAN
enabled: function(elem){
return elem.disabled === false && elem.type !== "hidden";
},
disabled: function(elem){
return elem.disabled === true;
},
checked: function(elem){
return elem.checked === true;
},
selected: function(elem){
elem.parentNode.selectedIndex;
return elem.selected === true;
},
parent: function(elem){
return !!elem.firstChild;
},
empty: function(elem){
return !elem.firstChild;
},
has: function(elem, i, match){
return !!Sizzle( match[3], elem ).length;
},
header: function(elem){
return /h\d/i.test( elem.nodeName );
share/static/alice.js view on Meta::CPAN
}
return true;
case 'nth':
var first = match[2], last = match[3];
if ( first == 1 && last == 0 ) {
return true;
}
var doneName = match[0],
parent = elem.parentNode;
if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
var count = 0;
for ( node = parent.firstChild; node; node = node.nextSibling ) {
if ( node.nodeType === 1 ) {
node.nodeIndex = ++count;
}
}
parent.sizcache = doneName;
}
var diff = elem.nodeIndex - last;
if ( first == 0 ) {
return diff == 0;
} else {
return ( diff % first == 0 && diff / first >= 0 );
}
}
},
share/static/alice.js view on Meta::CPAN
currentTarget = event.currentTarget;
if (currentTarget && currentTarget.tagName) {
if (type === 'load' || type === 'error' ||
(type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
&& currentTarget.type === 'radio'))
node = currentTarget;
}
if (node.nodeType == Node.TEXT_NODE)
node = node.parentNode;
return Element.extend(node);
}
function findElement(event, expression) {
var element = Event.element(event);
if (!expression) return element;
while (element) {
if (Object.isElement(element) && Prototype.Selector.match(element, expression)) {
return Element.extend(element);
}
element = element.parentNode;
}
}
function pointer(event) {
return { x: pointerX(event), y: pointerY(event) };
}
function pointerX(event) {
var docElement = document.documentElement,
body = document.body || { scrollLeft: 0 };
share/static/alice.js view on Meta::CPAN
Event.extend(event, element);
handler.call(element, event);
};
} else {
if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
(eventName === "mouseenter" || eventName === "mouseleave")) {
if (eventName === "mouseenter" || eventName === "mouseleave") {
responder = function(event) {
Event.extend(event, element);
var parent = event.relatedTarget;
while (parent && parent !== element) {
try { parent = parent.parentNode; }
catch(e) { parent = element; }
}
if (parent === element) return;
handler.call(element, event);
};
}
} else {
responder = function(event) {
Event.extend(event, element);
handler.call(element, event);
};
}
share/static/alice.js view on Meta::CPAN
for (var i = 0, child, cn; child = nodes[i]; i++) {
if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
(classNames && classNames.all(function(name) {
return !name.toString().blank() && cn.include(' ' + name + ' ');
}))))
elements.push(Element.extend(child));
}
return elements;
};
return function(className, parentElement) {
return $(parentElement || document.body).getElementsByClassName(className);
};
}(Element.Methods);
/*--------------------------------------------------------------------------*/
Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
initialize: function(element) {
this.element = $(element);
},
share/static/alice.js view on Meta::CPAN
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();
share/static/alice.js view on Meta::CPAN
deepest = drops[i];
return deepest;
},
isContained: function(element, drop) {
var containmentNode;
if(drop.tree) {
containmentNode = element.treeNode;
} else {
containmentNode = element.parentNode;
}
return drop._containers.detect(function(c) { return containmentNode == c });
},
isAffected: function(point, element, drop) {
return (
(drop.element!=element) &&
((!drop._containers) ||
this.isContained(element, drop)) &&
((!drop.accept) ||
share/static/alice.js view on Meta::CPAN
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;
} else {
this.originalScrollLeft = this.options.scroll.scrollLeft;
this.originalScrollTop = this.options.scroll.scrollTop;
share/static/alice.js view on Meta::CPAN
});
var Sortable = {
SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
sortables: { },
_findRootElement: function(element) {
while (element.tagName.toUpperCase() != "BODY") {
if(element.id && Sortable.sortables[element.id]) return element;
element = element.parentNode;
}
},
options: function(element) {
element = Sortable._findRootElement($(element));
if(!element) return;
return Sortable.sortables[element.id];
},
destroy: function(element){
share/static/alice.js view on Meta::CPAN
},
onHover: function(element, dropon, overlap) {
if(Element.isParent(dropon, element)) return;
if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
return;
} else if(overlap>0.5) {
Sortable.mark(dropon, 'before');
if(dropon.previousSibling != element) {
var oldParentNode = element.parentNode;
element.style.visibility = "hidden"; // fix gecko rendering
dropon.parentNode.insertBefore(element, dropon);
if(dropon.parentNode!=oldParentNode)
Sortable.options(oldParentNode).onChange(element);
Sortable.options(dropon.parentNode).onChange(element);
}
} else {
Sortable.mark(dropon, 'after');
var nextElement = dropon.nextSibling || null;
if(nextElement != element) {
var oldParentNode = element.parentNode;
element.style.visibility = "hidden"; // fix gecko rendering
dropon.parentNode.insertBefore(element, nextElement);
if(dropon.parentNode!=oldParentNode)
Sortable.options(oldParentNode).onChange(element);
Sortable.options(dropon.parentNode).onChange(element);
}
}
},
onEmptyHover: function(element, dropon, overlap) {
var oldParentNode = element.parentNode;
var droponOptions = Sortable.options(dropon);
if(!Element.isParent(dropon, element)) {
var index;
var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
var child = null;
if(children) {
var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
share/static/alice.js view on Meta::CPAN
Sortable.options(oldParentNode).onChange(element);
droponOptions.onChange(element);
}
},
unmark: function() {
if(Sortable._marker) Sortable._marker.hide();
},
mark: function(dropon, position) {
var sortable = Sortable.options(dropon.parentNode);
if(sortable && !sortable.ghosting) return;
if(!Sortable._marker) {
Sortable._marker =
($('dropmarker') || Element.extend(document.createElement('DIV'))).
hide().addClassName('dropmarker').setStyle({position:'absolute'});
document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
}
var offsets = dropon.cumulativeOffset();
Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
if(position=='after')
if(sortable.overlap == 'horizontal')
Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
else
Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
Sortable._marker.show();
},
_tree: function(element, options, parent) {
var children = Sortable.findElements(element, options) || [];
for (var i = 0; i < children.length; ++i) {
var match = children[i].id.match(options.format);
if (!match) continue;
var child = {
id: encodeURIComponent(match ? match[1] : null),
element: element,
parent: parent,
children: [],
position: parent.children.length,
container: $(children[i]).down(options.treeTag)
};
/* Get the element containing the children and recurse over it */
if (child.container)
this._tree(child.container, options, child);
parent.children.push (child);
}
return parent;
},
tree: function(element) {
element = $(element);
var sortableOptions = this.options(element);
var options = Object.extend({
tag: sortableOptions.tag,
treeTag: sortableOptions.treeTag,
only: sortableOptions.only,
name: element.id,
format: sortableOptions.format
}, arguments[1] || { });
var root = {
id: null,
parent: null,
children: [],
container: element,
position: 0
};
return Sortable._tree(element, options, root);
},
/* Construct a [i] index for a particular node */
_constructIndex: function(node) {
var index = '';
do {
if (node.id) index = '[' + node.position + ']' + index;
} while ((node = node.parent) != null);
return index;
},
sequence: function(element) {
element = $(element);
var options = Object.extend(this.options(element), arguments[1] || { });
return $(this.findElements(element, options) || []).map( function(item) {
return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
});
},
setSequence: function(element, new_sequence) {
element = $(element);
var options = Object.extend(this.options(element), arguments[2] || { });
var nodeMap = { };
this.findElements(element, options).each( function(n) {
if (n.id.match(options.format))
nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
n.parentNode.removeChild(n);
});
new_sequence.each(function(ident) {
var n = nodeMap[ident];
if (n) {
n[1].appendChild(n[0]);
delete nodeMap[ident];
}
});
},
share/static/alice.js view on Meta::CPAN
}).flatten().join('&');
} else {
return Sortable.sequence(element, arguments[1]).map( function(item) {
return name + "[]=" + encodeURIComponent(item);
}).join('&');
}
}
};
Element.isParent = function(child, element) {
if (!child.parentNode || child == element) return false;
if (child.parentNode == element) return true;
return Element.isParent(child.parentNode, element);
};
Element.findChildren = function(element, only, recursive, tagName) {
if(!element.hasChildNodes()) return null;
tagName = tagName.toUpperCase();
if(only) only = [only].flatten();
var elements = [];
$A(element.childNodes).each( function(e) {
if(e.tagName && e.tagName.toUpperCase()==tagName &&
(!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
share/static/alice.js view on Meta::CPAN
var ths = this;
shortcut_combination = shortcut_combination.toLowerCase();
var func = function(e) {
e = e || window.event;
if(opt['disable_in_input']) { //Don't enable shortcut keys in Input, Textarea fields
var element;
if(e.target) element=e.target;
else if(e.srcElement) element=e.srcElement;
if(element.nodeType==3) element=element.parentNode;
if(element.tagName == 'INPUT' || element.tagName == 'TEXTAREA') return;
}
if (e.keyCode) code = e.keyCode;
else if (e.which) code = e.which;
var character = String.fromCharCode(code).toLowerCase();
if(code == 188) character=","; //If the user presses , when the type is onkeydown
if(code == 190) character="."; //If the user presses , when the type is onkeydown
share/static/alice.js view on Meta::CPAN
*/
if (!window.getSelection) {
var DOMUtils = {
isDataNode: function(node) {
try {
return node && node.nodeValue !== null && node.data !== null;
} catch (e) {
return false;
}
},
isAncestorOf: function(parent, node) {
if (!parent) return false;
return !DOMUtils.isDataNode(parent) &&
(parent.contains(DOMUtils.isDataNode(node) ? node.parentNode : node) ||
node.parentNode == parent);
},
isAncestorOrSelf: function(root, node) {
return DOMUtils.isAncestorOf(root, node) || root == node;
},
findClosestAncestor: function(root, node) {
if (DOMUtils.isAncestorOf(root, node))
while (node && node.parentNode != root)
node = node.parentNode;
return node;
},
getNodeLength: function(node) {
return DOMUtils.isDataNode(node) ? node.length : node.childNodes.length;
},
splitDataNode: function(node, offset) {
if (!DOMUtils.isDataNode(node))
return false;
var newNode = node.cloneNode(false);
node.deleteData(offset, node.length);
newNode.deleteData(0, offset);
node.parentNode.insertBefore(newNode, node.nextSibling);
}
};
window.Range = (function() {
function Range(document) {
this._document = document;
this.startContainer = this.endContainer = document.body;
this.endOffset = DOMUtils.getNodeLength(document.body);
}
share/static/alice.js view on Meta::CPAN
endOffset: 0,
commonAncestorContainer: null,
collapsed: false,
_document: null,
_toTextRange: function() {
function adoptEndPoint(textRange, domRange, bStart) {
var container = domRange[bStart ? 'startContainer' : 'endContainer'];
var offset = domRange[bStart ? 'startOffset' : 'endOffset'], textOffset = 0;
var anchorNode = DOMUtils.isDataNode(container) ? container : container.childNodes[offset];
var anchorParent = DOMUtils.isDataNode(container) ? container.parentNode : container;
if (container.nodeType == 3 || container.nodeType == 4)
textOffset = offset;
var cursorNode = domRange._document.createElement('a');
if (anchorNode)
anchorParent.insertBefore(cursorNode, anchorNode);
else
anchorParent.appendChild(cursorNode);
var cursor = domRange._document.body.createTextRange();
cursor.moveToElementText(cursorNode);
cursorNode.parentNode.removeChild(cursorNode);
textRange.setEndPoint(bStart ? 'StartToStart' : 'EndToStart', cursor);
textRange[bStart ? 'moveStart' : 'moveEnd']('character', textOffset);
}
var textRange = this._document.body.createTextRange();
adoptEndPoint(textRange, this, true);
adoptEndPoint(textRange, this, false);
return textRange;
},
_refreshProperties: function() {
this.collapsed = (this.startContainer == this.endContainer && this.startOffset == this.endOffset);
var node = this.startContainer;
while (node && node != this.endContainer && !DOMUtils.isAncestorOf(node, this.endContainer))
node = node.parentNode;
this.commonAncestorContainer = node;
},
setStart: function(container, offset) {
this.startContainer = container;
this.startOffset = offset;
this._refreshProperties();
},
setEnd: function(container, offset) {
this.endContainer = container;
this.endOffset = offset;
this._refreshProperties();
},
setStartBefore: function(refNode) {
this.setStart(refNode.parentNode, findChildPosition(refNode));
},
setStartAfter: function(refNode) {
this.setStart(refNode.parentNode, findChildPosition(refNode) + 1);
},
setEndBefore: function(refNode) {
this.setEnd(refNode.parentNode, findChildPosition(refNode));
},
setEndAfter: function(refNode) {
this.setEnd(refNode.parentNode, findChildPosition(refNode) + 1);
},
selectNode: function(refNode) {
this.setStartBefore(refNode);
this.setEndAfter(refNode);
},
selectNodeContents: function(refNode) {
this.setStart(refNode, 0);
this.setEnd(refNode, DOMUtils.getNodeLength(refNode));
},
collapse: function(toStart) {
share/static/alice.js view on Meta::CPAN
this.setStartAfter(DOMUtils.findClosestAncestor(this.commonAncestorContainer, this.startContainer));
this.collapse(true);
(function deleteSubtree(iterator) {
while (iterator.next())
iterator.hasPartialSubtree() ? deleteSubtree(iterator.getSubtreeIterator()) : iterator.remove();
})(new RangeIterator(range));
},
insertNode: function(newNode) {
if (DOMUtils.isDataNode(this.startContainer)) {
DOMUtils.splitDataNode(this.startContainer, this.startOffset);
this.startContainer.parentNode.insertBefore(newNode, this.startContainer.nextSibling);
} else {
var offsetNode = this.startContainer.childNodes[this.startOffset];
if (offsetNode) {
this.startContainer.insertBefore(newNode, offsetNode);
} else {
this.startContainer.appendChild(newNode);
}
}
this.setStart(this.startContainer, this.startOffset);
},
share/static/alice.js view on Meta::CPAN
range.setStart(this.startContainer, this.startOffset);
range.setEnd(this.endContainer, this.endOffset);
return range;
},
detach: function() {
},
toString: function() {
return this._toTextRange().text;
},
createContextualFragment: function(tagString) {
var content = (DOMUtils.isDataNode(this.startContainer) ? this.startContainer.parentNode : this.startContainer).cloneNode(false);
content.innerHTML = tagString;
for (var fragment = this._document.createDocumentFragment(); content.firstChild; )
fragment.appendChild(content.firstChild);
return fragment;
}
};
function RangeIterator(range) {
this.range = range;
if (range.collapsed)
share/static/alice.js view on Meta::CPAN
}
return current;
},
remove: function() {
if (DOMUtils.isDataNode(this._current) &&
(this.range.startContainer == this._current || this.range.endContainer == this._current)) {
var start = this.range.startContainer == this._current ? this.range.startOffset : 0;
var end = this.range.endContainer == this._current ? this.range.endOffset : this._current.length;
this._current.deleteData(start, end - start);
} else
this._current.parentNode.removeChild(this._current);
},
hasPartialSubtree: function() {
return !DOMUtils.isDataNode(this._current) &&
(DOMUtils.isAncestorOrSelf(this._current, this.range.startContainer) ||
DOMUtils.isAncestorOrSelf(this._current, this.range.endContainer));
},
getSubtreeIterator: function() {
var subRange = new Range(this.range._document);
subRange.selectNodeContents(this._current);
if (DOMUtils.isAncestorOrSelf(this._current, this.range.startContainer))
share/static/alice.js view on Meta::CPAN
}
};
return Range;
})();
window.Range._fromTextRange = function(textRange, document) {
function adoptBoundary(domRange, textRange, bStart) {
var cursorNode = document.createElement('a'), cursor = textRange.duplicate();
cursor.collapse(bStart);
var parent = cursor.parentElement();
do {
parent.insertBefore(cursorNode, cursorNode.previousSibling);
cursor.moveToElementText(cursorNode);
} while (cursor.compareEndPoints(bStart ? 'StartToStart' : 'StartToEnd', textRange) > 0 && cursorNode.previousSibling);
if (cursor.compareEndPoints(bStart ? 'StartToStart' : 'StartToEnd', textRange) == -1 && cursorNode.nextSibling) {
cursor.setEndPoint(bStart ? 'EndToStart' : 'EndToEnd', textRange);
domRange[bStart ? 'setStart' : 'setEnd'](cursorNode.nextSibling, cursor.text.length);
} else {
domRange[bStart ? 'setStartBefore' : 'setEndBefore'](cursorNode);
}
cursorNode.parentNode.removeChild(cursorNode);
}
var domRange = new Range(document);
adoptBoundary(domRange, textRange, true);
adoptBoundary(domRange, textRange, false);
return domRange;
}
document.createRange = function() {
return new Range(document);
share/static/alice.js view on Meta::CPAN
Selection.prototype = {
rangeCount: 0,
_document: null,
_selectionChangeHandler: function() {
this.rangeCount = this._selectionExists(this._document.selection.createRange()) ? 1 : 0;
},
_selectionExists: function(textRange) {
return textRange.compareEndPoints('StartToEnd', textRange) != 0 ||
textRange.parentElement().isContentEditable;
},
addRange: function(range) {
var selection = this._document.selection.createRange(), textRange = range._toTextRange();
if (!this._selectionExists(selection)) {
textRange.select();
} else {
if (textRange.compareEndPoints('StartToStart', selection) == -1)
if (textRange.compareEndPoints('StartToEnd', selection) > -1 &&
textRange.compareEndPoints('EndToEnd', selection) == -1)
selection.setEndPoint('StartToStart', textRange);
share/static/alice.js view on Meta::CPAN
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,
share/static/alice.js view on Meta::CPAN
};
})(window);
if (Prototype.Browser.IE) {
Object.extend(Selection.prototype, (function() {
function setBookmark() {
var bookmark = $('bookmark');
if (bookmark) bookmark.remove();
bookmark = new Element('span', { 'id': 'bookmark' }).update(" ");
var parent = new Element('div');
parent.appendChild(bookmark);
var range = this._document.selection.createRange();
range.collapse();
range.pasteHTML(parent.innerHTML);
}
function moveToBookmark() {
var bookmark = $('bookmark');
if (!bookmark) return;
var range = this._document.selection.createRange();
range.moveToElementText(bookmark);
range.collapse();
range.select();
share/static/alice.js view on Meta::CPAN
return result;
}
function withEachChildNodeOf(element, callback) {
var nodes = $A(element.childNodes), length = nodes.length, i;
for (i = 0; i < length; i++) callback(nodes[i]);
}
function sanitizeNode(node, tagsToRemove, tagsToAllow, tagsToSkip) {
var parentNode = node.parentNode;
switch (node.nodeType) {
case Node.ELEMENT_NODE:
var tagName = node.tagName.toLowerCase();
if (tagsToSkip) {
var newNode = node.cloneNode(false);
withEachChildNodeOf(node, function(childNode) {
newNode.appendChild(childNode);
sanitizeNode(childNode, tagsToRemove, tagsToAllow, tagsToSkip);
});
parentNode.insertBefore(newNode, node);
} else if (tagName in tagsToAllow) {
var newNode = cloneWithAllowedAttributes(node, tagsToAllow[tagName]);
withEachChildNodeOf(node, function(childNode) {
newNode.appendChild(childNode);
sanitizeNode(childNode, tagsToRemove, tagsToAllow, tagsToSkip);
});
parentNode.insertBefore(newNode, node);
} else if (!(tagName in tagsToRemove)) {
withEachChildNodeOf(node, function(childNode) {
parentNode.insertBefore(childNode, node);
sanitizeNode(childNode, tagsToRemove, tagsToAllow, tagsToSkip);
});
}
case Node.COMMENT_NODE:
parentNode.removeChild(node);
}
}
Element.addMethods({
sanitizeContents: function(element, options) {
element = $(element);
var tagsToRemove = {};
(options.remove || "").split(",").each(function(tagName) {
tagsToRemove[tagName.strip()] = true;
share/static/alice.js view on Meta::CPAN
Element.addMethods({
observeFrameContentLoaded: observeFrameContentLoaded,
onFrameLoaded: onFrameLoaded
});
})();
document.on("dom:loaded", function() {
if ('selection' in document && 'onselectionchange' in document) {
var selectionChangeHandler = function() {
var range = document.selection.createRange();
var element = range.parentElement();
$(element).fire("selection:change");
}
document.on("selectionchange", selectionChangeHandler);
} else {
var previousRange;
var selectionChangeHandler = function() {
var element = document.activeElement;
var elementTagName = element.tagName.toLowerCase();
share/static/alice.js view on Meta::CPAN
} else {
var selection = window.getSelection();
if (selection.rangeCount < 1) return;
var range = selection.getRangeAt(0);
if (range && range.equalRange(previousRange)) return;
previousRange = range;
element = range.commonAncestorContainer;
while (element.nodeType == Node.TEXT_NODE)
element = element.parentNode;
$(element).fire("selection:change");
}
};
document.on("mouseup", selectionChangeHandler);
document.on("keyup", selectionChangeHandler);
}
});
WysiHat.Formatting = (function() {
share/static/alice.js view on Meta::CPAN
flush();
if (isListElement(tagName)) {
container = insertList(tagName);
mode = EXPECTING_LIST_ITEM;
}
} else if (isLineBreak(tagName)) {
if (isLineBreak(getPreviouslyAccumulatedTagName())) {
previousAccumulation.parentNode.removeChild(previousAccumulation);
flush();
}
accumulate(node.cloneNode(false));
if (!previousAccumulation.previousNode) flush();
} else {
accumulateInlineElement(tagName, node);
}
share/static/alice.js view on Meta::CPAN
}
}
function close(tagName) {
if (mode == ACCUMULATING_LINE) {
if (isLineElement(tagName)) {
flush();
}
if (line != lineContainer) {
lineContainer = lineContainer.parentNode;
}
} else if (mode == EXPECTING_LIST_ITEM) {
if (isListElement(tagName)) {
container = result;
mode = ACCUMULATING_LINE;
}
} else if (mode == ACCUMULATING_LIST_ITEM) {
if (isListItemElement(tagName)) {
flush();
mode = EXPECTING_LIST_ITEM;
}
if (line != lineContainer) {
lineContainer = lineContainer.parentNode;
}
}
}
function isBlockElement(tagName) {
return isLineElement(tagName) || isListElement(tagName);
}
function isLineElement(tagName) {
return tagName == "p" || tagName == "div";
share/static/alice.js view on Meta::CPAN
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;
share/static/alice.js view on Meta::CPAN
for (var i=0; i < length; i++) {
var node = children[i];
if (node.nodeName != "#text") {
Alice.makeLinksClickable(node);
}
else if (node.nodeValue.match(Alice.RE.url)) {
var span = new Element("SPAN");
span.innerHTML = node.nodeValue.escapeHTML().replace(
Alice.RE.url, '<a href="$1" target="_blank" rel="noreferrer">$1</a>');
node.parentNode.replaceChild(span, node);
}
}
},
growlNotify: function(message) {
if (window.fluid) {
window.fluid.showGrowlNotification({
title: message.subject,
description: message.body,
priority: 1,
share/static/alice.js view on Meta::CPAN
}
}
});
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 = '';
share/static/alice.js view on Meta::CPAN
this.complete();
},
complete: function() {
var match = this.matches[this.matchIndex];
match += this.leftOffset == 0 ? ":\u00a0" : "\u00a0";
this.restore(match, this.leftOffset + match.length);
},
restore: function(stem, index) {
if (!this.element.parentNode)
this.addTextNode();
this.element.data = this.stemLeft + (stem || this.stem) + this.stemRight;
this.setCursorToIndex(Object.isUndefined(index) ? this.index : index);
},
setCursorToIndex: function(index) {
var range = this.getRange();
range.setStart(this.element, index);
range.setEnd(this.element, index);
share/static/alice.js view on Meta::CPAN
this.leftOffset = this.index - left.length;
},
matchAgainst: function(candidates) {
return candidates.grep(new RegExp("^" + RegExp.escape(this.stem), "i"));
}
});
Alice.Completion.PATTERN = /[A-Za-z0-9\[\\\]^_{|}-]/;
if (window == window.parent) {
document.observe("dom:loaded", function () {
var alice = new Alice.Application();
window.alice = alice;
$('helpclose').observe("click", function () { $('help').hide(); });
$('nicklist_toggle').observe("click", function () { alice.toggleNicklist() });
$$('.dropdown').each(function (menu) {
menu.observe(alice.supportsTouch ? "touchstart" : "mousedown", function (e) {
e.stop();
( run in 0.526 second using v1.01-cache-2.11-cpan-4d50c553e7e )