Subversion-Projekte lars-tiefland.content-management

/**
 * editor_plugin_src.js
 *
 * Copyright 2011, Moxiecode Systems AB
 * Released under LGPL License.
 *
 * License: http://tinymce.moxiecode.com/license
 * Contributing: http://tinymce.moxiecode.com/contributing
 */

(function() {
        var each = tinymce.each, Event = tinymce.dom.Event, bookmark;

        // Skips text nodes that only contain whitespace since they aren't semantically important.
        function skipWhitespaceNodes(e, next) {
                while (e && (e.nodeType === 8 || (e.nodeType === 3 && /^[ \t\n\r]*$/.test(e.nodeValue)))) {
                        e = next(e);
                }
                return e;
        }

        function skipWhitespaceNodesBackwards(e) {
                return skipWhitespaceNodes(e, function(e) {
                        return e.previousSibling;
                });
        }

        function skipWhitespaceNodesForwards(e) {
                return skipWhitespaceNodes(e, function(e) {
                        return e.nextSibling;
                });
        }

        function hasParentInList(ed, e, list) {
                return ed.dom.getParent(e, function(p) {
                        return tinymce.inArray(list, p) !== -1;
                });
        }

        function isList(e) {
                return e && (e.tagName === 'OL' || e.tagName === 'UL');
        }

        function splitNestedLists(element, dom) {
                var tmp, nested, wrapItem;
                tmp = skipWhitespaceNodesBackwards(element.lastChild);
                while (isList(tmp)) {
                        nested = tmp;
                        tmp = skipWhitespaceNodesBackwards(nested.previousSibling);
                }
                if (nested) {
                        wrapItem = dom.create('li', { style: 'list-style-type: none;'});
                        dom.split(element, nested);
                        dom.insertAfter(wrapItem, nested);
                        wrapItem.appendChild(nested);
                        wrapItem.appendChild(nested);
                        element = wrapItem.previousSibling;
                }
                return element;
        }

        function attemptMergeWithAdjacent(e, allowDifferentListStyles, mergeParagraphs) {
                e = attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs);
                return attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs);
        }

        function attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs) {
                var prev = skipWhitespaceNodesBackwards(e.previousSibling);
                if (prev) {
                        return attemptMerge(prev, e, allowDifferentListStyles ? prev : false, mergeParagraphs);
                } else {
                        return e;
                }
        }

        function attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs) {
                var next = skipWhitespaceNodesForwards(e.nextSibling);
                if (next) {
                        return attemptMerge(e, next, allowDifferentListStyles ? next : false, mergeParagraphs);
                } else {
                        return e;
                }
        }

        function attemptMerge(e1, e2, differentStylesMasterElement, mergeParagraphs) {
                if (canMerge(e1, e2, !!differentStylesMasterElement, mergeParagraphs)) {
                        return merge(e1, e2, differentStylesMasterElement);
                } else if (e1 && e1.tagName === 'LI' && isList(e2)) {
                        // Fix invalidly nested lists.
                        e1.appendChild(e2);
                }
                return e2;
        }

        function canMerge(e1, e2, allowDifferentListStyles, mergeParagraphs) {
                if (!e1 || !e2) {
                        return false;
                } else if (e1.tagName === 'LI' && e2.tagName === 'LI') {
                        return e2.style.listStyleType === 'none' || containsOnlyAList(e2);
                } else if (isList(e1)) {
                        return (e1.tagName === e2.tagName && (allowDifferentListStyles || e1.style.listStyleType === e2.style.listStyleType)) || isListForIndent(e2);
                } else if (mergeParagraphs && e1.tagName === 'P' && e2.tagName === 'P') {
                        return true;
                } else {
                        return false;
                }
        }

        function isListForIndent(e) {
                var firstLI = skipWhitespaceNodesForwards(e.firstChild), lastLI = skipWhitespaceNodesBackwards(e.lastChild);
                return firstLI && lastLI && isList(e) && firstLI === lastLI && (isList(firstLI) || firstLI.style.listStyleType === 'none' || containsOnlyAList(firstLI));
        }

        function containsOnlyAList(e) {
                var firstChild = skipWhitespaceNodesForwards(e.firstChild), lastChild = skipWhitespaceNodesBackwards(e.lastChild);
                return firstChild && lastChild && firstChild === lastChild && isList(firstChild);
        }

        function merge(e1, e2, masterElement) {
                var lastOriginal = skipWhitespaceNodesBackwards(e1.lastChild), firstNew = skipWhitespaceNodesForwards(e2.firstChild);
                if (e1.tagName === 'P') {
                        e1.appendChild(e1.ownerDocument.createElement('br'));
                }
                while (e2.firstChild) {
                        e1.appendChild(e2.firstChild);
                }
                if (masterElement) {
                        e1.style.listStyleType = masterElement.style.listStyleType;
                }
                e2.parentNode.removeChild(e2);
                attemptMerge(lastOriginal, firstNew, false);
                return e1;
        }

        function findItemToOperateOn(e, dom) {
                var item;
                if (!dom.is(e, 'li,ol,ul')) {
                        item = dom.getParent(e, 'li');
                        if (item) {
                                e = item;
                        }
                }
                return e;
        }

        tinymce.create('tinymce.plugins.Lists', {
                init: function(ed, url) {
                        var LIST_TABBING = 0;
                        var LIST_EMPTY_ITEM = 1;
                        var LIST_ESCAPE = 2;
                        var LIST_UNKNOWN = 3;
                        var state = LIST_UNKNOWN;

                        function isTabInList(e) {
                                return e.keyCode === 9 && (ed.queryCommandState('InsertUnorderedList') || ed.queryCommandState('InsertOrderedList'));
                        }

                        function isOnLastListItem() {
                                var li = getLi();
                                var grandParent = li.parentNode.parentNode;
                                var isLastItem = li.parentNode.lastChild === li;
                                return isLastItem && !isNestedList(grandParent) && isEmptyListItem(li);
                        }

                        function isNestedList(grandParent) {
                                if (isList(grandParent)) {
                                        return grandParent.parentNode && grandParent.parentNode.tagName === 'LI';
                                } else {
                                        return  grandParent.tagName === 'LI';
                                }
                        }

                        function isInEmptyListItem() {
                                return ed.selection.isCollapsed() && isEmptyListItem(getLi());
                        }

                        function getLi() {
                                var n = ed.selection.getStart();
                                // Get start will return BR if the LI only contains a BR or an empty element as we use these to fix caret position
                                return ((n.tagName == 'BR' || n.tagName == '') && n.parentNode.tagName == 'LI') ? n.parentNode : n;
                        }

                        function isEmptyListItem(li) {
                                var numChildren = li.childNodes.length;
                                if (li.tagName === 'LI') {
                                        return numChildren == 0 ? true : numChildren == 1 && (li.firstChild.tagName == '' || isEmptyWebKitLi(li) || isEmptyIE9Li(li));
                                }
                                return false;
                        }

                        function isEmptyWebKitLi(li) {
                                // Check for empty LI or a LI with just a child that is a BR since Gecko and WebKit uses BR elements to place the caret
                                return tinymce.isWebKit && li.firstChild.nodeName == 'BR';
                        }

                        function isEmptyIE9Li(li) {
                                // only consider this to be last item if there is no list item content or that content is nbsp or space since IE9 creates these
                                var lis = tinymce.grep(li.parentNode.childNodes, function(n) {return n.nodeName == 'LI'});
                                var isLastLi = li == lis[lis.length - 1];
                                var child = li.firstChild;
                                return tinymce.isIE9 && isLastLi && (child.nodeValue == String.fromCharCode(160) || child.nodeValue == String.fromCharCode(32));
                        }

                        function isEnter(e) {
                                return e.keyCode === 13;
                        }

                        function getListKeyState(e) {
                                if (isTabInList(e)) {
                                        return LIST_TABBING;
                                } else if (isEnter(e) && isOnLastListItem()) {
                                        return LIST_ESCAPE;
                                } else if (isEnter(e) && isInEmptyListItem()) {
                                        return LIST_EMPTY_ITEM;
                                } else {
                                        return LIST_UNKNOWN;
                                }
                        }

                        function cancelEnterAndTab(_, e) {
                                if (state == LIST_TABBING || state == LIST_EMPTY_ITEM) {
                                        return Event.cancel(e);
                                }
                        }

                        function imageJoiningListItem(ed, e) {
                                var prevSibling;

                                if (!tinymce.isGecko)
                                        return;

                                var n = ed.selection.getStart();
                                if (e.keyCode != 8 || n.tagName !== 'IMG')
                                        return;

                                function lastLI(node) {
                                        var child = node.firstChild;
                                        var li = null;
                                        do {
                                                if (!child)
                                                        break;

                                                if (child.tagName === 'LI')
                                                        li = child;
                                        } while (child = child.nextSibling);

                                        return li;
                                }

                                function addChildren(parentNode, destination) {
                                        while (parentNode.childNodes.length > 0)
                                                destination.appendChild(parentNode.childNodes[0]);
                                }

                                // Check if there is a previous sibling
                                prevSibling = n.parentNode.previousSibling;
                                if (!prevSibling)
                                        return;

                                var ul;
                                if (prevSibling.tagName === 'UL' || prevSibling.tagName === 'OL')
                                        ul = prevSibling;
                                else if (prevSibling.previousSibling && (prevSibling.previousSibling.tagName === 'UL' || prevSibling.previousSibling.tagName === 'OL'))
                                        ul = prevSibling.previousSibling;
                                else
                                        return;

                                var li = lastLI(ul);

                                // move the caret to the end of the list item
                                var rng = ed.dom.createRng();
                                rng.setStart(li, 1);
                                rng.setEnd(li, 1);
                                ed.selection.setRng(rng);
                                ed.selection.collapse(true);

                                // save a bookmark at the end of the list item
                                var bookmark = ed.selection.getBookmark();

                                // copy the image an its text to the list item
                                var clone = n.parentNode.cloneNode(true);
                                if (clone.tagName === 'P' || clone.tagName === 'DIV')
                                        addChildren(clone, li);
                                else
                                        li.appendChild(clone);

                                // remove the old copy of the image
                                n.parentNode.parentNode.removeChild(n.parentNode);

                                // move the caret where we saved the bookmark
                                ed.selection.moveToBookmark(bookmark);
                        }

                        // fix the cursor position to ensure it is correct in IE
                        function setCursorPositionToOriginalLi(li) {
                                var list = ed.dom.getParent(li, 'ol,ul');
                                if (list != null) {
                                        var lastLi = list.lastChild;
                                        lastLi.appendChild(ed.getDoc().createElement(''));
                                        ed.selection.setCursorLocation(lastLi, 0);
                                }
                        }

                        this.ed = ed;
                        ed.addCommand('Indent', this.indent, this);
                        ed.addCommand('Outdent', this.outdent, this);
                        ed.addCommand('InsertUnorderedList', function() {
                                this.applyList('UL', 'OL');
                        }, this);
                        ed.addCommand('InsertOrderedList', function() {
                                this.applyList('OL', 'UL');
                        }, this);

                        ed.onInit.add(function() {
                                ed.editorCommands.addCommands({
                                        'outdent': function() {
                                                var sel = ed.selection, dom = ed.dom;

                                                function hasStyleIndent(n) {
                                                        n = dom.getParent(n, dom.isBlock);
                                                        return n && (parseInt(ed.dom.getStyle(n, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(n, 'padding-left') || 0, 10)) > 0;
                                                }

                                                return hasStyleIndent(sel.getStart()) || hasStyleIndent(sel.getEnd()) || ed.queryCommandState('InsertOrderedList') || ed.queryCommandState('InsertUnorderedList');
                                        }
                                }, 'state');
                        });

                        ed.onKeyUp.add(function(ed, e) {
                                if (state == LIST_TABBING) {
                                        ed.execCommand(e.shiftKey ? 'Outdent' : 'Indent', true, null);
                                        state = LIST_UNKNOWN;
                                        return Event.cancel(e);
                                } else if (state == LIST_EMPTY_ITEM) {
                                        var li = getLi();
                                        var shouldOutdent =  ed.settings.list_outdent_on_enter === true || e.shiftKey;
                                        ed.execCommand(shouldOutdent ? 'Outdent' : 'Indent', true, null);
                                        if (tinymce.isIE) {
                                                setCursorPositionToOriginalLi(li);
                                        }
                                        return Event.cancel(e);
                                } else if (state == LIST_ESCAPE) {
                                        if (tinymce.isIE8) {
                                                // append a zero sized nbsp so that caret is positioned correctly in IE8 after escaping and applying formatting.
                                                // if there is no text then applying formatting for e.g a H1 to the P tag immediately following list after
                                                // escaping from it will cause the caret to be positioned on the last li instead of staying the in P tag.
                                                var n = ed.getDoc().createTextNode('\uFEFF');
                                                ed.selection.getNode().appendChild(n);
                                        } else if (tinymce.isIE9) {
                                                // IE9 does not escape the list so we use outdent to do this and cancel the default behaviour
                                                ed.execCommand('Outdent');
                                                return Event.cancel(e);
                                        }
                                }
                        });
                        ed.onKeyDown.add(function(_, e) { state = getListKeyState(e); });
                        ed.onKeyDown.add(cancelEnterAndTab);
                        ed.onKeyDown.add(imageJoiningListItem);
                        ed.onKeyPress.add(cancelEnterAndTab);
                },

                applyList: function(targetListType, oppositeListType) {
                        var t = this, ed = t.ed, dom = ed.dom, applied = [], hasSameType = false, hasOppositeType = false, hasNonList = false, actions,
                                        selectedBlocks = ed.selection.getSelectedBlocks();

                        function cleanupBr(e) {
                                if (e && e.tagName === 'BR') {
                                        dom.remove(e);
                                }
                        }

                        function makeList(element) {
                                var list = dom.create(targetListType), li;

                                function adjustIndentForNewList(element) {
                                        // If there's a margin-left, outdent one level to account for the extra list margin.
                                        if (element.style.marginLeft || element.style.paddingLeft) {
                                                t.adjustPaddingFunction(false)(element);
                                        }
                                }

                                if (element.tagName === 'LI') {
                                        // No change required.
                                } else if (element.tagName === 'P' || element.tagName === 'DIV' || element.tagName === 'BODY') {
                                        processBrs(element, function(startSection, br, previousBR) {
                                                doWrapList(startSection, br, element.tagName === 'BODY' ? null : startSection.parentNode);
                                                li = startSection.parentNode;
                                                adjustIndentForNewList(li);
                                                cleanupBr(br);
                                        });
                                        if (element.tagName === 'P' || selectedBlocks.length > 1) {
                                                dom.split(li.parentNode.parentNode, li.parentNode);
                                        }
                                        attemptMergeWithAdjacent(li.parentNode, true);
                                        return;
                                } else {
                                        // Put the list around the element.
                                        li = dom.create('li');
                                        dom.insertAfter(li, element);
                                        li.appendChild(element);
                                        adjustIndentForNewList(element);
                                        element = li;
                                }
                                dom.insertAfter(list, element);
                                list.appendChild(element);
                                attemptMergeWithAdjacent(list, true);
                                applied.push(element);
                        }

                        function doWrapList(start, end, template) {
                                var li, n = start, tmp, i;
                                while (!dom.isBlock(start.parentNode) && start.parentNode !== dom.getRoot()) {
                                        start = dom.split(start.parentNode, start.previousSibling);
                                        start = start.nextSibling;
                                        n = start;
                                }
                                if (template) {
                                        li = template.cloneNode(true);
                                        start.parentNode.insertBefore(li, start);
                                        while (li.firstChild) dom.remove(li.firstChild);
                                        li = dom.rename(li, 'li');
                                } else {
                                        li = dom.create('li');
                                        start.parentNode.insertBefore(li, start);
                                }
                                while (n && n != end) {
                                        tmp = n.nextSibling;
                                        li.appendChild(n);
                                        n = tmp;
                                }
                                if (li.childNodes.length === 0) {
                                        li.innerHTML = '<br _mce_bogus="1" />';
                                }
                                makeList(li);
                        }

                        function processBrs(element, callback) {
                                var startSection, previousBR, END_TO_START = 3, START_TO_END = 1,
                                                breakElements = 'br,ul,ol,p,div,h1,h2,h3,h4,h5,h6,table,blockquote,address,pre,form,center,dl';

                                function isAnyPartSelected(start, end) {
                                        var r = dom.createRng(), sel;
                                        bookmark.keep = true;
                                        ed.selection.moveToBookmark(bookmark);
                                        bookmark.keep = false;
                                        sel = ed.selection.getRng(true);
                                        if (!end) {
                                                end = start.parentNode.lastChild;
                                        }
                                        r.setStartBefore(start);
                                        r.setEndAfter(end);
                                        return !(r.compareBoundaryPoints(END_TO_START, sel) > 0 || r.compareBoundaryPoints(START_TO_END, sel) <= 0);
                                }

                                function nextLeaf(br) {
                                        if (br.nextSibling)
                                                return br.nextSibling;
                                        if (!dom.isBlock(br.parentNode) && br.parentNode !== dom.getRoot())
                                                return nextLeaf(br.parentNode);
                                }

                                // Split on BRs within the range and process those.
                                startSection = element.firstChild;
                                // First mark the BRs that have any part of the previous section selected.
                                var trailingContentSelected = false;
                                each(dom.select(breakElements, element), function(br) {
                                        var b;
                                        if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {
                                                return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.
                                        }
                                        if (isAnyPartSelected(startSection, br)) {
                                                dom.addClass(br, '_mce_tagged_br');
                                                startSection = nextLeaf(br);
                                        }
                                });
                                trailingContentSelected = (startSection && isAnyPartSelected(startSection, undefined));
                                startSection = element.firstChild;
                                each(dom.select(breakElements, element), function(br) {
                                        // Got a section from start to br.
                                        var tmp = nextLeaf(br);
                                        if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {
                                                return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.
                                        }
                                        if (dom.hasClass(br, '_mce_tagged_br')) {
                                                callback(startSection, br, previousBR);
                                                previousBR = null;
                                        } else {
                                                previousBR = br;
                                        }
                                        startSection = tmp;
                                });
                                if (trailingContentSelected) {
                                        callback(startSection, undefined, previousBR);
                                }
                        }

                        function wrapList(element) {
                                processBrs(element, function(startSection, br, previousBR) {
                                        // Need to indent this part
                                        doWrapList(startSection, br);
                                        cleanupBr(br);
                                        cleanupBr(previousBR);
                                });
                        }

                        function changeList(element) {
                                if (tinymce.inArray(applied, element) !== -1) {
                                        return;
                                }
                                if (element.parentNode.tagName === oppositeListType) {
                                        dom.split(element.parentNode, element);
                                        makeList(element);
                                        attemptMergeWithNext(element.parentNode, false);
                                }
                                applied.push(element);
                        }

                        function convertListItemToParagraph(element) {
                                var child, nextChild, mergedElement, splitLast;
                                if (tinymce.inArray(applied, element) !== -1) {
                                        return;
                                }
                                element = splitNestedLists(element, dom);
                                while (dom.is(element.parentNode, 'ol,ul,li')) {
                                        dom.split(element.parentNode, element);
                                }
                                // Push the original element we have from the selection, not the renamed one.
                                applied.push(element);
                                element = dom.rename(element, 'p');
                                mergedElement = attemptMergeWithAdjacent(element, false, ed.settings.force_br_newlines);
                                if (mergedElement === element) {
                                        // Now split out any block elements that can't be contained within a P.
                                        // Manually iterate to ensure we handle modifications correctly (doesn't work with tinymce.each)
                                        child = element.firstChild;
                                        while (child) {
                                                if (dom.isBlock(child)) {
                                                        child = dom.split(child.parentNode, child);
                                                        splitLast = true;
                                                        nextChild = child.nextSibling && child.nextSibling.firstChild;
                                                } else {
                                                        nextChild = child.nextSibling;
                                                        if (splitLast && child.tagName === 'BR') {
                                                                dom.remove(child);
                                                        }
                                                        splitLast = false;
                                                }
                                                child = nextChild;
                                        }
                                }
                        }

                        each(selectedBlocks, function(e) {
                                e = findItemToOperateOn(e, dom);
                                if (e.tagName === oppositeListType || (e.tagName === 'LI' && e.parentNode.tagName === oppositeListType)) {
                                        hasOppositeType = true;
                                } else if (e.tagName === targetListType || (e.tagName === 'LI' && e.parentNode.tagName === targetListType)) {
                                        hasSameType = true;
                                } else {
                                        hasNonList = true;
                                }
                        });

                        if (hasNonList || hasOppositeType || selectedBlocks.length === 0) {
                                actions = {
                                        'LI': changeList,
                                        'H1': makeList,
                                        'H2': makeList,
                                        'H3': makeList,
                                        'H4': makeList,
                                        'H5': makeList,
                                        'H6': makeList,
                                        'P': makeList,
                                        'BODY': makeList,
                                        'DIV': selectedBlocks.length > 1 ? makeList : wrapList,
                                        defaultAction: wrapList
                                };
                        } else {
                                actions = {
                                        defaultAction: convertListItemToParagraph
                                };
                        }
                        this.process(actions);
                },

                indent: function() {
                        var ed = this.ed, dom = ed.dom, indented = [];

                        function createWrapItem(element) {
                                var wrapItem = dom.create('li', { style: 'list-style-type: none;'});
                                dom.insertAfter(wrapItem, element);
                                return wrapItem;
                        }

                        function createWrapList(element) {
                                var wrapItem = createWrapItem(element),
                                                list = dom.getParent(element, 'ol,ul'),
                                                listType = list.tagName,
                                                listStyle = dom.getStyle(list, 'list-style-type'),
                                                attrs = {},
                                                wrapList;
                                if (listStyle !== '') {
                                        attrs.style = 'list-style-type: ' + listStyle + ';';
                                }
                                wrapList = dom.create(listType, attrs);
                                wrapItem.appendChild(wrapList);
                                return wrapList;
                        }

                        function indentLI(element) {
                                if (!hasParentInList(ed, element, indented)) {
                                        element = splitNestedLists(element, dom);
                                        var wrapList = createWrapList(element);
                                        wrapList.appendChild(element);
                                        attemptMergeWithAdjacent(wrapList.parentNode, false);
                                        attemptMergeWithAdjacent(wrapList, false);
                                        indented.push(element);
                                }
                        }

                        this.process({
                                'LI': indentLI,
                                defaultAction: this.adjustPaddingFunction(true)
                        });

                },

                outdent: function() {
                        var t = this, ed = t.ed, dom = ed.dom, outdented = [];

                        function outdentLI(element) {
                                var listElement, targetParent, align;
                                if (!hasParentInList(ed, element, outdented)) {
                                        if (dom.getStyle(element, 'margin-left') !== '' || dom.getStyle(element, 'padding-left') !== '') {
                                                return t.adjustPaddingFunction(false)(element);
                                        }
                                        align = dom.getStyle(element, 'text-align', true);
                                        if (align === 'center' || align === 'right') {
                                                dom.setStyle(element, 'text-align', 'left');
                                                return;
                                        }
                                        element = splitNestedLists(element, dom);
                                        listElement = element.parentNode;
                                        targetParent = element.parentNode.parentNode;
                                        if (targetParent.tagName === 'P') {
                                                dom.split(targetParent, element.parentNode);
                                        } else {
                                                dom.split(listElement, element);
                                                if (targetParent.tagName === 'LI') {
                                                        // Nested list, need to split the LI and go back out to the OL/UL element.
                                                        dom.split(targetParent, element);
                                                } else if (!dom.is(targetParent, 'ol,ul')) {
                                                        dom.rename(element, 'p');
                                                }
                                        }
                                        outdented.push(element);
                                }
                        }

                        this.process({
                                'LI': outdentLI,
                                defaultAction: this.adjustPaddingFunction(false)
                        });

                        each(outdented, attemptMergeWithAdjacent);
                },

                process: function(actions) {
                        var t = this, sel = t.ed.selection, dom = t.ed.dom, selectedBlocks, r;

                        function processElement(element) {
                                dom.removeClass(element, '_mce_act_on');
                                if (!element || element.nodeType !== 1) {
                                        return;
                                }
                                element = findItemToOperateOn(element, dom);
                                var action = actions[element.tagName];
                                if (!action) {
                                        action = actions.defaultAction;
                                }
                                action(element);
                        }

                        function recurse(element) {
                                t.splitSafeEach(element.childNodes, processElement);
                        }

                        function brAtEdgeOfSelection(container, offset) {
                                return offset >= 0 && container.hasChildNodes() && offset < container.childNodes.length &&
                                                container.childNodes[offset].tagName === 'BR';
                        }

                        selectedBlocks = sel.getSelectedBlocks();
                        if (selectedBlocks.length === 0) {
                                selectedBlocks = [ dom.getRoot() ];
                        }

                        r = sel.getRng(true);
                        if (!r.collapsed) {
                                if (brAtEdgeOfSelection(r.endContainer, r.endOffset - 1)) {
                                        r.setEnd(r.endContainer, r.endOffset - 1);
                                        sel.setRng(r);
                                }
                                if (brAtEdgeOfSelection(r.startContainer, r.startOffset)) {
                                        r.setStart(r.startContainer, r.startOffset + 1);
                                        sel.setRng(r);
                                }
                        }


                        if (tinymce.isIE8) {
                                // append a zero sized nbsp so that caret is restored correctly using bookmark
                                var s = t.ed.selection.getNode();
                                if (s.tagName === 'LI' && !(s.parentNode.lastChild === s)) {
                                        var i = t.ed.getDoc().createTextNode('\uFEFF');
                                        s.appendChild(i);
                                }
                        }

                        bookmark = sel.getBookmark();
                        actions.OL = actions.UL = recurse;
                        t.splitSafeEach(selectedBlocks, processElement);
                        sel.moveToBookmark(bookmark);
                        bookmark = null;
                        // Avoids table or image handles being left behind in Firefox.
                        t.ed.execCommand('mceRepaint');
                },

                splitSafeEach: function(elements, f) {
                        if (tinymce.isGecko && (/Firefox\/[12]\.[0-9]/.test(navigator.userAgent) ||
                                        /Firefox\/3\.[0-4]/.test(navigator.userAgent))) {
                                this.classBasedEach(elements, f);
                        } else {
                                each(elements, f);
                        }
                },

                classBasedEach: function(elements, f) {
                        var dom = this.ed.dom, nodes, element;
                        // Mark nodes
                        each(elements, function(element) {
                                dom.addClass(element, '_mce_act_on');
                        });
                        nodes = dom.select('._mce_act_on');
                        while (nodes.length > 0) {
                                element = nodes.shift();
                                dom.removeClass(element, '_mce_act_on');
                                f(element);
                                nodes = dom.select('._mce_act_on');
                        }
                },

                adjustPaddingFunction: function(isIndent) {
                        var indentAmount, indentUnits, ed = this.ed;
                        indentAmount = ed.settings.indentation;
                        indentUnits = /[a-z%]+/i.exec(indentAmount);
                        indentAmount = parseInt(indentAmount, 10);
                        return function(element) {
                                var currentIndent, newIndentAmount;
                                currentIndent = parseInt(ed.dom.getStyle(element, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(element, 'padding-left') || 0, 10);
                                if (isIndent) {
                                        newIndentAmount = currentIndent + indentAmount;
                                } else {
                                        newIndentAmount = currentIndent - indentAmount;
                                }
                                ed.dom.setStyle(element, 'padding-left', '');
                                ed.dom.setStyle(element, 'margin-left', newIndentAmount > 0 ? newIndentAmount + indentUnits : '');
                        };
                },

                getInfo: function() {
                        return {
                                longname : 'Lists',
                                author : 'Moxiecode Systems AB',
                                authorurl : 'http://tinymce.moxiecode.com',
                                infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/lists',
                                version : tinymce.majorVersion + "." + tinymce.minorVersion
                        };
                }
        });
        tinymce.PluginManager.add("lists", tinymce.plugins.Lists);
}());