You are viewing a plain text version of this content. The canonical link for it is here.
Posted to graffito-commits@incubator.apache.org by cl...@apache.org on 2006/10/09 21:28:32 UTC

svn commit: r454522 [7/10] - in /incubator/graffito/trunk: applications/browser/src/java/org/apache/portals/graffito/servlets/ applications/browser/src/java/org/apache/portals/graffito/servlets/browser/ applications/browser/src/webapp/META-INF/ applica...

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuhelpers.js
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuhelpers.js?view=auto&rev=454522
==============================================================================
--- incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuhelpers.js (added)
+++ incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuhelpers.js Mon Oct  9 14:28:27 2006
@@ -0,0 +1,1345 @@
+/*****************************************************************************
+ *
+ * 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 21722 2006-01-05 17:27:50Z 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 addEventHandler(element, event, method, context) {
+    /* method to add an event handler for both IE and Mozilla */
+    var wrappedmethod = new ContextFixer(method, context);
+    var args = new Array(null, null);
+    for (var i=4; i < arguments.length; i++) {
+        args.push(arguments[i]);
+    };
+    wrappedmethod.args = args;
+    try {
+        if (_SARISSA_IS_MOZ) {
+            element.addEventListener(event, wrappedmethod.execute, false);
+        } else if (_SARISSA_IS_IE) {
+            element.attachEvent("on" + event, wrappedmethod.execute);
+        } else {
+            throw _("Unsupported browser!");
+        };
+        return wrappedmethod.execute;
+    } catch(e) {
+        alert(_('exception ${message} while registering an event handler ' +
+                'for element ${element}, event ${event}, method ${method}',
+                {'message': e.message, 'element': element,
+                    'event': event,
+                    'method': method}));
+    };
+};
+
+function removeEventHandler(element, event, method) {
+    /* method to remove an event handler for both IE and Mozilla */
+    if (_SARISSA_IS_MOZ) {
+        window.removeEventListener(event, method, false);
+    } else if (_SARISSA_IS_IE) {
+        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) {
+    /* open and center a popup window */
+    var sw = screen.width;
+    var sh = screen.height;
+    var left = sw / 2 - width / 2;
+    var top = sh / 2 - height / 2;
+    var win = window.open(url, 'someWindow', 
+                'width=' + width + ',height=' + height + ',left=' + left + ',top=' + top);
+    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();
+            if (dict[name] != undefined) {
+                if (!dict[name].push) {
+                    dict[name] = new Array(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) {
+    this.document = document;
+    this.selection = document.getWindow().getSelection();
+    
+    this.selectNodeContents = function(node) {
+        /* select the contents of a node */
+        this.selection.removeAllRanges();
+        this.selection.selectAllChildren(node);
+    };
+
+    this.collapse = function(collapseToEnd) {
+        try {
+            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.document.getDocument().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);
+                };
+            }
+
+            range.setEnd(afterNode, 0);
+            range.setStart(afterNode, 0);
+        }
+
+        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 = this.document.getWindow().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);
+                };
+            };
+            this.document.getWindow().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;
+            };
+            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.document.getDocument().createRange();
+        arange.setStart(anode, aoffset);
+        var orange = this.document.getDocument().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 != 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.document.getDocument().createRange();
+        arange.setStart(anode, aoffset);
+        var orange = this.document.getDocument().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 endoffset = 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() {
+        /* return the selected node (or the node containing the selection) */
+        // XXX this should be on a range object
+        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 = range.commonAncestorContainer;
+
+            // the following deals with cases where only a single child is
+            // selected, e.g. after a click on an image
+            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) {
+                // XXX the additional conditions catch some invisible
+                // intersections, but still not all of them
+                if (range.intersectsNode(child) &&
+                    !(child == startNode && startOffset == child.length) &&
+                    !(child == endNode && endOffset == 0)) {
+                    if (selectedChild) {
+                        // current child is the second selected child found
+                        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;
+            var startparent = null;
+            var startoffset = 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 = this.document.getWindow().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) {
+        return this.selection.containsNode(node, true);
+    }
+
+    this.toString = function() {
+        return this.selection.toString();
+    };
+
+    this.getRange = function() {
+        return this.selection.getRangeAt(0);
+    }
+    this.restoreRange = function(range) {
+        var selection = this.selection;
+        selection.removeAllRanges();
+        selection.addRange(range);
+    }
+};
+
+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.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 = this.selection.createRange().duplicate();
+        range.moveToElementText(node);
+        range.moveStart('character', 1);
+        range.moveStart('character', -1);
+        range.moveEnd('character', -1);
+        range.moveEnd('character', 1);
+        range.select();
+        this.selection = this.document.getDocument().selection;
+    };
+
+    this.collapse = function(collapseToEnd) {
+        var range = this.selection.createRange();
+        range.collapse(!collapseToEnd);
+        range.select();
+        this.selection = document.getDocument().selection;
+    };
+
+    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('<img id="kupu-tempnode">');
+            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() {
+        /* 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.moveEnd = function(offset) {
+        /* moves the end of the selection */
+        var range = this.selection.createRange();
+        range.moveEnd('character', offset);
+        range.select();
+    };
+
+    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();
+        } catch(e) {
+        };
+    }
+
+    this.toString = function() {
+        return this.selection.createRange().text;
+    };
+};
+
+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 = new Array();
+        // 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 = new Array();
+        for (var i=0; i < arguments.length - 3; i++) {
+            args.push(arguments[i + 3]);
+        }
+        var id = this._createUniqueId();
+        this.functions[id] = new Array(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 */
+    var spacereg = /(\s+)/g;
+    var copy = this;
+    while (true) {
+        var match = spacereg.exec(copy);
+        if (!match) {
+            return copy;
+        };
+        copy = copy.replace(match[0], ' ');
+    };
+};
+
+String.prototype.entitize = function() {
+    var ret = this.replace(/&/g, '&amp;');
+    ret = ret.replace(/"/g, '&quot;');
+    ret = ret.replace(/'/g, '&apos;');
+    ret = ret.replace(/</g, '&lt;');
+    ret = ret.replace(/>/g, '&gt;');
+    return ret;
+};
+
+String.prototype.deentitize = function() {
+    var ret = this.replace(/&gt;/g, '>');
+    ret = ret.replace(/&lt;/g, '<');
+    ret = ret.replace(/&quot;/g, '"');
+    ret = ret.replace(/&apos;/g, "'");
+    ret = ret.replace(/&amp;/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();

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/background-color.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/background-color.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/background-color.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/bold.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/bold.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/bold.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/bold.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/bold.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/bold.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/buttons.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/buttons.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/buttons.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/caret.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/caret.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/caret.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/closed.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/closed.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/closed.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/copy.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/copy.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/copy.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/create-new.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/create-new.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/create-new.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/cut.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/cut.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/cut.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/definitionlist.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/definitionlist.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/definitionlist.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/document.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/document.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/document.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/exit.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/exit.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/exit.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/exthyperlink.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/exthyperlink.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/exthyperlink.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/folder.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/folder.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/folder.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/fonts.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/fonts.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/fonts.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/format.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/format.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/format.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/hr.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/hr.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/hr.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/image.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/image.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/image.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/indent.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/indent.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/indent.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/indent.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/indent.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/indent.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/inthyperlink.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/inthyperlink.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/inthyperlink.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/italic.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/italic.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/italic.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/italic.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/italic.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/italic.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-center.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-center.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-center.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-full.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-full.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-full.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-left.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-left.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-left.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-right.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-right.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/justify-right.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupu_icon.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupu_icon.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupu_icon.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupulibrary.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupulibrary.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupulibrary.png
------------------------------------------------------------------------------
    svn:executable = *

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupulibrary.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupusearch_icon.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupusearch_icon.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/kupusearch_icon.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/larger-text.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/larger-text.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/larger-text.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/link.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/link.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/link.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/opened.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/opened.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/opened.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/ordered-list.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/ordered-list.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/ordered-list.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/outdent.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/outdent.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/outdent.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/paste.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/paste.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/paste.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/redo-disabled.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/redo-disabled.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/redo-disabled.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/redo.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/redo.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/redo.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/remove.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/remove.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/remove.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/save.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/save.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/save.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/size.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/size.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/size.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/smaller-text.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/smaller-text.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/smaller-text.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/space.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/space.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/space.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/strikethrough.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/strikethrough.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/strikethrough.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/subscript.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/subscript.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/subscript.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/superscript.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/superscript.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/superscript.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/table.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/table.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/table.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/text-check.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/text-check.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/text-check.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/text-color.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/text-color.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/text-color.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_blue.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_blue.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_blue.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_green.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_green.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_green.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_purple.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_purple.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_purple.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_wood.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_wood.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/toolbarbg_wood.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/underline.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/underline.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/underline.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/underline.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/underline.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/underline.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/undo-disabled.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/undo-disabled.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/undo-disabled.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/undo.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/undo.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/undo.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/unlink.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/unlink.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/unlink.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/unordered-list.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/unordered-list.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/unordered-list.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/view-source.png
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/view-source.png?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/view-source.png
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/zoom-in.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/zoom-in.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/zoom-in.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/zoom-out.gif
URL: http://svn.apache.org/viewvc/incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/zoom-out.gif?view=auto&rev=454522
==============================================================================
Binary file - no diff available.

Propchange: incubator/graffito/trunk/applications/browser/src/webapp/kupu-1.3.5/kupuimages/zoom-out.gif
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream