Returns the node at the specified index or null if the given index
* is greater than the list size or less than zero
* Emulate IE's expr property
* (Here the SarissaNodeList object is given as the result of selectNodes).
* @returns the XPath expression passed to selectNodes that resulted in
* this SarissaNodeList
*/
SarissaNodeList.prototype.expr = "";
/** dummy, used to accept IE's stuff without throwing errors */
if(window.XMLDocument && (!XMLDocument.prototype.setProperty)){
XMLDocument.prototype.setProperty = function(x,y){};
};
/**
* Programmatically control namespace URI/prefix mappings for XPath
* queries.
* This method comes especially handy when used to apply XPath queries
* on XML documents with a default namespace, as there is no other way
* of mapping that to a prefix.
* Using no namespace prefix in DOM Level 3 XPath queries, implies you
* are looking for elements in the null namespace. If you need to look
* for nodes in the default namespace, you need to map a prefix to it
* first like:
* Extends the XMLDocument to emulate IE's selectNodes.
* @argument sExpr the XPath expression to use
* @argument contextNode this is for internal use only by the same
* method when called on Elements
* @returns the result of the XPath search as a SarissaNodeList
* @throws An error if no namespace URI is found for the given prefix.
*/
XMLDocument.prototype.selectNodes = function(sExpr, contextNode, returnSingle){
var nsDoc = this;
var nsresolver = this._sarissa_useCustomResolver?
function(prefix) {
var s = nsDoc._sarissa_xpathNamespaces[prefix];
if(s)return s;
else throw "No namespace URI found for prefix: '" + prefix+"'";
}:
this.createNSResolver(this.documentElement);
var result = null;
if(!returnSingle){
var oResult = this.evaluate(sExpr,
(contextNode?contextNode:this),
nsresolver,
XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
var nodeList = new SarissaNodeList(oResult.snapshotLength);
nodeList.expr = sExpr;
for(var i=0;iExtends the Element to emulate IE's selectNodes
* @argument sExpr the XPath expression to use
* @returns the result of the XPath search as an (Sarissa)NodeList
* @throws An
* error if invoked on an HTML Element as this is only be
* available to XML Elements.
*/
Element.prototype.selectNodes = function(sExpr){
var doc = this.ownerDocument;
if(doc.selectNodes) {
return doc.selectNodes(sExpr, this);
}
else {
throw "Method selectNodes is only supported by XML Elements";
}
};
/**
* Extends the XMLDocument to emulate IE's selectSingleNode.
* @argument sExpr the XPath expression to use
* @argument contextNode this is for internal use only by the same
* method when called on Elements
* @returns the result of the XPath search as an (Sarissa)NodeList
*/
XMLDocument.prototype.selectSingleNode = function(sExpr, contextNode){
var ctx = contextNode?contextNode:null;
return this.selectNodes(sExpr, ctx, true);
};
/**
* Extends the Element to emulate IE's selectSingleNode.
* @argument sExpr the XPath expression to use
* @returns the result of the XPath search as an (Sarissa)NodeList
* @throws An error if invoked on an HTML Element as this is only be
* available to XML Elements.
*/
Element.prototype.selectSingleNode = function(sExpr){
var doc = this.ownerDocument;
if(doc.selectSingleNode) {
return doc.selectSingleNode(sExpr, this);
} else {
throw "Method selectNodes is only supported by XML Elements";
}
};
Sarissa.IS_ENABLED_SELECT_NODES = true;
}
/* - kupuhelpers.js - */
/*****************************************************************************
*
* Copyright (c) 2003-2005 Kupu Contributors. All rights reserved.
*
* This software is distributed under the terms of the Kupu
* License. See LICENSE.txt for license text. For a list of Kupu
* Contributors see CREDITS.txt.
*
*****************************************************************************/
// $Id: kupuhelpers.js 59576 2008-10-30 16:21:37Z guido $
/*
Some notes about the scripts:
- Problem with bound event handlers:
When a method on an object is used as an event handler, the method uses
its reference to the object it is defined on. The 'this' keyword no longer
points to the class, but instead refers to the element on which the event
is bound. To overcome this problem, you can wrap the method in a class that
holds a reference to the object and have a method on the wrapper that calls
the input method in the input object's context. This wrapped method can be
used as the event handler. An example:
class Foo() {
this.foo = function() {
// the method used as an event handler
// using this here wouldn't work if the method
// was passed to addEventListener directly
this.baz();
};
this.baz = function() {
// some method on the same object
};
};
f = new Foo();
// create the wrapper for the function, args are func, context
wrapper = new ContextFixer(f.foo, f);
// the wrapper can be passed to addEventListener, 'this' in the method
// will be pointing to the right context.
some_element.addEventListener("click", wrapper.execute, false);
- Problem with window.setTimeout:
The window.setTimeout function has a couple of problems in usage, all
caused by the fact that it expects a *string* argument that will be
evalled in the global namespace rather than a function reference with
plain variables as arguments. This makes that the methods on 'this' can
not be called (the 'this' variable doesn't exist in the global namespace)
and references to variables in the argument list aren't allowed (since
they don't exist in the global namespace). To overcome these problems,
there's now a singleton instance of a class called Timer, which has one
public method called registerFunction. This can be called with a function
reference and a variable number of extra arguments to pass on to the
function.
Usage:
timer_instance.registerFunction(this, this.myFunc, 10, 'foo', bar);
will call this.myFunc('foo', bar); in 10 milliseconds (with 'this'
as its context).
*/
//----------------------------------------------------------------------------
// Helper classes and functions
//----------------------------------------------------------------------------
function newDocumentElement(doc, tagName, args) {
/* Create a new element, set attributes, and append children */
if (_SARISSA_IS_IE) {
/* Braindead IE cannot set some attributes (e.g. NAME) except
* through bizarre use of createElement */
var attrs = [tagName];
for (var a = 1; a < args.length; a++) {
var arg = args[a];
if (arg.length===undefined) {
for (var attr in arg) {
var val = arg[attr];
if (val===true) val=attr;
if (val===false) continue;
if (attr=='className') attr='class';
attrs.push(attr+'="'+val.replace(/"/,'"')+'"');
};
};
};
tagName = "<"+attrs.join(' ')+">";
}
var node = doc.createElement(tagName);
for (var a = 1; a < args.length; a++) {
var arg = args[a];
if (arg.length===undefined) {
if (!_SARISSA_IS_IE) {
for (var attr in arg) {
if (/^on/.test(attr)) {
node.setAttribute(attr, arg[attr]);
} else {
node[attr] = arg[attr];
};
};
};
} else {
for (var i = 0; i < arg.length; i++) {
if(typeof(arg[i])=='string') {
node.appendChild(doc.createTextNode(arg[i]));
} else {
node.appendChild(arg[i]);
}
}
}
}
return node;
}
function newElement(tagName) {
return newDocumentElement(document, tagName, arguments);
}
function addEventHandler(element, event, method, context) {
/* method to add an event handler for both IE and Mozilla */
var wrappedmethod = new ContextFixer(method, context);
var args = [null, null];
for (var i=4; i < arguments.length; i++) {
args.push(arguments[i]);
};
wrappedmethod.args = args;
try {
if (element.addEventListener) {
element.addEventListener(event, wrappedmethod.execute, false);
} else if (element.attachEvent) {
element.attachEvent("on" + event, wrappedmethod.execute);
} else {
throw _("Unsupported browser!");
};
return wrappedmethod.execute;
} catch(e) {
var msg = _(
'exception ${message} while registering an event handler ' +
'for element ${element}, event ${event}, method ${method}, ',
{'message': e.message, 'element': element,
'event': event,
'method': method
});
if (e.stack) {
msg += _('\r\ntraceback:\r\n${traceback}', {'traceback': e.stack});
};
alert(msg);
};
};
function removeEventHandler(element, event, method) {
/* method to remove an event handler for both IE and Mozilla */
if (element.removeEventListener) {
element.removeEventListener(event, method, false);
} else if (element.detachEvent) {
element.detachEvent("on" + event, method);
} else {
throw _("Unsupported browser!");
};
};
/* Replacement for window.document.getElementById()
* selector can be an Id (so we maintain backwards compatability)
* but is intended to be a subset of valid CSS selectors.
* For now we only support the format: "#id tag.class"
*/
function getFromSelector(selector) {
var match = /#(\S+)\s*([^ .]+)\.(\S+)/.exec(selector);
if (!match) {
return window.document.getElementById(selector);
}
var id=match[1], tag=match[2], className=match[3];
var base = window.document.getElementById(id);
return getBaseTagClass(base, tag, className);
}
function getBaseTagClass(base, tag, className) {
var classPat = new RegExp('\\b'+className+'\\b');
var nodes = base.getElementsByTagName(tag);
for (var i = 0; i < nodes.length; i++) {
if (classPat.test(nodes[i].className)) {
return nodes[i];
}
}
return null;
}
function openPopup(url, width, height, properties) {
/* open and center a popup window */
var allprops = 'width=' + width + ',height=' + height;
if (properties) {
allprops += ',' + properties;
};
var win = window.open(url, 'someWindow', allprops);
return win;
};
function selectSelectItem(select, item) {
/* select a certain item from a select */
for (var i=0; i < select.options.length; i++) {
var option = select.options[i];
if (option.value == item) {
select.selectedIndex = i;
return;
}
}
select.selectedIndex = 0;
};
function parentWithStyleChecker(tagnames, style, stylevalue, command) {
/* small wrapper that provides a generic function to check if a
button should look pressed in */
return function(selNode, button, editor, event) {
/* check if the button needs to look pressed in */
if (command) {
var result = editor.getInnerDocument().queryCommandState(command);
if (result || editor.getSelection().getContentLength() == 0) {
return result;
};
};
var currnode = selNode;
while (currnode && currnode.style) {
for (var i=0; i < tagnames.length; i++) {
if (currnode.nodeName.toLowerCase() == tagnames[i].toLowerCase()) {
return true;
};
};
if (style && currnode.style[style] == stylevalue) {
return true;
};
currnode = currnode.parentNode;
};
return false;
};
};
function _load_dict_helper(element) {
/* walks through a set of XML nodes and builds a nested tree of objects */
var dict = {};
for (var i=0; i < element.childNodes.length; i++) {
var child = element.childNodes[i];
if (child.nodeType == 1) {
var value = '';
for (var j=0; j < child.childNodes.length; j++) {
// test if we can recurse, if so ditch the string (probably
// ignorable whitespace) and dive into the node
if (child.childNodes[j].nodeType == 1) {
value = _load_dict_helper(child);
break;
} else if (typeof(value) == typeof('')) {
value += child.childNodes[j].nodeValue;
};
};
if (typeof(value) == typeof('') && !isNaN(parseInt(value)) &&
parseInt(value).toString().length == value.length) {
value = parseInt(value);
} else if (typeof(value) != typeof('')) {
if (value.length == 1) {
value = value[0];
};
};
var name = child.nodeName.toLowerCase();
var attr = child.attributes[0];
if (attr && !(/^([^_]|_moz)/.test(attr.name))) {
name += attr.name.toLowerCase(); // Fix for Opera
}
if (dict[name] != undefined) {
if (!dict[name].push) {
dict[name] = [dict[name], value];
} else {
dict[name].push(value);
};
} else {
dict[name] = value;
};
};
};
return dict;
};
function loadDictFromXML(document, islandid) {
/* load configuration values from an XML chunk
this is quite generic, it just reads data from a chunk of XML into
an object, checking if the object is complete should be done in the
calling context.
*/
var dict = {};
var confnode = getFromSelector(islandid);
var root = null;
for (var i=0; i < confnode.childNodes.length; i++) {
if (confnode.childNodes[i].nodeType == 1) {
root = confnode.childNodes[i];
break;
};
};
if (!root) {
throw(_('No element found in the config island!'));
};
dict = _load_dict_helper(root);
return dict;
};
function NodeIterator(node, continueatnextsibling) {
/* simple node iterator
can be used to recursively walk through all children of a node,
the next() method will return the next node until either the next
sibling of the startnode is reached (when continueatnextsibling is
false, the default) or when there's no node left (when
continueatnextsibling is true)
returns false if no nodes are left
*/
this.node = node;
this.current = node;
this.terminator = continueatnextsibling ? null : node;
this.next = function() {
/* return the next node */
if (this.current === false) {
// restart
this.current = this.node;
};
var current = this.current;
if (current.firstChild) {
this.current = current.firstChild;
} else {
// walk up parents until we finish or find one with a nextSibling
while (current !== this.terminator && !current.nextSibling) {
current = current.parentNode;
};
if (current === this.terminator) {
this.current = false;
} else {
this.current = current.nextSibling;
};
};
return this.current;
};
this.reset = function() {
/* reset the iterator so it starts at the first node */
this.current = this.node;
};
this.setCurrent = function(node) {
/* change the current node
can be really useful for specific hacks, the user must take
care that the node is inside the iterator's scope or it will
go wild
*/
this.current = node;
};
};
/* selection classes, these are wrappers around the browser-specific
selection objects to provide a generic abstraction layer
*/
function BaseSelection() {
/* superclass for the Selection objects
this will contain higher level methods that don't contain
browser-specific code
*/
this.splitNodeAtSelection = function(node) {
/* split the node at the current selection
remove any selected text, then split the node on the location
of the selection, thus creating a new node, this is attached to
the node's parent after the node
this will fail if the selection is not inside the node
*/
if (!this.selectionInsideNode(node)) {
throw(_('Selection not inside the node!'));
};
// a bit sneaky: what we'll do is insert a new br node to replace
// the current selection, then we'll walk up to that node in both
// the original and the cloned node, in the original we'll remove
// the br node and everything that's behind it, on the cloned one
// we'll remove the br and everything before it
// anyway, we'll end up with 2 nodes, the first already in the
// document (the original node) and the second we can just attach
// to the doc after the first one
var doc = this.document.getDocument();
var br = doc.createElement('br');
br.setAttribute('node_splitter', 'indeed');
this.replaceWithNode(br);
var clone = node.cloneNode(true);
// now walk through the original node
var iterator = new NodeIterator(node);
var currnode = iterator.next();
var remove = false;
while (currnode) {
if (currnode.nodeName.toLowerCase() == 'br' && currnode.getAttribute('node_splitter') == 'indeed') {
// here's the point where we should start removing
remove = true;
};
// we should fetch the next node before we remove the current one, else the iterator
// will fail (since the current node is removed)
var lastnode = currnode;
currnode = iterator.next();
// XXX this will leave nodes that *became* empty in place, since it doesn't visit it again,
// perhaps we should do a second pass that removes the rest(?)
if (remove && (lastnode.nodeType == 3 || !lastnode.hasChildNodes())) {
lastnode.parentNode.removeChild(lastnode);
};
};
// and through the clone
var iterator = new NodeIterator(clone);
var currnode = iterator.next();
var remove = true;
while (currnode) {
var lastnode = currnode;
currnode = iterator.next();
if (lastnode.nodeName.toLowerCase() == 'br' && lastnode.getAttribute('node_splitter') == 'indeed') {
// here's the point where we should stop removing
lastnode.parentNode.removeChild(lastnode);
remove = false;
};
if (remove && (lastnode.nodeType == 3 || !lastnode.hasChildNodes())) {
lastnode.parentNode.removeChild(lastnode);
};
};
// next we need to attach the node to the document
if (node.nextSibling) {
node.parentNode.insertBefore(clone, node.nextSibling);
} else {
node.parentNode.appendChild(clone);
};
// this will change the selection, so reselect
this.reset();
// return a reference to the clone
return clone;
};
this.selectionInsideNode = function(node) {
/* returns a Boolean to indicate if the selection is resided
inside the node
*/
var currnode = this.parentElement();
while (currnode) {
if (currnode == node) {
return true;
};
currnode = currnode.parentNode;
};
return false;
};
};
function MozillaSelection(document) {
var win = document.getWindow();
this.document = document;
this.selection = win.getSelection();
this._createRange = function() {
return this.document.getDocument().createRange();
};
this.selectNodeContents = function(node) {
if (node && node.parentNode) {
/* select the contents of a node */
var sel = this.selection;
sel.removeAllRanges();
if (sel.selectAllChildren && node.nodeType == 1) {
sel.selectAllChildren(node);
} else {
var range = this._createRange();
try {
range.selectNode(node);
} catch (e) {
range.selectNodeContents(node);
};
sel.addRange(range);
};
};
};
this.collapse = function(collapseToEnd) {
try {
if (!this.selection) this.reset();
if (!collapseToEnd) {
this.selection.collapseToStart();
} else {
this.selection.collapseToEnd();
};
} catch(e) {};
};
this.replaceWithNode = function(node, selectAfterPlace) {
// XXX this should be on a range object
/* replaces the current selection with a new node
returns a reference to the inserted node
newnode is the node to replace the content with, selectAfterPlace
can either be a DOM node that should be selected after the new
node was placed, or some value that resolves to true to select
the placed node
*/
// get the first range of the selection
// (there's almost always only one range)
var range = this.selection.getRangeAt(0);
// deselect everything
this.selection.removeAllRanges();
// remove content of current selection from document
range.deleteContents();
// get location of current selection
var container = range.startContainer;
var pos = range.startOffset;
// make a new range for the new selection
var range = this._createRange();
if (container.nodeType == 3 && node.nodeType == 3) {
// if we insert text in a textnode, do optimized insertion
container.insertData(pos, node.nodeValue);
// put cursor after inserted text
range.setEnd(container, pos + node.length);
range.setStart(container, pos + node.length);
} else {
var afterNode;
if (container.nodeType == 3) {
// when inserting into a textnode
// we create 2 new textnodes
// and put the node in between
var textNode = container;
var container = textNode.parentNode;
var text = textNode.nodeValue;
// text before the split
var textBefore = text.substr(0,pos);
// text after the split
var textAfter = text.substr(pos);
var beforeNode = this.document.getDocument().createTextNode(textBefore);
afterNode = this.document.getDocument().createTextNode(textAfter);
// insert the 3 new nodes before the old one
container.insertBefore(afterNode, textNode);
container.insertBefore(node, afterNode);
container.insertBefore(beforeNode, node);
// remove the old node
container.removeChild(textNode);
} else {
// else simply insert the node
afterNode = container.childNodes[pos];
if (afterNode) {
container.insertBefore(node, afterNode);
} else {
container.appendChild(node);
afterNode = container.nextSibling;
};
}
range.setEndAfter(node);
range.collapse(false);
}
if (selectAfterPlace) {
// a bit implicit here, but I needed this to be backward
// compatible and also I didn't want yet another argument,
// JavaScript isn't as nice as Python in that respect (kwargs)
// if selectAfterPlace is a DOM node, select all of that node's
// contents, else select the newly added node's
this.selection = win.getSelection();
this.selection.addRange(range);
if (selectAfterPlace.nodeType == 1) {
this.selection.selectAllChildren(selectAfterPlace);
} else {
if (node.hasChildNodes()) {
this.selection.selectAllChildren(node);
} else {
var range = this.selection.getRangeAt(0).cloneRange();
this.selection.removeAllRanges();
range.selectNode(node);
this.selection.addRange(range);
};
};
win.focus();
};
return node;
};
this.startOffset = function() {
// XXX this should be on a range object
var startnode = this.startNode();
var startnodeoffset = 0;
if (startnode == this.selection.anchorNode) {
startnodeoffset = this.selection.anchorOffset;
} else {
startnodeoffset = this.selection.focusOffset;
};
var parentnode = this.parentElement();
if (startnode == parentnode) {
return startnodeoffset;
};
var currnode = parentnode.firstChild;
var offset = 0;
if (!currnode) {
// 'Control range', range consists of a single element, so startOffset is 0
if (startnodeoffset != 0) {
// just an assertion to see if my assumption about this case is right
throw(_('Start node offset detected in a node without children!'));
};
return 0;
};
while (currnode != startnode) {
if (currnode.nodeType == 3) {
offset += currnode.nodeValue.length;
};
while (!currnode.nextSibling) {
currnode = currnode.parentNode;
};
currnode = currnode.nextSibling;
};
return offset + startnodeoffset;
};
this.startNode = function() {
// XXX this should be on a range object
var anode = this.selection.anchorNode;
var aoffset = this.selection.anchorOffset;
var onode = this.selection.focusNode;
var ooffset = this.selection.focusOffset;
var arange = this._createRange();
arange.setStart(anode, aoffset);
var orange = this._createRange();
orange.setStart(onode, ooffset);
return arange.compareBoundaryPoints('START_TO_START', orange) <= 0 ? anode : onode;
};
this.endOffset = function() {
// XXX this should be on a range object
var endnode = this.endNode();
var endnodeoffset = 0;
if (endnode == this.selection.focusNode) {
endnodeoffset = this.selection.focusOffset;
} else {
endnodeoffset = this.selection.anchorOffset;
};
var parentnode = this.parentElement();
var currnode = parentnode.firstChild;
var offset = 0;
if (parentnode == endnode) {
for (var i=0; i < parentnode.childNodes.length; i++) {
var child = parentnode.childNodes[i];
if (i == endnodeoffset) {
return offset;
};
if (child.nodeType == 3) {
offset += child.nodeValue.length;
};
};
};
if (!currnode) {
// node doesn't have any content, so offset is always 0
if (endnodeoffset != 0) {
// just an assertion to see if my assumption about this case is right
var msg = _('End node offset detected in a node without ' +
'children!');
alert(msg);
throw(msg);
};
return 0;
};
while (currnode && currnode != endnode) {
if (currnode.nodeType == 3) { // should account for CDATA nodes as well
offset += currnode.nodeValue.length;
};
currnode = currnode.nextSibling;
};
return offset + endnodeoffset;
};
this.endNode = function() {
// XXX this should be on a range object
var anode = this.selection.anchorNode;
var aoffset = this.selection.anchorOffset;
var onode = this.selection.focusNode;
var ooffset = this.selection.focusOffset;
var arange = this._createRange();
arange.setStart(anode, aoffset);
var orange = this._createRange();
orange.setStart(onode, ooffset);
return arange.compareBoundaryPoints('START_TO_START', orange) > 0 ? anode : onode;
};
this.getContentLength = function() {
// XXX this should be on a range object
return this.selection.toString().length;
};
this.cutChunk = function(startOffset, endOffset) {
// XXX this should be on a range object
var range = this.selection.getRangeAt(0);
// set start point
var offsetParent = this.parentElement();
var currnode = offsetParent.firstChild;
var curroffset = 0;
var startparent = null;
var startparentoffset = 0;
while (currnode) {
if (currnode.nodeType == 3) { // XXX need to add CDATA support
var nodelength = currnode.nodeValue.length;
if (curroffset + nodelength < startOffset) {
curroffset += nodelength;
} else {
startparent = currnode;
startparentoffset = startOffset - curroffset;
break;
};
};
currnode = currnode.nextSibling;
};
// set end point
var currnode = offsetParent.firstChild;
var curroffset = 0;
var endparent = null;
var endparentoffset = 0;
while (currnode) {
if (currnode.nodeType == 3) { // XXX need to add CDATA support
var nodelength = currnode.nodeValue.length;
if (curroffset + nodelength < endOffset) {
curroffset += nodelength;
} else {
endparent = currnode;
endparentoffset = endOffset - curroffset;
break;
};
};
currnode = currnode.nextSibling;
};
// now cut the chunk
if (!startparent) {
throw(_('Start offset out of range!'));
};
if (!endparent) {
throw(_('End offset out of range!'));
};
var newrange = range.cloneRange();
newrange.setStart(startparent, startparentoffset);
newrange.setEnd(endparent, endparentoffset);
return newrange.extractContents();
};
this.getElementLength = function(element) {
// XXX this should be a helper function
var length = 0;
var currnode = element.firstChild;
while (currnode) {
if (currnode.nodeType == 3) { // XXX should support CDATA as well
length += currnode.nodeValue.length;
};
currnode = currnode.nextSibling;
};
return length;
};
this.parentElement = function(allowmulti) {
/* return the selected node (or the node containing the selection) */
// XXX this should be on a range object
if (!this.selection) {
return null;
}
if (this.selection.rangeCount == 0) {
var parent = this.document.getDocument().body;
while (parent.firstChild) {
parent = parent.firstChild;
};
} else {
var range = this.selection.getRangeAt(0);
var parent = this.parentElementOfRange(range);
if( allowmulti ) {
var numRanges = this.selection.rangeCount;
for( var i = 1; i < numRanges; i = i + 1 )
{
var parent1 = parent;
var parent2 = null;
var range1 = this._createRange();
var range2 = this._createRange();
var parent2 = this.parentElementOfRange(this.selection.getRangeAt(i));
range1.selectNode(parent1);
range2.selectNode(parent2);
if( range1.compareBoundaryPoints(Range.START_TO_START, range2) <= 0 &&
range1.compareBoundaryPoints(Range.END_TO_END, range2) >= 0 ) {
//parent1 contains parent2
parent = parent1;
} else if( range1.compareBoundaryPoints(Range.START_TO_START, range2) >= 0 &&
range1.compareBoundaryPoints(Range.END_TO_END, range2) <= 0 ) {
//parent2 contains parent1
parent = parent2;
} else if( range1.compareBoundaryPoints(Range.START_TO_END, range2) <= 0 ) {
//parent1 comes before parent2
//commonAncestorContainer returns the node parent if a range is
//just one node, which we don't want; but since parent1
//and parent2 are different, their range is not just
//one node
var coverRange = this._createRange();
coverRange.setStartBefore(parent1);
coverRange.setEndAfter(parent2);
parent = coverRange.commonAncestorContainer;
} else {
//parent2 comes before parent1
//commonAncestorContainer returns the node parent if a range is
//just one node, which we don't want; but since parent1
//and parent2 are different, their range is not just
//one node
var coverRange = this._createRange();
coverRange.setStartBefore(parent2);
coverRange.setEndAfter(parent1);
parent = coverRange.commonAncestorContainer;
};
};
};
};
if (parent.nodeType == Node.TEXT_NODE) {
parent = parent.parentNode;
};
return parent;
};
this.parentElementOfRange = function(range) {
if( range.compareBoundaryPoints(Range.START_TO_END, range) < 0 ) {
var startNode = range.endContainer;
var startOffset = range.endOffset;
var endNode = range.startContainer;
var endOffset = range.startOffset;
range.setStart( startNode, startOffset );
range.setEnd( endNode, endOffset );
}
var parent = range.commonAncestorContainer;
// if there is only a single node selected, e.g. after a click on
// an image, then this node itself should be returned as the
// parentElement. however, in this case, "parent" is the selected
// node's parent. the following searches if any other node
// intersects the selection range; if not, then the selected node
// is set to the parentElement.
var inv = range.compareBoundaryPoints(Range.START_TO_END, range) < 0;
var startNode = inv ? range.endContainer : range.startContainer;
var startOffset = inv ? range.endOffset : range.startOffset;
var endNode = inv ? range.startContainer : range.endContainer;
var endOffset = inv ? range.startOffset : range.endOffset;
var selectedChild = null;
var child = parent.firstChild;
while (child) {
if (range.intersectsNode(child) &&
!(child == startNode && startOffset == child.length) &&
!(child == endNode && endOffset == 0)) {
if (selectedChild) {
// current child is the second node found that
// intersects the selection, so commonAncestorContainer
// is the correct parentElement to use
selectedChild = null;
break;
} else {
// current child is the first selected child found
selectedChild = child;
};
} else if (selectedChild) {
// current child is after the selection
break;
};
child = child.nextSibling;
};
if (selectedChild) {
parent = selectedChild;
};
if (parent.nodeType == Node.TEXT_NODE) {
parent = parent.parentNode;
};
return parent;
};
// deprecated alias of parentElement
this.getSelectedNode = this.parentElement;
this.moveStart = function(offset) {
// XXX this should be on a range object
var offsetparent = this.parentElement();
// the offset within the offsetparent
var startoffset = this.startOffset();
var realoffset = offset + startoffset;
if (realoffset >= 0) {
var currnode = offsetparent.firstChild;
var curroffset = 0;
while (currnode) {
if (currnode.nodeType == 3) { // XXX need to support CDATA sections
var nodelength = currnode.nodeValue.length;
if (curroffset + nodelength >= realoffset) {
var range = this.selection.getRangeAt(0);
//range.setEnd(this.endNode(), this.endOffset());
range.setStart(currnode, realoffset - curroffset);
return;
//this.selection.removeAllRanges();
//this.selection.addRange(range);
};
};
currnode = currnode.nextSibling;
};
// if we still haven't found the startparent we should walk to
// all nodes following offsetparent as well
var currnode = offsetparent.nextSibling;
while (currnode) {
if (currnode.nodeType == 3) {
var nodelength = currnode.nodeValue.length;
if (curroffset + nodelength >= realoffset) {
var range = this.selection.getRangeAt(0);
// XXX does IE switch the begin and end nodes here as well?
var endnode = this.endNode();
var endoffset = this.endOffset();
range.setEnd(currnode, realoffset - curroffset);
range.setStart(endnode, endoffset);
return;
};
curroffset += nodelength;
};
currnode = currnode.nextSibling;
};
throw(_('Offset out of document range'));
} else if (realoffset < 0) {
var currnode = offsetparent.prevSibling;
var curroffset = 0;
while (currnode) {
if (currnode.nodeType == 3) { // XXX need to support CDATA sections
var currlength = currnode.nodeValue.length;
if (curroffset - currlength < realoffset) {
var range = this.selection.getRangeAt(0);
range.setStart(currnode, realoffset - curroffset);
};
curroffset -= currlength;
};
currnode = currnode.prevSibling;
};
} else {
var range = this.selection.getRangeAt(0);
range.setStart(offsetparent, 0);
//this.selection.removeAllRanges();
//this.selection.addRange(range);
};
};
this.moveEnd = function(offset) {
// XXX this should be on a range object
};
this.reset = function() {
this.selection = win.getSelection();
};
this.cloneContents = function() {
/* returns a document fragment with a copy of the contents */
var range = this.selection.getRangeAt(0);
return range.cloneContents();
};
this.containsNode = function(node) {
var sel = this.selection;
if (sel.containsNode) {
return sel.containsNode(node, true);
} else {
// kludge it for safari
for(var i = 0; i < sel.rangeCount; i++ ) {
if( sel.getRangeAt(i).containsNode(node) ) {
return true;
}
};
return false;
}
};
this.toString = function() {
return this.selection.toString();
};
this.getRange = function() {
if (this.selection && this.selection.rangeCount > 0) {
return this.selection.getRangeAt(0);
}
};
this.restoreRange = function(range) {
var selection = this.selection;
if (selection) {
selection.removeAllRanges();
selection.addRange(range);
}
};
//sample kindly snipped from Mozilla's wiki
if( !win.Range.prototype.intersectsNode ){
win.Range.prototype.intersectsNode = function(node) {
var nodeRange = node.ownerDocument.createRange();
try {
nodeRange.selectNode(node);
} catch (e) {
nodeRange.selectNodeContents(node);
};
// selection end after node start and selection start
// before node end
return this.compareBoundaryPoints(Range.END_TO_START, nodeRange) == -1 &&
this.compareBoundaryPoints(Range.START_TO_END, nodeRange) == 1;
};
};
this.intersectsNode = function(node) {
for(var i = 0; i < this.selection.rangeCount; i++ ) {
if( this.selection.getRangeAt(i).intersectsNode(node) ) {
return true;
}
};
return false;
};
if( !win.Range.prototype.containsNode ){
win.Range.prototype.containsNode = function(node) {
var nodeRange = node.ownerDocument.createRange();
try {
nodeRange.selectNode(node);
} catch (e) {
nodeRange.selectNodeContents(node);
};
// selection start not after node start and selection end
// not before node end.
return this.compareBoundaryPoints(Range.START_TO_START, nodeRange) != -1 &&
this.compareBoundaryPoints(Range.END_TO_END, nodeRange) != 1;
};
};
};
MozillaSelection.prototype = new BaseSelection;
function IESelection(document) {
this.document = document;
this.selection = document.getDocument().selection;
/* If no selection in editable document, IE returns selection from
* main page, so force an inner selection. */
var doc = document.getDocument();
var range = this.selection.createRange();
var parent = this.selection.type=="Text" ?
range.parentElement() :
this.selection.type=="Control" ? range.parentElement : null;
if(parent && parent.ownerDocument != doc) {
var range = doc.body.createTextRange();
range.collapse();
range.select();
this.reset();
}
this.selectNodeContents = function(node) {
/* select the contents of a node */
// a bit nasty, when moveToElementText is called it will move the selection start
// to just before the element instead of inside it, and since IE doesn't reserve
// an index for the element itself as well the way to get it inside the element is
// by moving the start one pos and then moving it back (yuck!)
var range = doc.body.createTextRange();
range.moveToElementText(node);
range.moveStart('character', 1);
range.moveStart('character', -1);
range.moveEnd('character', -1);
range.moveEnd('character', 1);
range.select();
this.reset();
};
this.collapse = function(collapseToEnd) {
var range = this.selection.createRange();
range.collapse(!collapseToEnd);
range.select();
this.reset();
};
this.replaceWithNode = function(newnode, selectAfterPlace) {
/* replaces the current selection with a new node
returns a reference to the inserted node
newnode is the node to replace the content with, selectAfterPlace
can either be a DOM node that should be selected after the new
node was placed, or some value that resolves to true to select
the placed node
*/
if (this.selection.type == 'Control') {
var range = this.selection.createRange();
range.item(0).parentNode.replaceChild(newnode, range.item(0));
for (var i=1; i < range.length; i++) {
range.item(i).parentNode.removeChild(range[i]);
};
if (selectAfterPlace) {
var range = this.document.getDocument().body.createTextRange();
range.moveToElementText(newnode);
range.select();
};
} else {
var document = this.document.getDocument();
var range = this.selection.createRange();
range.pasteHTML('![]()
');
var tempnode = document.getElementById('kupu-tempnode');
tempnode.replaceNode(newnode);
if (selectAfterPlace) {
// see MozillaSelection.replaceWithNode() for some comments about
// selectAfterPlace
if (selectAfterPlace.nodeType == Node.ELEMENT_NODE) {
range.moveToElementText(selectAfterPlace);
} else {
range.moveToElementText(newnode);
};
range.select();
};
};
this.reset();
return newnode;
};
this.startOffset = function() {
var startoffset = 0;
var selrange = this.selection.createRange();
var parent = selrange.parentElement();
var elrange = selrange.duplicate();
elrange.moveToElementText(parent);
var tempstart = selrange.duplicate();
while (elrange.compareEndPoints('StartToStart', tempstart) < 0) {
startoffset++;
tempstart.moveStart('character', -1);
};
return startoffset;
};
this.endOffset = function() {
var endoffset = 0;
var selrange = this.selection.createRange();
var parent = selrange.parentElement();
var elrange = selrange.duplicate();
elrange.moveToElementText(parent);
var tempend = selrange.duplicate();
while (elrange.compareEndPoints('EndToEnd', tempend) > 0) {
endoffset++;
tempend.moveEnd('character', 1);
};
return endoffset;
};
this.getContentLength = function() {
if (this.selection.type == 'Control') {
return this.selection.createRange().length;
};
var contentlength = 0;
var range = this.selection.createRange();
var endrange = range.duplicate();
while (range.compareEndPoints('StartToEnd', endrange) < 0) {
range.move('character', 1);
contentlength++;
};
return contentlength;
};
this.cutChunk = function(startOffset, endOffset) {
/* cut a chunk of HTML from the selection
this *should* return the chunk of HTML but doesn't yet
*/
var range = this.selection.createRange().duplicate();
range.moveStart('character', startOffset);
range.moveEnd('character', -endOffset);
range.pasteHTML('');
// XXX here it should return the chunk
};
this.getElementLength = function(element) {
/* returns the length of an element *including* 1 char for each child element
this is defined on the selection since it returns results that can be used
to work with selection offsets
*/
var length = 0;
var range = this.selection.createRange().duplicate();
range.moveToElementText(element);
range.moveStart('character', 1);
range.moveEnd('character', -1);
var endpoint = range.duplicate();
endpoint.collapse(false);
range.collapse();
while (!range.isEqual(endpoint)) {
range.moveEnd('character', 1);
range.moveStart('character', 1);
length++;
};
return length;
};
this.parentElement = function(allowmulti) {
/* return the selected node (or the node containing the selection) */
// XXX this should be on a range object
if (this.selection.type == 'Control') {
return this.selection.createRange().item(0);
} else {
return this.selection.createRange().parentElement();
};
};
// deprecated alias of parentElement
this.getSelectedNode = this.parentElement;
this.moveStart = function(offset) {
/* move the start of the selection */
var range = this.selection.createRange();
range.moveStart('character', offset);
range.select();
this.reset();
};
this.moveEnd = function(offset) {
/* moves the end of the selection */
var range = this.selection.createRange();
range.moveEnd('character', offset);
range.select();
this.reset();
};
this.reset = function() {
this.selection = this.document.getDocument().selection;
};
this.cloneContents = function() {
/* returns a document fragment with a copy of the contents */
var contents = this.selection.createRange().htmlText;
var doc = this.document.getDocument();
var docfrag = doc.createElement('span');
docfrag.innerHTML = contents;
return docfrag;
};
this.containsNode = function(node) {
var selected = this.selection.createRange();
if (this.selection.type.toLowerCase()=='text') {
var range = doc.body.createTextRange();
range.moveToElementText(node);
if (selected.compareEndPoints('StartToEnd', range) >= 0 ||
selected.compareEndPoints('EndToStart', range) <= 0) {
return false;
}
return true;
} else {
for (var i = 0; i < selected.length; i++) {
if (selected.item(i).contains(node)) {
return true;
}
}
return false;
}
};
this.getRange = function() {
return this.selection.createRange();
};
this.restoreRange = function(range) {
try {
range.select();
this.reset();
} catch(e) {
};
};
this.toString = function() {
return this.selection.createRange().text;
};
this.intersectsNode = function(node) {
var noderange = doc.body.createTextRange();
noderange.moveToElementText(node);
var selrange = this.selection.createRange();
if((selrange.compareEndPoints('StartToStart', noderange) <= 0 &&
selrange.compareEndPoints('EndToStart', noderange) > 0) ||
(selrange.compareEndPoints('StartToStart', noderange) > 0 &&
selrange.compareEndPoints('StartToEnd', noderange) < 0)) {
return true;
}
return false;
};
};
IESelection.prototype = new BaseSelection;
/* ContextFixer, fixes a problem with the prototype based model
When a method is called in certain particular ways, for instance
when it is used as an event handler, the context for the method
is changed, so 'this' inside the method doesn't refer to the object
on which the method is defined (or to which it is attached), but for
instance to the element on which the method was bound to as an event
handler. This class can be used to wrap such a method, the wrapper
has one method that can be used as the event handler instead. The
constructor expects at least 2 arguments, first is a reference to the
method, second the context (a reference to the object) and optionally
it can cope with extra arguments, they will be passed to the method
as arguments when it is called (which is a nice bonus of using
this wrapper).
*/
function ContextFixer(func, context) {
/* Make sure 'this' inside a method points to its class */
this.func = func;
this.context = context;
this.args = arguments;
var self = this;
this.execute = function() {
/* execute the method */
var args = [];
// the first arguments will be the extra ones of the class
for (var i=0; i < self.args.length - 2; i++) {
args.push(self.args[i + 2]);
};
// the last are the ones passed on to the execute method
for (var i=0; i < arguments.length; i++) {
args.push(arguments[i]);
};
return self.func.apply(self.context, args);
};
};
/* Alternative implementation of window.setTimeout
This is a singleton class, the name of the single instance of the
object is 'timer_instance', which has one public method called
registerFunction. This method takes at least 2 arguments: a
reference to the function (or method) to be called and the timeout.
Arguments to the function are optional arguments to the
registerFunction method. Example:
timer_instance.registerMethod(foo, 100, 'bar', 'baz');
will call the function 'foo' with the arguments 'bar' and 'baz' with
a timeout of 100 milliseconds.
Since the method doesn't expect a string but a reference to a function
and since it can handle arguments that are resolved within the current
namespace rather then in the global namespace, the method can be used
to call methods on objects from within the object (so this.foo calls
this.foo instead of failing to find this inside the global namespace)
and since the arguments aren't strings which are resolved in the global
namespace the arguments work as expected even inside objects.
*/
function Timer() {
/* class that has a method to replace window.setTimeout */
this.lastid = 0;
this.functions = {};
this.registerFunction = function(object, func, timeout) {
/* register a function to be called with a timeout
args:
func - the function
timeout - timeout in millisecs
all other args will be passed 1:1 to the function when called
*/
var args = [];
for (var i=0; i < arguments.length - 3; i++) {
args.push(arguments[i + 3]);
}
var id = this._createUniqueId();
this.functions[id] = [object, func, args];
setTimeout("timer_instance._handleFunction(" + id + ")", timeout);
};
this._handleFunction = function(id) {
/* private method that does the actual function call */
var obj = this.functions[id][0];
var func = this.functions[id][1];
var args = this.functions[id][2];
this.functions[id] = null;
func.apply(obj, args);
};
this._createUniqueId = function() {
/* create a unique id to store the function by */
while (this.lastid in this.functions && this.functions[this.lastid]) {
this.lastid++;
if (this.lastid > 100000) {
this.lastid = 0;
}
}
return this.lastid;
};
};
// create a timer instance in the global namespace, obviously this does some
// polluting but I guess it's impossible to avoid...
// OBVIOUSLY THIS VARIABLE SHOULD NEVER BE OVERWRITTEN!!!
timer_instance = new Timer();
// helper function on the Array object to test for containment
Array.prototype.contains = function(element, objectequality) {
/* see if some value is in this */
for (var i=0; i < this.length; i++) {
if (objectequality) {
if (element === this[i]) {
return true;
};
} else {
if (element == this[i]) {
return true;
};
};
};
return false;
};
// return a copy of an array with doubles removed
Array.prototype.removeDoubles = function() {
var ret = [];
for (var i=0; i < this.length; i++) {
if (!ret.contains(this[i])) {
ret.push(this[i]);
};
};
return ret;
};
Array.prototype.map = function(func) {
/* apply 'func' to each element in the array */
for (var i=0; i < this.length; i++) {
this[i] = func(this[i]);
};
};
Array.prototype.reversed = function() {
var ret = [];
for (var i = this.length; i > 0; i--) {
ret.push(this[i - 1]);
};
return ret;
};
// JavaScript has a friggin' blink() function, but not for string stripping...
String.prototype.strip = function() {
var stripspace = /^\s*([\s\S]*?)\s*$/;
return stripspace.exec(this)[1];
};
String.prototype.reduceWhitespace = function() {
/* returns a string in which all whitespace is reduced
to a single, plain space */
return this.replace(/\s+/g, ' ');
};
String.prototype.truncate = function(len) {
if (this.length <= len) {
return this;
} else {
var trimmed = this.substring(0, len+1).replace(/\s[^\s]*$/, '...');
return trimmed;
}
};
String.prototype.entitize = function() {
var ret = this.replace(/&/g, '&');
ret = ret.replace(/"/g, '"');
ret = ret.replace(/'/g, ''');
ret = ret.replace(//g, '>');
return ret;
};
String.prototype.deentitize = function() {
var ret = this.replace(/>/g, '>');
ret = ret.replace(/</g, '<');
ret = ret.replace(/'/g, "'");
ret = ret.replace(/"/g, '"');
ret = ret.replace(/&/g, '&');
return ret;
};
String.prototype.urldecode = function() {
var reg = /%([a-fA-F0-9]{2})/g;
var str = this;
while (true) {
var match = reg.exec(str);
if (!match || !match.length) {
break;
};
var repl = new RegExp(match[0], 'g');
str = str.replace(repl, String.fromCharCode(parseInt(match[1], 16)));
};
return str;
};
String.prototype.centerTruncate = function(maxlength) {
if (this.length <= maxlength) {
return this;
};
var chunklength = maxlength / 2 - 3;
var start = this.substr(0, chunklength);
var end = this.substr(this.length - chunklength);
return start + ' ... ' + end;
};
//----------------------------------------------------------------------------
// Exceptions
//----------------------------------------------------------------------------
function debug(str, win) {
if (!win) {
win = window;
};
var doc = win.document;
var div = doc.createElement('div');
div.appendChild(doc.createTextNode(str));
doc.getElementsByTagName('body')[0].appendChild(div);
};
// XXX don't know if this is the regular way to define exceptions in JavaScript?
function Exception() {
return;
};
// throw this as an exception inside an updateState handler to restart the
// update, may be required in situations where updateState changes the structure
// of the document (e.g. does a cleanup or so)
UpdateStateCancelBubble = new Exception();
function kupuFixImage(image) {
image.removeAttribute('width');
image.removeAttribute('height');
var width = image.naturalWidth || image.width;
var height = image.naturalHeight || image.height;
if (height > width) {
if (height > 128) {
width = width * 128 / height;
height = 128;
};
} else {
if (width > 128) {
height = height * 128 / width;
width = 128;
};
};
if (width&&height) {
image.height = height;
image.width = width;
}
}
function toggleAltFieldVisibility(me) {
var label = document.getElementById('image-alt-label');
var vis = me.checked?'none':'';
if (label) {
label.style.display = vis;
var fld = document.getElementById(label.htmlFor);
if(fld) { fld.style.display = vis; }
}
}
function getOuterHtml(node) {
var html = '<';
html += node.nodeName.toLowerCase();
var attrs = node.attributes;
for (var a = 0; a < attrs.length; a++) {
var att = attrs[a];
if (att.specified) {
html += ' ' + att.nodeName.toLowerCase() + '="' + att.nodeValue + '"';
}
}
html += '>';
if (!(/hr|br|img|input/i.test(node.nodeName))) {
html += node.innerHTML;
html += '<\/' + node.nodeName.toLowerCase() + '>';
}
return html;
}
/* - kupueditor.js - */
/*****************************************************************************
*
* Copyright (c) 2003-2005 Kupu Contributors. All rights reserved.
*
* This software is distributed under the terms of the Kupu
* License. See LICENSE.txt for license text. For a list of Kupu
* Contributors see CREDITS.txt.
*
*****************************************************************************/
// $Id: kupueditor.js 65353 2009-05-22 07:29:45Z duncan $
//----------------------------------------------------------------------------
// Main classes
//----------------------------------------------------------------------------
/* KupuDocument
This essentially wraps the iframe.
XXX Is this overkill?
*/
function KupuDocument(iframe) {
/* Model */
// attrs
this.editable = iframe; // the iframe
this.window = this.editable.contentWindow;
this.document = this.window.document;
this._browser = _SARISSA_IS_IE ? 'IE' : 'Mozilla';
var DEPRECATED = { 'contentReadOnly': 'readonly', 'styleWithCSS': 'useCSS' };
// methods
this.execCommand = function(command, arg) {
/* delegate execCommand */
if (arg === undefined) arg = null;
try {
this.document.execCommand(command, false, arg);
} catch(e) {
command = DEPRECATED[command];
if (command) {
this.document.execCommand(command, false, !arg);
};
};
};
this.reloadSource = function() {
/* reload the source */
// XXX To temporarily work around problems with resetting the
// state after a reload, currently the whole page is reloaded.
// XXX Nasty workaround!! to solve refresh problems...
document.location = document.location;
};
this.getDocument = function() {
/* returns a reference to the window.document object of the iframe */
return this.document;
};
this.getWindow = function() {
/* returns a reference to the window object of the iframe */
return this.window;
};
this.getSelection = function() {
if (this._browser == 'Mozilla') {
return new MozillaSelection(this);
} else {
return new IESelection(this);
};
};
this.getEditable = function() {
return this.editable;
};
};
/* KupuEditor
This controls the document, should be used from the UI.
*/
function KupuEditor(document, config, logger) {
/* Controller */
// attrs
this.document = document; // the model
this.config = config; // an object that holds the config values
this.log = logger; // simple logger object
this.tools = {}; // mapping id->tool
this.filters = []; // contentfilters
this.serializer = new XMLSerializer();
this._designModeSetAttempts = 0;
this._initialized = false;
this._wantDesignMode = false;
// some properties to save the selection, required for IE to remember
// where in the iframe the selection was
this._previous_range = null;
// this property is true if the content is changed, false if no changes
// are made yet
this.content_changed = false;
// methods
this.initialize = function() {
/* Should be called on iframe.onload, will initialize the editor */
//DOM2Event.initRegistration();
this._initializeEventHandlers();
if (this.getBrowserName() == "IE") {
var body = this.getInnerDocument().getElementsByTagName('body')[0];
body.setAttribute('contentEditable', 'true');
// provide an 'afterInit' method on KupuEditor.prototype
// for additional bootstrapping (after editor init)
this._initialized = true;
if (this.afterInit) {
this.afterInit();
};
this._saveSelection();
} else {
this._setDesignModeWhenReady();
};
};
this.setContextMenu = function(menu) {
/* initialize the contextmenu */
menu.initialize(this);
};
this.registerTool = function(id, tool) {
/* register a tool */
this.tools[id] = tool;
tool.initialize(this);
};
this.getTool = function(id) {
/* get a tool by id */
return this.tools[id];
};
this.registerFilter = function(filter) {
/* register a content filter method
the method will be called together with any other registered
filters before the content is saved to the server, the methods
can be used to filter any trash out of the content. they are
called with 1 argument, which is a reference to the rootnode
of the content tree (the html node)
*/
this.filters.push(filter);
filter.initialize(this);
};
this.updateStateHandler = function(event) {
/* check whether the event is interesting enough to trigger the
updateState machinery and act accordingly */
var interesting_codes = [8, 13, 37, 38, 39, 40, 46];
// unfortunately it's not possible to do this on blur, since that's
// too late. also (some versions of?) IE 5.5 doesn't support the
// onbeforedeactivate event, which would be ideal here...
this._saveSelection();
if (event.type == 'click' ||
(event.type == 'keyup' &&
interesting_codes.contains(event.keyCode))) {
// Filthy trick to make the updateState method get called *after*
// the event has been resolved. This way the updateState methods can
// react to the situation *after* any actions have been performed (so
// can actually stay up to date).
this.updateState(event);
}
};
this.updateState = function(event) {
/* let each tool change state if required */
// first see if the event is interesting enough to trigger
// the whole updateState machinery
var selNode = this.getSelectedNode();
for (var id in this.tools) {
try {
this.tools[id].updateState(selNode, event);
} catch (e) {
if (e == UpdateStateCancelBubble) {
this.updateState(event);
break;
} else {
this.logMessage(
'Exception while processing updateState on ' +
'${id}: ${msg}', {'id': id, 'msg': e}, 2);
};
};
};
};
this.saveDocument = function(redirect, synchronous) {
/* save the document
the (optional) redirect argument can be used to make the client
jump to another URL when the save action was successful.
synchronous is a boolean to allow sync saving (usually better to
not save synchronous, since it may make browsers freeze on errors,
this is used for saveOnPart, though)
*/
// if no dst is available, bail out
if (!this.config.dst) {
this.logMessage(_('No destination URL available!'), 2);
return;
}
var sourcetool = this.getTool('sourceedittool');
if (sourcetool) {sourcetool.cancelSourceMode();};
// make sure people can't edit or save during saving
if (!this._initialized) {
return;
}
this._initialized = false;
// set the window status so people can see we're actually saving
window.status= _("Please wait while saving document...");
// call (optional) beforeSave() method on all tools
for (var id in this.tools) {
var tool = this.tools[id];
if (tool.beforeSave) {
try {
tool.beforeSave();
} catch(e) {
alert(e);
this._initialized = true;
return;
};
};
};
// pass the content through the filters
this.logMessage(_("Starting HTML cleanup"));
var transform = this._filterContent(this.getInnerDocument().documentElement);
// serialize to a string
var contents = this._serializeOutputToString(transform);
this.logMessage(_("Cleanup done, sending document to server"));
var request = new XMLHttpRequest();
if (!synchronous) {
request.onreadystatechange = (new ContextFixer(this._saveCallback,
this, request, redirect)).execute;
request.open("PUT", this.config.dst, true);
request.setRequestHeader("Content-type", this.config.content_type);
request.send(contents);
this.logMessage(_("Request sent to server"));
} else {
this.logMessage(_('Sending request to server'));
request.open("PUT", this.config.dst, false);
request.setRequestHeader("Content-type", this.config.content_type);
request.send(contents);
this.handleSaveResponse(request,redirect);
};
};
this.prepareForm = function(form, id) {
/* add a field to the form and place the contents in it
can be used for simple POST support where Kupu is part of a
form
*/
var sourcetool = this.getTool('sourceedittool');
if (sourcetool) {sourcetool.cancelSourceMode();};
// make sure people can't edit or save during saving
if (!this._initialized) {
return;
}
this._initialized = false;
// set the window status so people can see we're actually saving
window.status= _("Please wait while saving document...");
// call (optional) beforeSave() method on all tools
for (var tid in this.tools) {
var tool = this.tools[tid];
if (tool.beforeSave) {
try {
tool.beforeSave();
} catch(e) {
alert(e);
this._initialized = true;
return;
};
};
};
// set a default id
if (!id) {
id = 'kupu';
};
// pass the content through the filters
this.logMessage(_("Starting HTML cleanup"));
var transform = this._filterContent(this.getInnerDocument().documentElement);
// XXX need to fix this. Sometimes a spurious "\n\n" text
// node appears in the transform, which breaks the Moz
// serializer on .xml
var contents = this._serializeOutputToString(transform);
this.logMessage(_("Cleanup done, sending document to server"));
// now create the form input, since IE 5.5 doesn't support the
// ownerDocument property we use window.document as a fallback (which
// will almost by definition be correct).
var document = form.ownerDocument ? form.ownerDocument : window.document;
var ta = document.createElement('textarea');
ta.style.visibility = 'hidden';
var text = document.createTextNode(contents);
ta.appendChild(text);
ta.setAttribute('name', id);
// and add it to the form
form.appendChild(ta);
// let the calling code know we have added the textarea
return true;
};
this.execCommand = function(command, param) {
/* general stuff like making current selection bold, italics etc.
and adding basic elements such as lists
*/
if (!this._initialized) {
this.logMessage(_('Editor not initialized yet!'));
return;
};
if (this.getBrowserName() == "IE") {
this._restoreSelection();
} else {
this.focusDocument();
if (command != 'styleWithCSS') {
this.content_changed = true;
// Done here otherwise it doesn't always work or gets lost
// after some commands
this.getDocument().execCommand('styleWithCSS', false);
};
};
this.getDocument().execCommand(command, param);
this.updateState();
};
this.getSelection = function() {
/* returns a Selection object wrapping the current selection */
this._restoreSelection();
return this.getDocument().getSelection();
};
this.getSelectedNode = function(allowmulti) {
/* returns the selected node (read: parent) or none */
/* if allowmulti is true, returns the parent of all ranges in the
selection (in the rare case that selection has more than one
range) */
return this.getSelection().parentElement(allowmulti);
};
this.getNearestParentOfType = function(node, type) {
/* well the title says it all ;) */
var type = type.toLowerCase();
while (node) {
if (node.nodeName.toLowerCase() == type) {
return node;
}
var node = node.parentNode;
}
return false;
};
this.removeNearestParentOfType = function(node, type) {
var nearest = this.getNearestParentOfType(node, type);
if (!nearest) {
return false;
};
var parent = nearest.parentNode;
while (nearest.childNodes.length) {
var child = nearest.firstChild;
child = nearest.removeChild(child);
parent.insertBefore(child, nearest);
};
parent.removeChild(nearest);
};
this.getDocument = function() {
/* returns a reference to the document object that wraps the iframe */
return this.document;
};
this.getInnerDocument = function() {
/* returns a reference to the window.document object of the iframe */
return this.getDocument().getDocument();
};
this.insertNodeAtSelection = function(insertNode, selectNode) {
/* insert a newly created node into the document */
if (!this._initialized) {
this.logMessage(_('Editor not initialized yet!'));
return;
};
this.content_changed = true;
var browser = this.getBrowserName();
if (browser != "IE") {
this.focusDocument();
};
var ret = this.getSelection().replaceWithNode(insertNode, selectNode);
this._saveSelection();
return ret;
};
this.focusDocument = function() {
this.getDocument().getWindow().focus();
};
this.logMessage = function(message, severity) {
/* log a message using the logger, severity can be 0 (message, default), 1 (warning) or 2 (error) */
this.log.log(message, severity);
};
this.registerContentChanger = function(element) {
/* set this.content_changed to true (marking the content changed) when the
element's onchange is called
*/
addEventHandler(element, 'change', function() {this.content_changed = true;}, this);
};
// helper methods
this.getBrowserName = function() {
/* returns either 'Mozilla' (for Mozilla, Firebird, Netscape etc.) or 'IE' */
if (_SARISSA_IS_MOZ) {
return "Mozilla";
} else if (_SARISSA_IS_IE) {
return "IE";
} else {
throw _("Browser not supported!");
}
};
this.handleSaveResponse = function(request, redirect) {
// mind the 1223 status, somehow IE gives that sometimes (on 204?)
// at first we didn't want to add it here, since it's a specific IE
// bug, but too many users had trouble with it...
if (request.status != '200' && request.status != '204' &&
request.status != '1223') {
var msg = _('Error saving your data.\nResponse status: ' +
'${status}.\nCheck your server log for more ' +
'information.', {'status': request.status});
alert(msg);
window.status = _("Error saving document");
} else if (redirect) { // && (!request.status || request.status == '200' || request.status == '204'))
window.document.location = redirect;
this.content_changed = false;
} else {
// clear content_changed before reloadSrc so saveOnPart is not triggered
this.content_changed = false;
if (this.config.reload_after_save) {
this.reloadSrc();
};
// we're done so we can start editing again
window.status= _("Document saved");
};
this._initialized = true;
};
// private methods
this._addEventHandler = addEventHandler;
this._saveCallback = function(request, redirect) {
/* callback for Sarissa */
if (request.readyState == 4) {
this.handleSaveResponse(request, redirect);
};
};
this.reloadSrc = function() {
/* reload the src, called after a save when reload_src is set to true */
// XXX Broken!!!
/*
if (this.getBrowserName() == "Mozilla") {
this.getInnerDocument().designMode = "Off";
}
*/
// XXX call reloadSrc() which has a workaround, reloads the full page
// instead of just the iframe...
this.getDocument().reloadSource();
if (this.getBrowserName() == "Mozilla") {
this.getInnerDocument().designMode = "On";
};
/*
var selNode = this.getSelectedNode();
this.updateState(selNode);
*/
};
// Fixup Mozilla breaking image src url when dragging images
this.imageInserted = function(event) {
var node = event.target;
if (node && node.nodeType==1) {
var nodes = (/^img$/i.test(node.nodeName))?[node]:node.getElementsByTagName('img');
for (var i = 0; i < nodes.length; i++) {
node = nodes[i];
var src = node.getAttribute('kupu-src');
if (src) { node.src = src; };
};
};
};
// Prevent Mozilla resizing of images
this.imageModified = function(event) {
var node = event.target;
if (node && (/^img$/i.test(node.nodeName))) {
if (event.attrName=="style" && event.attrChange==1 && (/height|width/.test(event.newValue))) {
timer_instance.registerFunction(this, this._clearStyle, 1, node);
}
};
};
// Make sure image size is set on width/height attributes not style.
this._clearStyle = function(node) {
var w = node.width;
var h = node.height;
node.style.width = "";
node.style.height = "";
if (this.okresize) {
if (w) {node.width = w;};
if (h) {node.height = h;};
};
};
this._cancelResize = function(evt) {
return false;
};
this._initializeEventHandlers = function() {
/* attache the event handlers to the iframe */
var win = this.getDocument().getWindow();
var idoc = this.getInnerDocument();
var e = this._addEventHandler;
var validattrs = this.xhtmlvalid.tagAttributes.img;
this.okresize = validattrs.contains('width') && validattrs.contains('height');
// Set design mode on resize event:
e(win, 'resize', this._resizeHandler, this);
// Initialize DOM2Event compatibility
// XXX should come back and change to passing in an element
e(idoc, "click", this.updateStateHandler, this);
e(idoc, "dblclick", this.updateStateHandler, this);
e(idoc, "keyup", this.updateStateHandler, this);
e(idoc, "keyup", function() {this.content_changed = true;}, this);
e(idoc, "mouseup", this.updateStateHandler, this);
if (this.getBrowserName() == "IE") {
e(idoc, "selectionchange", this.onSelectionChange, this);
if (!this.okresize) { e(idoc.documentElement, "resizestart", this._cancelResize, this);};
} else {
e(idoc, "DOMNodeInserted", this.imageInserted, this);
e(idoc, "DOMAttrModified", this.imageModified, this);
}
};
this._resizeHandler = function() {
// Use the resize event to trigger setting design mode
if (this._wantDesignMode) {
this._setDesignModeWhenReady();
}
};
this._setDesignModeWhenReady = function() {
/* Try to set design mode, but if we fail then just wait for a
* resize event.
*/
var success = false;
try {
this._setDesignMode();
success = true;
} catch (e) {
};
if (success) {
this._wantDesignMode = false;
// provide an 'afterInit' method on KupuEditor.prototype
// for additional bootstrapping (after editor init)
if (this.afterInit) {
this.afterInit();
};
} else {
this._wantDesignMode = true; // Enable the resize trigger
}
};
this._setDesignMode = function() {
this.getInnerDocument().designMode = "On";
this.execCommand("undo");
// note the negation: the argument doesn't work as expected...
this._initialized = true;
};
this._saveSelection = function() {
/* Save the selection, works around a problem with IE where the
selection in the iframe gets lost. We only save if the current
selection in the document */
if (this._isDocumentSelected()) {
var cursel = this.getInnerDocument().selection;
var currange = cursel.createRange();
if (cursel.type=="Control" && currange.item(0).nodeName.toLowerCase()=="body") {
/* This happens when you try to active an embedded
* object */
this._restoreSelection(true);
return;
}
this._previous_range = currange;
};
};
this._restoreSelection = function(force) {
/* re-selects the previous selection in IE. We only restore if the
current selection is not in the document.*/
if (this._previous_range && (force || !this._isDocumentSelected())) {
try {
this._previous_range.select();
} catch (e) { };
};
};
if (this.getBrowserName() != "IE") {
this._saveSelection = function() {};
this._restoreSelection = function() {};
}
this.onSelectionChange = function(event) {
this._saveSelection();
};
this._isDocumentSelected = function() {
if (this.suspended) return false;
var editable_body = this.getInnerDocument().getElementsByTagName('body')[0];
try {
var selrange = this.getInnerDocument().selection.createRange();
} catch(e) {
return false;
}
var someelement = selrange.parentElement ? selrange.parentElement() : selrange.item(0);
while (someelement.nodeName.toLowerCase() != 'body') {
someelement = someelement.parentNode;
};
return someelement == editable_body;
};
this._clearSelection = function() {
/* clear the last stored selection */
this._previous_range = null;
};
this._filterContent = function(documentElement) {
/* pass the content through all the filters */
// first copy all nodes to a Sarissa document so it's usable
var xhtmldoc = Sarissa.getDomDocument();
var doc = this._convertToSarissaNode(xhtmldoc, documentElement);
// now pass it through all filters
for (var i=0; i < this.filters.length; i++) {
var doc = this.filters[i].filter(xhtmldoc, doc);
};
// fix some possible structural problems, such as an empty or missing head, title
// or script or textarea tags without closing tag...
this._fixXML(doc, xhtmldoc);
return doc;
};
this.getXMLBody = function(transform) {
var bodies = transform.getElementsByTagName('body');
var data = '';
for (var i = 0; i < bodies.length; i++) {
data += this.serializer.serializeToString(bodies[i]);
}
return this.layoutsource(this.escapeEntities(data));
};
this.getHTMLBody = function() {
var doc = this.getInnerDocument();
var docel = doc.documentElement;
var bodies = docel.getElementsByTagName('body');
var data = '';
for (var i = 0; i < bodies.length; i++) {
data += bodies[i].innerHTML;
}
return this.layoutsource(this.escapeEntities(data));
};
// If we have multiple bodies this needs to remove the extras.
this.setHTMLBody = function(text) {
var doc = this.getInnerDocument().documentElement;
var bodies = doc.getElementsByTagName('body');
for (var i = 0; i < bodies.length-1; i++) {
bodies[i].parentNode.removeChild(bodies[i]);
}
if (_SARISSA_IS_IE) { /* IE converts certain comments to visible text so strip them */
text = text.replace(//g, '');
} else { /* Mozilla doesn't understand strong/em */
var fixups = { 'strong':'b', 'em':'i' };
text = text.replace(/<(\/?)(strong|em)\b([^>]*)>/gi, function(all,close,tag,attrs) {
tag = fixups[tag.toLowerCase()];
return '<'+close+tag+attrs+'>';
});
};
text = text.replace(/()<\/p>/g,'$1');
bodies[bodies.length-1].innerHTML = text;
/* Mozilla corrupts dragged images, so save the src attribute */
var nodes = doc.getElementsByTagName('img');
for (var i = 0; i < nodes.length; i++) {
var node = nodes[i];
node.setAttribute('kupu-src', node.src);
};
};
this._fixXML = function(doc, document) {
/* fix some structural problems in the XML that make it invalid XTHML */
// find if we have a head and title, and if not add them
var heads = doc.getElementsByTagName('head');
var titles = doc.getElementsByTagName('title');
if (!heads.length) {
// assume we have a body, guess Kupu won't work without one anyway ;)
var body = doc.getElementsByTagName('body')[0];
var head = document.createElement('head');
body.parentNode.insertBefore(head, body);
var title = document.createElement('title');
var titletext = document.createTextNode('');
head.appendChild(title);
title.appendChild(titletext);
} else if (!titles.length) {
var head = heads[0];
var title = document.createElement('title');
var titletext = document.createTextNode('');
head.appendChild(title);
title.appendChild(titletext);
};
// create a closing element for all elements that require one in XHTML
var dualtons = ['a', 'abbr', 'acronym', 'address', 'applet',
'b', 'bdo', 'big', 'blink', 'blockquote',
'button', 'caption', 'center', 'cite',
'comment', 'del', 'dfn', 'dir', 'div',
'dl', 'dt', 'em', 'embed', 'fieldset',
'font', 'form', 'frameset', 'h1', 'h2',
'h3', 'h4', 'h5', 'h6', 'i', 'iframe',
'ins', 'kbd', 'label', 'legend', 'li',
'listing', 'map', 'marquee', 'menu',
'multicol', 'nobr', 'noembed', 'noframes',
'noscript', 'object', 'ol', 'optgroup',
'option', 'p', 'pre', 'q', 's', 'script',
'select', 'small', 'span', 'strike',
'strong', 'style', 'sub', 'sup', 'table',
'tbody', 'td', 'textarea', 'tfoot',
'th', 'thead', 'title', 'tr', 'tt', 'u',
'ul', 'xmp'];
// XXX I reckon this is *way* slow, can we use XPath instead or
// something to speed this up?
for (var i=0; i < dualtons.length; i++) {
var elname = dualtons[i];
var els = doc.getElementsByTagName(elname);
for (var j=0; j < els.length; j++) {
var el = els[j];
if (!el.hasChildNodes()) {
var child = document.createTextNode('');
el.appendChild(child);
};
};
};
};
this.xhtmlvalid = new XhtmlValidation(this);
this._convertToSarissaNode = function(ownerdoc, htmlnode) {
/* Given a string of non-well-formed HTML, return a string of
well-formed XHTML.
This function works by leveraging the already-excellent HTML
parser inside the browser, which generally can turn a pile
of crap into a DOM. We iterate over the HTML DOM, appending
new nodes (elements and attributes) into a node.
The primary problems this tries to solve for crappy HTML: mixed
element names, elements that open but don't close,
and attributes that aren't in quotes. This can also be adapted
to filter out tags that you don't want and clean up inline styles.
Inspired by Guido, adapted by Paul from something in usenet.
Tag and attribute tables added by Duncan
*/
return this.xhtmlvalid._convertToSarissaNode(ownerdoc, htmlnode);
};
this._fixupSingletons = function(xml) {
return xml.replace(/<([^>]+)\/>/g, "<$1 />");
};
this._serializeOutputToString = function(transform) {
// XXX need to fix this. Sometimes a spurious "\n\n" text
// node appears in the transform, which breaks the Moz
// serializer on .xml
if (this.config.strict_output) {
var contents = '\n' +
'' +
this.serializer.serializeToString(transform.getElementsByTagName("head")[0]) +
this.serializer.serializeToString(transform.getElementsByTagName("body")[0]) +
'';
} else {
var contents = '' +
this.serializer.serializeToString(transform.getElementsByTagName("head")[0]) +
this.serializer.serializeToString(transform.getElementsByTagName("body")[0]) +
'';
};
contents = this.escapeEntities(contents);
if (this.config.compatible_singletons) {
contents = this._fixupSingletons(contents);
};
return contents;
};
this.layoutsource = function(data) {
data = data.replace(
/\s*(<(p|div|h.|ul|ol|dl|menu|dir|pre|blockquote|address|center|table|thead|tbody|tfoot|tr|th|td))\b/ig, '\n$1');
data = data.replace(
/\s*(<\/(p|div|h.|ul|ol|dl|menu|dir|pre|blockquote|address|center|table|thead|tbody|tfoot|tr|th|td)>)\s*/ig, '$1\n');
data = data.replace(/\((?:.|\n)*?)\<\/pre\>/gm, function(s) {
return s.replace(/]*>/gi,'\n');
});
return data.strip();
};
this.escapeEntities = function(xml) {
// XXX: temporarily disabled
xml = xml.replace(/\xa0/g, ' ');
return xml;
// Escape non-ascii characters as entities.
// return xml.replace(/[^\r\n -\177]/g,
// function(c) {
// return '&#'+c.charCodeAt(0)+';';
// });
};
this.getFullEditor = function() {
var fulleditor = this.getDocument().getEditable();
while (!(/kupu-fulleditor/.test(fulleditor.className))) {
fulleditor = fulleditor.parentNode;
}
return fulleditor;
};
// Control the className and hence the style for the whole editor.
this.setClass = function(name) {
this.getFullEditor().className += ' '+name;
};
this.clearClass = function(name) {
var fulleditor = this.getFullEditor();
fulleditor.className = fulleditor.className.replace(' '+name, '');
};
var busycount = 0;
this.busy = function() {
if (busycount <= 0) {
this.setClass('kupu-busy');
}
busycount++;
};
this.notbusy = function(force) {
busycount = force?0:busycount?busycount-1:0;
if (busycount <= 0) {
this.clearClass('kupu-busy');
}
};
this.suspendEditing = function() {
this._previous_range = this.getSelection().getRange();
this.setClass('kupu-modal');
for (var id in this.tools) {
this.tools[id].disable();
}
if (this.getBrowserName() == "IE") {
var body = this.getInnerDocument().getElementsByTagName('body')[0];
body.setAttribute('contentEditable', 'false');
} else {
this.getDocument().execCommand('contentReadOnly', 'true');
}
this.suspended = true;
};
this.resumeEditing = function() {
if (!this.suspended) {
return;
}
this.clearClass('kupu-modal');
for (var id in this.tools) {
this.tools[id].enable();
}
if (this.getBrowserName() == "IE") {
var body = this.getInnerDocument().getElementsByTagName('body')[0];
body.setAttribute('contentEditable', 'true');
this._restoreSelection();
} else {
var doc = this.getInnerDocument();
this.getDocument().execCommand('contentReadOnly', 'false');
doc.designMode = "On";
this.focusDocument();
this.getSelection().restoreRange(this._previous_range);
}
this.suspended = false;
};
this.newElement = function(tagName) {
return newDocumentElement(this.getInnerDocument(), tagName, arguments);
};
this.newText = function(text) {
return this.getInnerDocument().createTextNode(text);
};
}
/* - kupubasetools.js - */
/*****************************************************************************
*
* Copyright (c) 2003-2005 Kupu Contributors. All rights reserved.
*
* This software is distributed under the terms of the Kupu
* License. See LICENSE.txt for license text. For a list of Kupu
* Contributors see CREDITS.txt.
*
*****************************************************************************/
// $Id: kupubasetools.js 59216 2008-10-18 15:50:04Z duncan $
//----------------------------------------------------------------------------
//
// Toolboxes
//
// These are addons for Kupu, simple plugins that implement a certain
// interface to provide functionality and control view aspects.
//
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Superclasses
//----------------------------------------------------------------------------
function KupuTool() {
/* Superclass (or actually more of an interface) for tools
Tools must implement at least an initialize method and an
updateState method, and can implement other methods to add
certain extra functionality (e.g. createContextMenuElements).
*/
this.toolboxes = {};
// private methods
addEventHandler = addEventHandler;
};
// methods
KupuTool.prototype.initialize = function(editor) {
/* Initialize the tool.
Obviously this can be overriden but it will do
for the most simple cases
*/
this.editor = editor;
};
KupuTool.prototype.registerToolBox = function(id, toolbox) {
/* register a ui box
Note that this needs to be called *after* the tool has been
registered to the KupuEditor
*/
this.toolboxes[id] = toolbox;
toolbox.initialize(this, this.editor);
};
KupuTool.prototype.updateState = function(selNode, event) {
/* Is called when user moves cursor to other element
Calls the updateState for all toolboxes and may want perform
some actions itself
*/
for (var id in this.toolboxes) {
this.toolboxes[id].updateState(selNode, event);
};
};
KupuTool.prototype.enable = function() {
// Called when the tool is enabled after a form is dismissed.
};
KupuTool.prototype.disable = function() {
// Called when the tool is disabled (e.g. for a modal form)
};
function KupuToolBox() {
/* Superclass for a user-interface object that controls a tool */
};
KupuToolBox.prototype.initialize = function(tool, editor) {
/* store a reference to the tool and the editor */
this.tool = tool;
this.editor = editor;
};
KupuToolBox.prototype.updateState = function(selNode, event) {
/* update the toolbox according to the current iframe's situation */
};
function noContextMenu(object) {
/* Decorator for a tool to suppress the context menu */
object.createContextMenuElements = function(selNode, event) {
return [];
};
return object;
}
// Helper function for enabling/disabling tools
function kupuButtonDisable(button) {
button = button || this.button;
if (button) {
button.disabled = "disabled";
button.className += ' disabled';
}
};
function kupuButtonEnable(button) {
button = button || this.button;
if (button) {
button.disabled = "";
button.className = button.className.replace(/ *\bdisabled\b/g, '');
}
};
//----------------------------------------------------------------------------
// Implementations
//----------------------------------------------------------------------------
function KupuButton(buttonid, commandfunc, tool) {
/* Base prototype for kupu button tools */
if (arguments.length) {
this.buttonid = buttonid;
this.button = getFromSelector(buttonid);
this.commandfunc = commandfunc;
this.tool = tool;
this.disable = kupuButtonDisable;
this.enable = kupuButtonEnable;
};
};
KupuButton.prototype = new KupuTool;
KupuButton.prototype.initialize = function(editor) {
this.editor = editor;
if (!this.button) return;
addEventHandler(this.button, 'click', this.execCommand, this);
};
KupuButton.prototype.execCommand = function() {
/* exec this button's command */
this.commandfunc(this, this.editor, this.tool);
};
KupuButton.prototype.updateState = function(selNode, event) {
/* override this in subclasses to determine whether a button should
look 'pressed in' or not
*/
};
function KupuStateButton(buttonid, commandfunc, checkfunc, offclass, onclass) {
/* A button that can have two states (e.g. pressed and
not-pressed) based on CSS classes */
this.buttonid = buttonid;
this.button = getFromSelector(buttonid);
this.commandfunc = commandfunc;
this.checkfunc = checkfunc;
this.offclass = offclass;
this.onclass = onclass;
this.pressed = false;
this.execCommand = function() {
/* exec this button's command */
this.button.className = (this.pressed ? this.offclass : this.onclass);
this.pressed = !this.pressed;
this.editor.focusDocument();
this.commandfunc(this, this.editor);
};
this.updateState = function(selNode, event) {
/* check if we need to be clicked or unclicked, and update accordingly
if the state of the button should be changed, we set the class
*/
if (!this.button) return;
var currclass = this.button.className;
var newclass = null;
if (this.checkfunc(selNode, this, this.editor, event)) {
newclass = this.onclass;
this.pressed = true;
} else {
newclass = this.offclass;
this.pressed = false;
};
if (currclass != newclass) {
this.button.className = newclass;
};
};
};
KupuStateButton.prototype = new KupuButton;
/* Same as the state button, but the focusDocument call is delayed.
* Mozilla&Firefox have a bug on windows which can cause a crash if you
* change CSS positioning styles on an element which has focus.
*/
function KupuLateFocusStateButton(buttonid, commandfunc, checkfunc,
offclass, onclass) {
KupuStateButton.apply(this, [buttonid, commandfunc, checkfunc,
offclass, onclass]);
}
KupuLateFocusStateButton.prototype = new KupuStateButton;
KupuLateFocusStateButton.prototype.execCommand = function() {
/* exec this button's command */
this.button.className = (this.pressed ? this.offclass : this.onclass);
this.pressed = !this.pressed;
this.commandfunc(this, this.editor);
this.editor.focusDocument();
};
function KupuRemoveElementButton(buttonid, element_name, cssclass) {
/* A button specialized in removing elements in the current node
context. Typical usages include removing links, images, etc. */
this.button = getFromSelector(buttonid);
this.element_name = element_name;
this.onclass = 'invisible';
this.offclass = cssclass;
this.pressed = false;
};
KupuRemoveElementButton.prototype = new KupuStateButton;
KupuRemoveElementButton.prototype.commandfunc = function(button, editor) {
editor.focusDocument();
editor.removeNearestParentOfType(editor.getSelectedNode(), this.element_name);
editor.updateState();
};
KupuRemoveElementButton.prototype.checkfunc = function(currnode, button,
editor, event) {
var element = editor.getNearestParentOfType(currnode, this.element_name);
return (element ? false : true);
};
function KupuUI(textstyleselectid) {
/* View
This is the main view, which controls most of the toolbar buttons.
Even though this is probably never going to be removed from the view,
it was easier to implement this as a plain tool (plugin) as well.
*/
// attributes
this.tsselect = getFromSelector(textstyleselectid);
this.paraoptions = [];
this.tableoptions = [];
this.styleoptions = [];
this.tableoffset = 0;
this.styleoffset = 0;
this.tablegrp = null;
this.optionstate = -1;
this.otherstyle = null;
this.tablestyles = {};
this.charstyles = {};
this.styles = {}; // use an object here so we can use the 'in' operator later on
this.blocktagre = /^(p|div|h.|ul|ol|dl|menu|dir|pre|blockquote|address|center)$/i;
this.spanre = /^span\b/i;
this.tblre = /^thead|tbody|table|t[rdh]\b/i;
};
KupuUI.prototype = new KupuTool;
KupuUI.prototype.initialize = function(editor) {
/* initialize the ui like tools */
this.editor = editor;
this.cleanStyles();
this.enableOptions(false);
if (this.tsselect) {
this._selectevent = addEventHandler(this.tsselect, 'change', this.setTextStyleHandler, this);
}
};
KupuUI.prototype.getStyles = function() {
if (!this.paraoptions) {
this.cleanStyles();
}
return [ this.paraoptions, this.tableoptions ];
};
KupuUI.prototype.setTextStyleHandler = function(event) {
this.setTextStyle(this.tsselect.options[this.tsselect.selectedIndex].value);
};
// event handlers
KupuUI.prototype.basicButtonHandler = function(action) {
/* event handler for basic actions (toolbar buttons) */
this.editor.execCommand(action);
this.editor.updateState();
};
KupuUI.prototype.saveButtonHandler = function() {
/* handler for the save button */
this.editor.saveDocument();
};
KupuUI.prototype.saveAndExitButtonHandler = function(redirect_url) {
/* save the document and, if successful, redirect */
this.editor.saveDocument(redirect_url);
};
KupuUI.prototype.cutButtonHandler = function() {
try {
this.editor.execCommand('Cut');
} catch (e) {
if (this.editor.getBrowserName() == 'Mozilla') {
alert(_('Cutting from JavaScript is disabled on your Mozilla due to security settings. For more information, read http://www.mozilla.org/editor/midasdemo/securityprefs.html'));
} else {
throw e;
};
};
this.editor.updateState();
};
KupuUI.prototype.copyButtonHandler = function() {
try {
this.editor.execCommand('Copy');
} catch (e) {
if (this.editor.getBrowserName() == 'Mozilla') {
alert(_('Copying from JavaScript is disabled on your Mozilla due to security settings. For more information, read http://www.mozilla.org/editor/midasdemo/securityprefs.html'));
} else {
throw e;
};
};
this.editor.updateState();
};
KupuUI.prototype.pasteButtonHandler = function() {
try {
this.editor.execCommand('Paste');
} catch (e) {
if (this.editor.getBrowserName() == 'Mozilla') {
alert(_('Pasting from JavaScript is disabled on your Mozilla due to security settings. For more information, read http://www.mozilla.org/editor/midasdemo/securityprefs.html'));
} else {
throw e;
};
};
this.editor.updateState();
};
KupuUI.prototype.cleanStyles = function() {
if (!this.tsselect) return;
var options = this.tsselect.options;
var parastyles = this.styles;
var tablestyles = this.tablestyles;
var charstyles = this.charstyles;
var normal = ['Normal', 'p|'];
var td = ['Plain Cell', 'td|'];
var nostyle = ['(remove style)', ''];
var opts = [];
while (options.length) {
var opt = options[0];
options[0] = null;
var v = opt.value;
if (v.indexOf('|') > -1) {
var split = v.split('|');
v = split[0].toLowerCase() + "|" + split[1];
} else {
v = v.toLowerCase()+"|";
};
var optarray = [opt.text, v];
if (v=='td|') {
td = optarray;
} else if (v=='p|') {
normal = optarray;
} else if (v=='') {
nostyle = optarray;
} else {
opts.push([opt.text,v]);
}
}
this.tableoptions.push(td);
tablestyles[td[1]] = 0;
this.paraoptions.push(normal);
parastyles[normal[1]] = 0;
for (var i = 0; i < opts.length; i++) {
optarray = opts[i];
v = optarray[1];
if (this.spanre.test(v)) {
charstyles[v] = this.styleoptions.length;
this.styleoptions.push(optarray);
} else if (this.tblre.test(v)) {
tablestyles[v] = this.tableoptions.length;
this.tableoptions.push(optarray);
} else {
parastyles[v] = this.paraoptions.length;
this.paraoptions.push(optarray);
};
};
this.paraoptions.push(nostyle);
this.styleoffset = this.paraoptions.length;
this.tableoffset = this.styleoffset + this.styleoptions.length;
};
// Remove otherstyle and switch to appropriate style set.
KupuUI.prototype.enableOptions = function(inTable) {
if (!this.tsselect) return;
var select = this.tsselect;
var options = select.options;
if (this.otherstyle) {
options[0] = null;
this.otherstyle = null;
}
if (this.optionstate == inTable) return; /* No change */
// while (select.firstChild) select.removeChild(select.firstChild);
function option(info) {
return newElement('option', {'value': info[1]}, [info[0]]);
}
if (this.optionstate==-1) {
for (var i = 0; i < this.paraoptions.length; i++) {
select.appendChild(option(this.paraoptions[i]));
}
if (this.styleoptions.length) {
var grp = document.createElement('optgroup');
grp.label = 'Character styles';
for (var i = 0; i < this.styleoptions.length; i++) {
grp.appendChild(option(this.styleoptions[i]));
}
select.appendChild(grp);
}
}
if (inTable) {
var grp = (this.tablegrp = document.createElement('optgroup'));
grp.label = 'Table elements';
for (var i = 0; i < this.tableoptions.length; i++) {
grp.appendChild(option(this.tableoptions[i]));
}
select.appendChild(grp);
} else {
while (select.options[this.tableoffset]) {
select.options[this.tableoffset] = null;
};
if (this.tablegrp) {
select.removeChild(this.tablegrp);
this.tablegrp = null;
};
};
this.optionstate = inTable;
};
KupuUI.prototype.setIndex = function(currnode, tag, index, styles) {
var className = currnode.className;
this.styletag = tag;
this.classname = className;
var style = tag+'|'+className;
if (style in styles) {
return styles[style];
} else if (!className && tag in styles) {
return styles[tag];
}
return index;
};
KupuUI.prototype.nodeStyle = function(node) {
var currnode = node;
var index = -1;
this.styletag = undefined;
this.classname = '';
// Set the table state correctly
this.intable = false;
while(currnode) {
var tag = currnode.nodeName;
if (/^body$/i.test(tag)) break;
if (this.tblre.test(tag)) {
this.intable = true;
break;
};
currnode = currnode.parentNode;
};
currnode = node;
while (currnode) {
var tag = currnode.nodeName.toLowerCase();
if (/^body$/.test(tag)) {
if (!this.styletag) {
// Forced style messes up in Firefox: return -1 to
// indicate no style
return -1;
}
break;
}
if (this.spanre.test(tag)) {
index = this.setIndex(currnode, tag, index, this.charstyles);
if (index >= 0) return index+this.styleoffset; // span takes priority
} else if (this.blocktagre.test(tag)) {
index = this.setIndex(currnode, tag, index, this.styles);
} else if (this.tblre.test(tag)) {
if (index > 0) return index; // block or span takes priority.
index = this.setIndex(currnode, tag, index, this.tablestyles);
if (index >= 0 || tag=='table') {
return index+this.tableoffset; // Stop processing if in a table
}
}
currnode = currnode.parentNode;
}
return index;
};
KupuUI.prototype.updateState = function(selNode) {
/* set the text-style pulldown */
// first get the nearest style
// search the list of nodes like in the original one, break if we encounter a match,
// this method does some more than the original one since it can handle commands in
// the form of '