library/tinymce/jscripts/tiny_mce/plugins/lists/editor_plugin_src.js

   1 /**\r
   2  * editor_plugin_src.js\r
   3  *\r
   4  * Copyright 2011, Moxiecode Systems AB\r
   5  * Released under LGPL License.\r
   6  *\r
   7  * License: http://tinymce.moxiecode.com/license\r
   8  * Contributing: http://tinymce.moxiecode.com/contributing\r
   9  */\r
  10 \r
  11 (function() {\r
  12         var each = tinymce.each, Event = tinymce.dom.Event, bookmark;\r
  13 \r
  14         // Skips text nodes that only contain whitespace since they aren't semantically important.\r
  15         function skipWhitespaceNodes(e, next) {\r
  16                 while (e && (e.nodeType === 8 || (e.nodeType === 3 && /^[ \t\n\r]*$/.test(e.nodeValue)))) {\r
  17                         e = next(e);\r
  18                 }\r
  19                 return e;\r
  20         }\r
  21 \r
  22         function skipWhitespaceNodesBackwards(e) {\r
  23                 return skipWhitespaceNodes(e, function(e) {\r
  24                         return e.previousSibling;\r
  25                 });\r
  26         }\r
  27 \r
  28         function skipWhitespaceNodesForwards(e) {\r
  29                 return skipWhitespaceNodes(e, function(e) {\r
  30                         return e.nextSibling;\r
  31                 });\r
  32         }\r
  33 \r
  34         function hasParentInList(ed, e, list) {\r
  35                 return ed.dom.getParent(e, function(p) {\r
  36                         return tinymce.inArray(list, p) !== -1;\r
  37                 });\r
  38         }\r
  39 \r
  40         function isList(e) {\r
  41                 return e && (e.tagName === 'OL' || e.tagName === 'UL');\r
  42         }\r
  43 \r
  44         function splitNestedLists(element, dom) {\r
  45                 var tmp, nested, wrapItem;\r
  46                 tmp = skipWhitespaceNodesBackwards(element.lastChild);\r
  47                 while (isList(tmp)) {\r
  48                         nested = tmp;\r
  49                         tmp = skipWhitespaceNodesBackwards(nested.previousSibling);\r
  50                 }\r
  51                 if (nested) {\r
  52                         wrapItem = dom.create('li', { style: 'list-style-type: none;'});\r
  53                         dom.split(element, nested);\r
  54                         dom.insertAfter(wrapItem, nested);\r
  55                         wrapItem.appendChild(nested);\r
  56                         wrapItem.appendChild(nested);\r
  57                         element = wrapItem.previousSibling;\r
  58                 }\r
  59                 return element;\r
  60         }\r
  61 \r
  62         function attemptMergeWithAdjacent(e, allowDifferentListStyles, mergeParagraphs) {\r
  63                 e = attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs);\r
  64                 return attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs);\r
  65         }\r
  66 \r
  67         function attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs) {\r
  68                 var prev = skipWhitespaceNodesBackwards(e.previousSibling);\r
  69                 if (prev) {\r
  70                         return attemptMerge(prev, e, allowDifferentListStyles ? prev : false, mergeParagraphs);\r
  71                 } else {\r
  72                         return e;\r
  73                 }\r
  74         }\r
  75 \r
  76         function attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs) {\r
  77                 var next = skipWhitespaceNodesForwards(e.nextSibling);\r
  78                 if (next) {\r
  79                         return attemptMerge(e, next, allowDifferentListStyles ? next : false, mergeParagraphs);\r
  80                 } else {\r
  81                         return e;\r
  82                 }\r
  83         }\r
  84 \r
  85         function attemptMerge(e1, e2, differentStylesMasterElement, mergeParagraphs) {\r
  86                 if (canMerge(e1, e2, !!differentStylesMasterElement, mergeParagraphs)) {\r
  87                         return merge(e1, e2, differentStylesMasterElement);\r
  88                 } else if (e1 && e1.tagName === 'LI' && isList(e2)) {\r
  89                         // Fix invalidly nested lists.\r
  90                         e1.appendChild(e2);\r
  91                 }\r
  92                 return e2;\r
  93         }\r
  94 \r
  95         function canMerge(e1, e2, allowDifferentListStyles, mergeParagraphs) {\r
  96                 if (!e1 || !e2) {\r
  97                         return false;\r
  98                 } else if (e1.tagName === 'LI' && e2.tagName === 'LI') {\r
  99                         return e2.style.listStyleType === 'none' || containsOnlyAList(e2);\r
 100                 } else if (isList(e1)) {\r
 101                         return (e1.tagName === e2.tagName && (allowDifferentListStyles || e1.style.listStyleType === e2.style.listStyleType)) || isListForIndent(e2);\r
 102                 } else return mergeParagraphs && e1.tagName === 'P' && e2.tagName === 'P';\r
 103         }\r
 104 \r
 105         function isListForIndent(e) {\r
 106                 var firstLI = skipWhitespaceNodesForwards(e.firstChild), lastLI = skipWhitespaceNodesBackwards(e.lastChild);\r
 107                 return firstLI && lastLI && isList(e) && firstLI === lastLI && (isList(firstLI) || firstLI.style.listStyleType === 'none' || containsOnlyAList(firstLI));\r
 108         }\r
 109 \r
 110         function containsOnlyAList(e) {\r
 111                 var firstChild = skipWhitespaceNodesForwards(e.firstChild), lastChild = skipWhitespaceNodesBackwards(e.lastChild);\r
 112                 return firstChild && lastChild && firstChild === lastChild && isList(firstChild);\r
 113         }\r
 114 \r
 115         function merge(e1, e2, masterElement) {\r
 116                 var lastOriginal = skipWhitespaceNodesBackwards(e1.lastChild), firstNew = skipWhitespaceNodesForwards(e2.firstChild);\r
 117                 if (e1.tagName === 'P') {\r
 118                         e1.appendChild(e1.ownerDocument.createElement('br'));\r
 119                 }\r
 120                 while (e2.firstChild) {\r
 121                         e1.appendChild(e2.firstChild);\r
 122                 }\r
 123                 if (masterElement) {\r
 124                         e1.style.listStyleType = masterElement.style.listStyleType;\r
 125                 }\r
 126                 e2.parentNode.removeChild(e2);\r
 127                 attemptMerge(lastOriginal, firstNew, false);\r
 128                 return e1;\r
 129         }\r
 130 \r
 131         function findItemToOperateOn(e, dom) {\r
 132                 var item;\r
 133                 if (!dom.is(e, 'li,ol,ul')) {\r
 134                         item = dom.getParent(e, 'li');\r
 135                         if (item) {\r
 136                                 e = item;\r
 137                         }\r
 138                 }\r
 139                 return e;\r
 140         }\r
 141 \r
 142         tinymce.create('tinymce.plugins.Lists', {\r
 143                 init: function(ed) {\r
 144                         var LIST_TABBING = 'TABBING';\r
 145                         var LIST_EMPTY_ITEM = 'EMPTY';\r
 146                         var LIST_ESCAPE = 'ESCAPE';\r
 147                         var LIST_PARAGRAPH = 'PARAGRAPH';\r
 148                         var LIST_UNKNOWN = 'UNKNOWN';\r
 149                         var state = LIST_UNKNOWN;\r
 150 \r
 151                         function isTabInList(e) {\r
 152                                 // Don't indent on Ctrl+Tab or Alt+Tab\r
 153                                 return e.keyCode === tinymce.VK.TAB && !(e.altKey || e.ctrlKey) &&\r
 154                                         (ed.queryCommandState('InsertUnorderedList') || ed.queryCommandState('InsertOrderedList'));\r
 155                         }\r
 156 \r
 157                         function isOnLastListItem() {\r
 158                                 var li = getLi();\r
 159                                 var grandParent = li.parentNode.parentNode;\r
 160                                 var isLastItem = li.parentNode.lastChild === li;\r
 161                                 return isLastItem && !isNestedList(grandParent) && isEmptyListItem(li);\r
 162                         }\r
 163 \r
 164                         function isNestedList(grandParent) {\r
 165                                 if (isList(grandParent)) {\r
 166                                         return grandParent.parentNode && grandParent.parentNode.tagName === 'LI';\r
 167                                 } else {\r
 168                                         return  grandParent.tagName === 'LI';\r
 169                                 }\r
 170                         }\r
 171 \r
 172                         function isInEmptyListItem() {\r
 173                                 return ed.selection.isCollapsed() && isEmptyListItem(getLi());\r
 174                         }\r
 175 \r
 176                         function getLi() {\r
 177                                 var n = ed.selection.getStart();\r
 178                                 // Get start will return BR if the LI only contains a BR or an empty element as we use these to fix caret position\r
 179                                 return ((n.tagName == 'BR' || n.tagName == '') && n.parentNode.tagName == 'LI') ? n.parentNode : n;\r
 180                         }\r
 181 \r
 182                         function isEmptyListItem(li) {\r
 183                                 var numChildren = li.childNodes.length;\r
 184                                 if (li.tagName === 'LI') {\r
 185                                         return numChildren == 0 ? true : numChildren == 1 && (li.firstChild.tagName == '' || li.firstChild.tagName == 'BR' || isEmptyIE9Li(li));\r
 186                                 }\r
 187                                 return false;\r
 188                         }\r
 189 \r
 190                         function isEmptyIE9Li(li) {\r
 191                                 // 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\r
 192                                 var lis = tinymce.grep(li.parentNode.childNodes, function(n) {return n.tagName == 'LI'});\r
 193                                 var isLastLi = li == lis[lis.length - 1];\r
 194                                 var child = li.firstChild;\r
 195                                 return tinymce.isIE9 && isLastLi && (child.nodeValue == String.fromCharCode(160) || child.nodeValue == String.fromCharCode(32));\r
 196                         }\r
 197 \r
 198                         function isEnter(e) {\r
 199                                 return e.keyCode === tinymce.VK.ENTER;\r
 200                         }\r
 201 \r
 202                         function isEnterWithoutShift(e) {\r
 203                                 return isEnter(e) && !e.shiftKey;\r
 204                         }\r
 205 \r
 206                         function getListKeyState(e) {\r
 207                                 if (isTabInList(e)) {\r
 208                                         return LIST_TABBING;\r
 209                                 } else if (isEnterWithoutShift(e) && isOnLastListItem()) {\r
 210                                         // Returns LIST_UNKNOWN since breaking out of lists is handled by the EnterKey.js logic now\r
 211                                         //return LIST_ESCAPE;\r
 212                                         return LIST_UNKNOWN;\r
 213                                 } else if (isEnterWithoutShift(e) && isInEmptyListItem()) {\r
 214                                         return LIST_EMPTY_ITEM;\r
 215                                 } else {\r
 216                                         return LIST_UNKNOWN;\r
 217                                 }\r
 218                         }\r
 219 \r
 220                         function cancelDefaultEvents(ed, e) {\r
 221                                 // list escape is done manually using outdent as it does not create paragraphs correctly in td's\r
 222                                 if (state == LIST_TABBING || state == LIST_EMPTY_ITEM || tinymce.isGecko && state == LIST_ESCAPE) {\r
 223                                         Event.cancel(e);\r
 224                                 }\r
 225                         }\r
 226 \r
 227                         function isCursorAtEndOfContainer() {\r
 228                                 var range = ed.selection.getRng(true);\r
 229                                 var startContainer = range.startContainer;\r
 230                                 if (startContainer.nodeType == 3) {\r
 231                                         var value = startContainer.nodeValue;\r
 232                                         if (tinymce.isIE9 && value.length > 1 && value.charCodeAt(value.length-1) == 32) {\r
 233                                                 // IE9 places a space on the end of the text in some cases so ignore last char\r
 234                                                 return (range.endOffset == value.length-1);\r
 235                                         } else {\r
 236                                                 return (range.endOffset == value.length);\r
 237                                         }\r
 238                                 } else if (startContainer.nodeType == 1) {\r
 239                                         return range.endOffset == startContainer.childNodes.length;\r
 240                                 }\r
 241                                 return false;\r
 242                         }\r
 243 \r
 244                         /*\r
 245                                 If we are at the end of a list item surrounded with an element, pressing enter should create a\r
 246                                 new list item instead without splitting the element e.g. don't want to create new P or H1 tag\r
 247                           */\r
 248                         function isEndOfListItem() {\r
 249                                 var node = ed.selection.getNode();\r
 250                                 var validElements = 'h1,h2,h3,h4,h5,h6,p,div';\r
 251                                 var isLastParagraphOfLi = ed.dom.is(node, validElements) && node.parentNode.tagName === 'LI' && node.parentNode.lastChild === node;\r
 252                                 return ed.selection.isCollapsed() && isLastParagraphOfLi && isCursorAtEndOfContainer();\r
 253                         }\r
 254 \r
 255                         // Creates a new list item after the current selection's list item parent\r
 256                         function createNewLi(ed, e) {\r
 257                                 if (isEnterWithoutShift(e) && isEndOfListItem()) {\r
 258                                         var node = ed.selection.getNode();\r
 259                                         var li = ed.dom.create("li");\r
 260                                         var parentLi = ed.dom.getParent(node, 'li');\r
 261                                         ed.dom.insertAfter(li, parentLi);\r
 262 \r
 263                                         // Move caret to new list element.\r
 264                                         if (tinymce.isIE6 || tinymce.isIE7 || tinyMCE.isIE8) {\r
 265                                                 // Removed this line since it would create an odd <&nbsp;> tag and placing the caret inside an empty LI is handled and should be handled by the selection logic\r
 266                                                 //li.appendChild(ed.dom.create("&nbsp;")); // IE needs an element within the bullet point\r
 267                                                 ed.selection.setCursorLocation(li, 1);\r
 268                                         } else {\r
 269                                                 ed.selection.setCursorLocation(li, 0);\r
 270                                         }\r
 271                                         e.preventDefault();\r
 272                                 }\r
 273                         }\r
 274 \r
 275                         function imageJoiningListItem(ed, e) {\r
 276                                 var prevSibling;\r
 277 \r
 278                                 if (!tinymce.isGecko)\r
 279                                         return;\r
 280 \r
 281                                 var n = ed.selection.getStart();\r
 282                                 if (e.keyCode != tinymce.VK.BACKSPACE || n.tagName !== 'IMG')\r
 283                                         return;\r
 284 \r
 285                                 function lastLI(node) {\r
 286                                         var child = node.firstChild;\r
 287                                         var li = null;\r
 288                                         do {\r
 289                                                 if (!child)\r
 290                                                         break;\r
 291 \r
 292                                                 if (child.tagName === 'LI')\r
 293                                                         li = child;\r
 294                                         } while (child = child.nextSibling);\r
 295 \r
 296                                         return li;\r
 297                                 }\r
 298 \r
 299                                 function addChildren(parentNode, destination) {\r
 300                                         while (parentNode.childNodes.length > 0)\r
 301                                                 destination.appendChild(parentNode.childNodes[0]);\r
 302                                 }\r
 303 \r
 304                                 // Check if there is a previous sibling\r
 305                                 prevSibling = n.parentNode.previousSibling;\r
 306                                 if (!prevSibling)\r
 307                                         return;\r
 308 \r
 309                                 var ul;\r
 310                                 if (prevSibling.tagName === 'UL' || prevSibling.tagName === 'OL')\r
 311                                         ul = prevSibling;\r
 312                                 else if (prevSibling.previousSibling && (prevSibling.previousSibling.tagName === 'UL' || prevSibling.previousSibling.tagName === 'OL'))\r
 313                                         ul = prevSibling.previousSibling;\r
 314                                 else\r
 315                                         return;\r
 316 \r
 317                                 var li = lastLI(ul);\r
 318 \r
 319                                 // move the caret to the end of the list item\r
 320                                 var rng = ed.dom.createRng();\r
 321                                 rng.setStart(li, 1);\r
 322                                 rng.setEnd(li, 1);\r
 323                                 ed.selection.setRng(rng);\r
 324                                 ed.selection.collapse(true);\r
 325 \r
 326                                 // save a bookmark at the end of the list item\r
 327                                 var bookmark = ed.selection.getBookmark();\r
 328 \r
 329                                 // copy the image an its text to the list item\r
 330                                 var clone = n.parentNode.cloneNode(true);\r
 331                                 if (clone.tagName === 'P' || clone.tagName === 'DIV')\r
 332                                         addChildren(clone, li);\r
 333                                 else\r
 334                                         li.appendChild(clone);\r
 335 \r
 336                                 // remove the old copy of the image\r
 337                                 n.parentNode.parentNode.removeChild(n.parentNode);\r
 338 \r
 339                                 // move the caret where we saved the bookmark\r
 340                                 ed.selection.moveToBookmark(bookmark);\r
 341                         }\r
 342 \r
 343                         // fix the cursor position to ensure it is correct in IE\r
 344                         function setCursorPositionToOriginalLi(li) {\r
 345                                 var list = ed.dom.getParent(li, 'ol,ul');\r
 346                                 if (list != null) {\r
 347                                         var lastLi = list.lastChild;\r
 348                                         // Removed this line since IE9 would report an DOM character error and placing the caret inside an empty LI is handled and should be handled by the selection logic\r
 349                                         //lastLi.appendChild(ed.getDoc().createElement(''));\r
 350                                         ed.selection.setCursorLocation(lastLi, 0);\r
 351                                 }\r
 352                         }\r
 353 \r
 354                         this.ed = ed;\r
 355                         ed.addCommand('Indent', this.indent, this);\r
 356                         ed.addCommand('Outdent', this.outdent, this);\r
 357                         ed.addCommand('InsertUnorderedList', function() {\r
 358                                 this.applyList('UL', 'OL');\r
 359                         }, this);\r
 360                         ed.addCommand('InsertOrderedList', function() {\r
 361                                 this.applyList('OL', 'UL');\r
 362                         }, this);\r
 363 \r
 364                         ed.onInit.add(function() {\r
 365                                 ed.editorCommands.addCommands({\r
 366                                         'outdent': function() {\r
 367                                                 var sel = ed.selection, dom = ed.dom;\r
 368 \r
 369                                                 function hasStyleIndent(n) {\r
 370                                                         n = dom.getParent(n, dom.isBlock);\r
 371                                                         return n && (parseInt(ed.dom.getStyle(n, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(n, 'padding-left') || 0, 10)) > 0;\r
 372                                                 }\r
 373 \r
 374                                                 return hasStyleIndent(sel.getStart()) || hasStyleIndent(sel.getEnd()) || ed.queryCommandState('InsertOrderedList') || ed.queryCommandState('InsertUnorderedList');\r
 375                                         }\r
 376                                 }, 'state');\r
 377                         });\r
 378 \r
 379                         ed.onKeyUp.add(function(ed, e) {\r
 380                                 if (state == LIST_TABBING) {\r
 381                                         ed.execCommand(e.shiftKey ? 'Outdent' : 'Indent', true, null);\r
 382                                         state = LIST_UNKNOWN;\r
 383                                         return Event.cancel(e);\r
 384                                 } else if (state == LIST_EMPTY_ITEM) {\r
 385                                         var li = getLi();\r
 386                                         var shouldOutdent =  ed.settings.list_outdent_on_enter === true || e.shiftKey;\r
 387                                         ed.execCommand(shouldOutdent ? 'Outdent' : 'Indent', true, null);\r
 388                                         if (tinymce.isIE) {\r
 389                                                 setCursorPositionToOriginalLi(li);\r
 390                                         }\r
 391 \r
 392                                         return Event.cancel(e);\r
 393                                 } else if (state == LIST_ESCAPE) {\r
 394                                         if (tinymce.isIE6 || tinymce.isIE7 || tinymce.isIE8) {\r
 395                                                 // append a zero sized nbsp so that caret is positioned correctly in IE after escaping and applying formatting.\r
 396                                                 // if there is no text then applying formatting for e.g a H1 to the P tag immediately following list after\r
 397                                                 // escaping from it will cause the caret to be positioned on the last li instead of staying the in P tag.\r
 398                                                 var n = ed.getDoc().createTextNode('\uFEFF');\r
 399                                                 ed.selection.getNode().appendChild(n);\r
 400                                         } else if (tinymce.isIE9 || tinymce.isGecko) {\r
 401                                                 // IE9 does not escape the list so we use outdent to do this and cancel the default behaviour\r
 402                                                 // Gecko does not create a paragraph outdenting inside a TD so default behaviour is cancelled and we outdent ourselves\r
 403                                                 ed.execCommand('Outdent');\r
 404                                                 return Event.cancel(e);\r
 405                                         }\r
 406                                 }\r
 407                         });\r
 408 \r
 409                         function fixListItem(parent, reference) {\r
 410                                 // a zero-sized non-breaking space is placed in the empty list item so that the nested list is\r
 411                                 // displayed on the below line instead of next to it\r
 412                                 var n = ed.getDoc().createTextNode('\uFEFF');\r
 413                                 parent.insertBefore(n, reference);\r
 414                                 ed.selection.setCursorLocation(n, 0);\r
 415                                 // repaint to remove rendering artifact. only visible when creating new list\r
 416                                 ed.execCommand('mceRepaint');\r
 417                         }\r
 418 \r
 419                         function fixIndentedListItemForGecko(ed, e) {\r
 420                                 if (isEnter(e)) {\r
 421                                         var li = getLi();\r
 422                                         if (li) {\r
 423                                                 var parent = li.parentNode;\r
 424                                                 var grandParent = parent && parent.parentNode;\r
 425                                                 if (grandParent && grandParent.nodeName == 'LI' && grandParent.firstChild == parent && li == parent.firstChild) {\r
 426                                                         fixListItem(grandParent, parent);\r
 427                                                 }\r
 428                                         }\r
 429                                 }\r
 430                         }\r
 431 \r
 432                         function fixIndentedListItemForIE8(ed, e) {\r
 433                                 if (isEnter(e)) {\r
 434                                         var li = getLi();\r
 435                                         if (ed.dom.select('ul li', li).length === 1) {\r
 436                                                 var list = li.firstChild;\r
 437                                                 fixListItem(li, list);\r
 438                                         }\r
 439                                 }\r
 440                         }\r
 441 \r
 442                         function fixDeletingFirstCharOfList(ed, e) {\r
 443                                 function listElements(list, li) {\r
 444                                         var elements = [];\r
 445                                         var walker = new tinymce.dom.TreeWalker(li, list);\r
 446                                         for (var node = walker.current(); node; node = walker.next()) {\r
 447                                                 if (ed.dom.is(node, 'ol,ul,li')) {\r
 448                                                         elements.push(node);\r
 449                                                 }\r
 450                                         }\r
 451                                         return elements;\r
 452                                 }\r
 453 \r
 454                                 if (e.keyCode == tinymce.VK.BACKSPACE) {\r
 455                                         var li = getLi();\r
 456                                         if (li) {\r
 457                                                 var list = ed.dom.getParent(li, 'ol,ul');\r
 458                                                 if (list && list.firstChild === li) {\r
 459                                                         var elements = listElements(list, li);\r
 460                                                         ed.execCommand("Outdent", false, elements);\r
 461                                                         ed.undoManager.add();\r
 462                                                         return Event.cancel(e);\r
 463                                                 }\r
 464                                         }\r
 465                                 }\r
 466                         }\r
 467 \r
 468                         function fixDeletingEmptyLiInWebkit(ed, e) {\r
 469                                 var li = getLi();\r
 470                                 if (e.keyCode === tinymce.VK.BACKSPACE && ed.dom.is(li, 'li') && li.parentNode.firstChild!==li) {\r
 471                                         if (ed.dom.select('ul,ol', li).length === 1) {\r
 472                                                 var prevLi = li.previousSibling;\r
 473                                                 ed.dom.remove(ed.dom.select('br', li));\r
 474                                                 ed.dom.remove(li, true);\r
 475                                                 var textNodes = tinymce.grep(prevLi.childNodes, function(n){ return n.nodeType === 3 });\r
 476                                                 if (textNodes.length === 1) {\r
 477                                                         var textNode = textNodes[0]\r
 478                                                         ed.selection.setCursorLocation(textNode, textNode.length);\r
 479                                                 }\r
 480                                                 ed.undoManager.add();\r
 481                                                 return Event.cancel(e);\r
 482                                         }\r
 483                                 }\r
 484                         }\r
 485 \r
 486                         ed.onKeyDown.add(function(_, e) { state = getListKeyState(e); });\r
 487                         ed.onKeyDown.add(cancelDefaultEvents);\r
 488                         ed.onKeyDown.add(imageJoiningListItem);\r
 489                         ed.onKeyDown.add(createNewLi);\r
 490 \r
 491                         if (tinymce.isGecko) {\r
 492                                 ed.onKeyUp.add(fixIndentedListItemForGecko);\r
 493                         }\r
 494                         if (tinymce.isIE8) {\r
 495                                 ed.onKeyUp.add(fixIndentedListItemForIE8);\r
 496                         }\r
 497                         if (tinymce.isGecko || tinymce.isWebKit) {\r
 498                                 ed.onKeyDown.add(fixDeletingFirstCharOfList);\r
 499                         }\r
 500                         if (tinymce.isWebKit) {\r
 501                                 ed.onKeyDown.add(fixDeletingEmptyLiInWebkit);\r
 502                         }\r
 503                 },\r
 504 \r
 505                 applyList: function(targetListType, oppositeListType) {\r
 506                         var t = this, ed = t.ed, dom = ed.dom, applied = [], hasSameType = false, hasOppositeType = false, hasNonList = false, actions,\r
 507                                         selectedBlocks = ed.selection.getSelectedBlocks();\r
 508 \r
 509                         function cleanupBr(e) {\r
 510                                 if (e && e.tagName === 'BR') {\r
 511                                         dom.remove(e);\r
 512                                 }\r
 513                         }\r
 514 \r
 515                         function makeList(element) {\r
 516                                 var list = dom.create(targetListType), li;\r
 517 \r
 518                                 function adjustIndentForNewList(element) {\r
 519                                         // If there's a margin-left, outdent one level to account for the extra list margin.\r
 520                                         if (element.style.marginLeft || element.style.paddingLeft) {\r
 521                                                 t.adjustPaddingFunction(false)(element);\r
 522                                         }\r
 523                                 }\r
 524 \r
 525                                 if (element.tagName === 'LI') {\r
 526                                         // No change required.\r
 527                                 } else if (element.tagName === 'P' || element.tagName === 'DIV' || element.tagName === 'BODY') {\r
 528                                         processBrs(element, function(startSection, br) {\r
 529                                                 doWrapList(startSection, br, element.tagName === 'BODY' ? null : startSection.parentNode);\r
 530                                                 li = startSection.parentNode;\r
 531                                                 adjustIndentForNewList(li);\r
 532                                                 cleanupBr(br);\r
 533                                         });\r
 534                                         if (li) {\r
 535                                                 if (li.tagName === 'LI' && (element.tagName === 'P' || selectedBlocks.length > 1)) {\r
 536                                                         dom.split(li.parentNode.parentNode, li.parentNode);\r
 537                                                 }\r
 538                                                 attemptMergeWithAdjacent(li.parentNode, true);\r
 539                                         }\r
 540                                         return;\r
 541                                 } else {\r
 542                                         // Put the list around the element.\r
 543                                         li = dom.create('li');\r
 544                                         dom.insertAfter(li, element);\r
 545                                         li.appendChild(element);\r
 546                                         adjustIndentForNewList(element);\r
 547                                         element = li;\r
 548                                 }\r
 549                                 dom.insertAfter(list, element);\r
 550                                 list.appendChild(element);\r
 551                                 attemptMergeWithAdjacent(list, true);\r
 552                                 applied.push(element);\r
 553                         }\r
 554 \r
 555                         function doWrapList(start, end, template) {\r
 556                                 var li, n = start, tmp;\r
 557                                 while (!dom.isBlock(start.parentNode) && start.parentNode !== dom.getRoot()) {\r
 558                                         start = dom.split(start.parentNode, start.previousSibling);\r
 559                                         start = start.nextSibling;\r
 560                                         n = start;\r
 561                                 }\r
 562                                 if (template) {\r
 563                                         li = template.cloneNode(true);\r
 564                                         start.parentNode.insertBefore(li, start);\r
 565                                         while (li.firstChild) dom.remove(li.firstChild);\r
 566                                         li = dom.rename(li, 'li');\r
 567                                 } else {\r
 568                                         li = dom.create('li');\r
 569                                         start.parentNode.insertBefore(li, start);\r
 570                                 }\r
 571                                 while (n && n != end) {\r
 572                                         tmp = n.nextSibling;\r
 573                                         li.appendChild(n);\r
 574                                         n = tmp;\r
 575                                 }\r
 576                                 if (li.childNodes.length === 0) {\r
 577                                         li.innerHTML = '<br _mce_bogus="1" />';\r
 578                                 }\r
 579                                 makeList(li);\r
 580                         }\r
 581 \r
 582                         function processBrs(element, callback) {\r
 583                                 var startSection, previousBR, END_TO_START = 3, START_TO_END = 1,\r
 584                                                 breakElements = 'br,ul,ol,p,div,h1,h2,h3,h4,h5,h6,table,blockquote,address,pre,form,center,dl';\r
 585 \r
 586                                 function isAnyPartSelected(start, end) {\r
 587                                         var r = dom.createRng(), sel;\r
 588                                         bookmark.keep = true;\r
 589                                         ed.selection.moveToBookmark(bookmark);\r
 590                                         bookmark.keep = false;\r
 591                                         sel = ed.selection.getRng(true);\r
 592                                         if (!end) {\r
 593                                                 end = start.parentNode.lastChild;\r
 594                                         }\r
 595                                         r.setStartBefore(start);\r
 596                                         r.setEndAfter(end);\r
 597                                         return !(r.compareBoundaryPoints(END_TO_START, sel) > 0 || r.compareBoundaryPoints(START_TO_END, sel) <= 0);\r
 598                                 }\r
 599 \r
 600                                 function nextLeaf(br) {\r
 601                                         if (br.nextSibling)\r
 602                                                 return br.nextSibling;\r
 603                                         if (!dom.isBlock(br.parentNode) && br.parentNode !== dom.getRoot())\r
 604                                                 return nextLeaf(br.parentNode);\r
 605                                 }\r
 606 \r
 607                                 // Split on BRs within the range and process those.\r
 608                                 startSection = element.firstChild;\r
 609                                 // First mark the BRs that have any part of the previous section selected.\r
 610                                 var trailingContentSelected = false;\r
 611                                 each(dom.select(breakElements, element), function(br) {\r
 612                                         if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {\r
 613                                                 return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.\r
 614                                         }\r
 615                                         if (isAnyPartSelected(startSection, br)) {\r
 616                                                 dom.addClass(br, '_mce_tagged_br');\r
 617                                                 startSection = nextLeaf(br);\r
 618                                         }\r
 619                                 });\r
 620                                 trailingContentSelected = (startSection && isAnyPartSelected(startSection, undefined));\r
 621                                 startSection = element.firstChild;\r
 622                                 each(dom.select(breakElements, element), function(br) {\r
 623                                         // Got a section from start to br.\r
 624                                         var tmp = nextLeaf(br);\r
 625                                         if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {\r
 626                                                 return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.\r
 627                                         }\r
 628                                         if (dom.hasClass(br, '_mce_tagged_br')) {\r
 629                                                 callback(startSection, br, previousBR);\r
 630                                                 previousBR = null;\r
 631                                         } else {\r
 632                                                 previousBR = br;\r
 633                                         }\r
 634                                         startSection = tmp;\r
 635                                 });\r
 636                                 if (trailingContentSelected) {\r
 637                                         callback(startSection, undefined, previousBR);\r
 638                                 }\r
 639                         }\r
 640 \r
 641                         function wrapList(element) {\r
 642                                 processBrs(element, function(startSection, br, previousBR) {\r
 643                                         // Need to indent this part\r
 644                                         doWrapList(startSection, br);\r
 645                                         cleanupBr(br);\r
 646                                         cleanupBr(previousBR);\r
 647                                 });\r
 648                         }\r
 649 \r
 650                         function changeList(element) {\r
 651                                 if (tinymce.inArray(applied, element) !== -1) {\r
 652                                         return;\r
 653                                 }\r
 654                                 if (element.parentNode.tagName === oppositeListType) {\r
 655                                         dom.split(element.parentNode, element);\r
 656                                         makeList(element);\r
 657                                         attemptMergeWithNext(element.parentNode, false);\r
 658                                 }\r
 659                                 applied.push(element);\r
 660                         }\r
 661 \r
 662                         function convertListItemToParagraph(element) {\r
 663                                 var child, nextChild, mergedElement, splitLast;\r
 664                                 if (tinymce.inArray(applied, element) !== -1) {\r
 665                                         return;\r
 666                                 }\r
 667                                 element = splitNestedLists(element, dom);\r
 668                                 while (dom.is(element.parentNode, 'ol,ul,li')) {\r
 669                                         dom.split(element.parentNode, element);\r
 670                                 }\r
 671                                 // Push the original element we have from the selection, not the renamed one.\r
 672                                 applied.push(element);\r
 673                                 element = dom.rename(element, 'p');\r
 674                                 mergedElement = attemptMergeWithAdjacent(element, false, ed.settings.force_br_newlines);\r
 675                                 if (mergedElement === element) {\r
 676                                         // Now split out any block elements that can't be contained within a P.\r
 677                                         // Manually iterate to ensure we handle modifications correctly (doesn't work with tinymce.each)\r
 678                                         child = element.firstChild;\r
 679                                         while (child) {\r
 680                                                 if (dom.isBlock(child)) {\r
 681                                                         child = dom.split(child.parentNode, child);\r
 682                                                         splitLast = true;\r
 683                                                         nextChild = child.nextSibling && child.nextSibling.firstChild;\r
 684                                                 } else {\r
 685                                                         nextChild = child.nextSibling;\r
 686                                                         if (splitLast && child.tagName === 'BR') {\r
 687                                                                 dom.remove(child);\r
 688                                                         }\r
 689                                                         splitLast = false;\r
 690                                                 }\r
 691                                                 child = nextChild;\r
 692                                         }\r
 693                                 }\r
 694                         }\r
 695 \r
 696                         each(selectedBlocks, function(e) {\r
 697                                 e = findItemToOperateOn(e, dom);\r
 698                                 if (e.tagName === oppositeListType || (e.tagName === 'LI' && e.parentNode.tagName === oppositeListType)) {\r
 699                                         hasOppositeType = true;\r
 700                                 } else if (e.tagName === targetListType || (e.tagName === 'LI' && e.parentNode.tagName === targetListType)) {\r
 701                                         hasSameType = true;\r
 702                                 } else {\r
 703                                         hasNonList = true;\r
 704                                 }\r
 705                         });\r
 706 \r
 707                         if (hasNonList &&!hasSameType || hasOppositeType || selectedBlocks.length === 0) {\r
 708                                 actions = {\r
 709                                         'LI': changeList,\r
 710                                         'H1': makeList,\r
 711                                         'H2': makeList,\r
 712                                         'H3': makeList,\r
 713                                         'H4': makeList,\r
 714                                         'H5': makeList,\r
 715                                         'H6': makeList,\r
 716                                         'P': makeList,\r
 717                                         'BODY': makeList,\r
 718                                         'DIV': selectedBlocks.length > 1 ? makeList : wrapList,\r
 719                                         defaultAction: wrapList,\r
 720                                         elements: this.selectedBlocks()\r
 721                                 };\r
 722                         } else {\r
 723                                 actions = {\r
 724                                         defaultAction: convertListItemToParagraph,\r
 725                                         elements: this.selectedBlocks()\r
 726                                 };\r
 727                         }\r
 728                         this.process(actions);\r
 729                 },\r
 730 \r
 731                 indent: function() {\r
 732                         var ed = this.ed, dom = ed.dom, indented = [];\r
 733 \r
 734                         function createWrapItem(element) {\r
 735                                 var wrapItem = dom.create('li', { style: 'list-style-type: none;'});\r
 736                                 dom.insertAfter(wrapItem, element);\r
 737                                 return wrapItem;\r
 738                         }\r
 739 \r
 740                         function createWrapList(element) {\r
 741                                 var wrapItem = createWrapItem(element),\r
 742                                                 list = dom.getParent(element, 'ol,ul'),\r
 743                                                 listType = list.tagName,\r
 744                                                 listStyle = dom.getStyle(list, 'list-style-type'),\r
 745                                                 attrs = {},\r
 746                                                 wrapList;\r
 747                                 if (listStyle !== '') {\r
 748                                         attrs.style = 'list-style-type: ' + listStyle + ';';\r
 749                                 }\r
 750                                 wrapList = dom.create(listType, attrs);\r
 751                                 wrapItem.appendChild(wrapList);\r
 752                                 return wrapList;\r
 753                         }\r
 754 \r
 755                         function indentLI(element) {\r
 756                                 if (!hasParentInList(ed, element, indented)) {\r
 757                                         element = splitNestedLists(element, dom);\r
 758                                         var wrapList = createWrapList(element);\r
 759                                         wrapList.appendChild(element);\r
 760                                         attemptMergeWithAdjacent(wrapList.parentNode, false);\r
 761                                         attemptMergeWithAdjacent(wrapList, false);\r
 762                                         indented.push(element);\r
 763                                 }\r
 764                         }\r
 765 \r
 766                         this.process({\r
 767                                 'LI': indentLI,\r
 768                                 defaultAction: this.adjustPaddingFunction(true),\r
 769                                 elements: this.selectedBlocks()\r
 770                         });\r
 771 \r
 772                 },\r
 773 \r
 774                 outdent: function(ui, elements) {\r
 775                         var t = this, ed = t.ed, dom = ed.dom, outdented = [];\r
 776 \r
 777                         function outdentLI(element) {\r
 778                                 var listElement, targetParent, align;\r
 779                                 if (!hasParentInList(ed, element, outdented)) {\r
 780                                         if (dom.getStyle(element, 'margin-left') !== '' || dom.getStyle(element, 'padding-left') !== '') {\r
 781                                                 return t.adjustPaddingFunction(false)(element);\r
 782                                         }\r
 783                                         align = dom.getStyle(element, 'text-align', true);\r
 784                                         if (align === 'center' || align === 'right') {\r
 785                                                 dom.setStyle(element, 'text-align', 'left');\r
 786                                                 return;\r
 787                                         }\r
 788                                         element = splitNestedLists(element, dom);\r
 789                                         listElement = element.parentNode;\r
 790                                         targetParent = element.parentNode.parentNode;\r
 791                                         if (targetParent.tagName === 'P') {\r
 792                                                 dom.split(targetParent, element.parentNode);\r
 793                                         } else {\r
 794                                                 dom.split(listElement, element);\r
 795                                                 if (targetParent.tagName === 'LI') {\r
 796                                                         // Nested list, need to split the LI and go back out to the OL/UL element.\r
 797                                                         dom.split(targetParent, element);\r
 798                                                 } else if (!dom.is(targetParent, 'ol,ul')) {\r
 799                                                         dom.rename(element, 'p');\r
 800                                                 }\r
 801                                         }\r
 802                                         outdented.push(element);\r
 803                                 }\r
 804                         }\r
 805 \r
 806                         var listElements = elements && tinymce.is(elements, 'array') ? elements : this.selectedBlocks();\r
 807                         this.process({\r
 808                                 'LI': outdentLI,\r
 809                                 defaultAction: this.adjustPaddingFunction(false),\r
 810                                 elements: listElements\r
 811                         });\r
 812 \r
 813                         each(outdented, attemptMergeWithAdjacent);\r
 814                 },\r
 815 \r
 816                 process: function(actions) {\r
 817                         var t = this, sel = t.ed.selection, dom = t.ed.dom, selectedBlocks, r;\r
 818 \r
 819                         function isEmptyElement(element) {\r
 820                                 var excludeBrsAndBookmarks = tinymce.grep(element.childNodes, function(n) {\r
 821                                         return !(n.nodeName === 'BR' || n.nodeName === 'SPAN' && dom.getAttrib(n, 'data-mce-type') == 'bookmark'\r
 822                                                         || n.nodeType == 3 && (n.nodeValue == String.fromCharCode(160) || n.nodeValue == ''));\r
 823                                 });\r
 824                                 return excludeBrsAndBookmarks.length === 0;\r
 825                         }\r
 826 \r
 827                         function processElement(element) {\r
 828                                 dom.removeClass(element, '_mce_act_on');\r
 829                                 if (!element || element.nodeType !== 1 || selectedBlocks.length > 1 && isEmptyElement(element)) {\r
 830                                         return;\r
 831                                 }\r
 832                                 element = findItemToOperateOn(element, dom);\r
 833                                 var action = actions[element.tagName];\r
 834                                 if (!action) {\r
 835                                         action = actions.defaultAction;\r
 836                                 }\r
 837                                 action(element);\r
 838                         }\r
 839 \r
 840                         function recurse(element) {\r
 841                                 t.splitSafeEach(element.childNodes, processElement);\r
 842                         }\r
 843 \r
 844                         function brAtEdgeOfSelection(container, offset) {\r
 845                                 return offset >= 0 && container.hasChildNodes() && offset < container.childNodes.length &&\r
 846                                                 container.childNodes[offset].tagName === 'BR';\r
 847                         }\r
 848 \r
 849                         function isInTable() {\r
 850                                 var n = sel.getNode();\r
 851                                 var p = dom.getParent(n, 'td');\r
 852                                 return p !== null;\r
 853                         }\r
 854 \r
 855                         selectedBlocks = actions.elements;\r
 856 \r
 857                         r = sel.getRng(true);\r
 858                         if (!r.collapsed) {\r
 859                                 if (brAtEdgeOfSelection(r.endContainer, r.endOffset - 1)) {\r
 860                                         r.setEnd(r.endContainer, r.endOffset - 1);\r
 861                                         sel.setRng(r);\r
 862                                 }\r
 863                                 if (brAtEdgeOfSelection(r.startContainer, r.startOffset)) {\r
 864                                         r.setStart(r.startContainer, r.startOffset + 1);\r
 865                                         sel.setRng(r);\r
 866                                 }\r
 867                         }\r
 868 \r
 869 \r
 870                         if (tinymce.isIE8) {\r
 871                                 // append a zero sized nbsp so that caret is restored correctly using bookmark\r
 872                                 var s = t.ed.selection.getNode();\r
 873                                 if (s.tagName === 'LI' && !(s.parentNode.lastChild === s)) {\r
 874                                         var i = t.ed.getDoc().createTextNode('\uFEFF');\r
 875                                         s.appendChild(i);\r
 876                                 }\r
 877                         }\r
 878 \r
 879                         bookmark = sel.getBookmark();\r
 880                         actions.OL = actions.UL = recurse;\r
 881                         t.splitSafeEach(selectedBlocks, processElement);\r
 882                         sel.moveToBookmark(bookmark);\r
 883                         bookmark = null;\r
 884 \r
 885                         // we avoid doing repaint in a table as this will move the caret out of the table in Firefox 3.6\r
 886                         if (!isInTable()) {\r
 887                                 // Avoids table or image handles being left behind in Firefox.\r
 888                                 t.ed.execCommand('mceRepaint');\r
 889                         }\r
 890                 },\r
 891 \r
 892                 splitSafeEach: function(elements, f) {\r
 893                         if (tinymce.isGecko && (/Firefox\/[12]\.[0-9]/.test(navigator.userAgent) ||\r
 894                                         /Firefox\/3\.[0-4]/.test(navigator.userAgent))) {\r
 895                                 this.classBasedEach(elements, f);\r
 896                         } else {\r
 897                                 each(elements, f);\r
 898                         }\r
 899                 },\r
 900 \r
 901                 classBasedEach: function(elements, f) {\r
 902                         var dom = this.ed.dom, nodes, element;\r
 903                         // Mark nodes\r
 904                         each(elements, function(element) {\r
 905                                 dom.addClass(element, '_mce_act_on');\r
 906                         });\r
 907                         nodes = dom.select('._mce_act_on');\r
 908                         while (nodes.length > 0) {\r
 909                                 element = nodes.shift();\r
 910                                 dom.removeClass(element, '_mce_act_on');\r
 911                                 f(element);\r
 912                                 nodes = dom.select('._mce_act_on');\r
 913                         }\r
 914                 },\r
 915 \r
 916                 adjustPaddingFunction: function(isIndent) {\r
 917                         var indentAmount, indentUnits, ed = this.ed;\r
 918                         indentAmount = ed.settings.indentation;\r
 919                         indentUnits = /[a-z%]+/i.exec(indentAmount);\r
 920                         indentAmount = parseInt(indentAmount, 10);\r
 921                         return function(element) {\r
 922                                 var currentIndent, newIndentAmount;\r
 923                                 currentIndent = parseInt(ed.dom.getStyle(element, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(element, 'padding-left') || 0, 10);\r
 924                                 if (isIndent) {\r
 925                                         newIndentAmount = currentIndent + indentAmount;\r
 926                                 } else {\r
 927                                         newIndentAmount = currentIndent - indentAmount;\r
 928                                 }\r
 929                                 ed.dom.setStyle(element, 'padding-left', '');\r
 930                                 ed.dom.setStyle(element, 'margin-left', newIndentAmount > 0 ? newIndentAmount + indentUnits : '');\r
 931                         };\r
 932                 },\r
 933 \r
 934                 selectedBlocks: function() {\r
 935                         var ed = this.ed\r
 936                         var selectedBlocks = ed.selection.getSelectedBlocks();\r
 937                         return selectedBlocks.length == 0 ? [ ed.dom.getRoot() ] : selectedBlocks;\r
 938                 },\r
 939 \r
 940                 getInfo: function() {\r
 941                         return {\r
 942                                 longname : 'Lists',\r
 943                                 author : 'Moxiecode Systems AB',\r
 944                                 authorurl : 'http://tinymce.moxiecode.com',\r
 945                                 infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/lists',\r
 946                                 version : tinymce.majorVersion + "." + tinymce.minorVersion\r
 947                         };\r
 948                 }\r
 949         });\r
 950         tinymce.PluginManager.add("lists", tinymce.plugins.Lists);\r
 951 }());\r