wp-includes/js/tinymce/plugins/lists/plugin.js

   1 /**
   2  * plugin.js
   3  *
   4  * Copyright, Moxiecode Systems AB
   5  * Released under LGPL License.
   6  *
   7  * License: http://www.tinymce.com/license
   8  * Contributing: http://www.tinymce.com/contributing
   9  */
  10
  11 /*global tinymce:true */
  12 /*eslint consistent-this:0 */
  13
  14 tinymce.PluginManager.add('lists', function(editor) {
  15         var self = this;
  16
  17         function isListNode(node) {
  18                 return node && (/^(OL|UL|DL)$/).test(node.nodeName);
  19         }
  20
  21         function isFirstChild(node) {
  22                 return node.parentNode.firstChild == node;
  23         }
  24
  25         function isLastChild(node) {
  26                 return node.parentNode.lastChild == node;
  27         }
  28
  29         function isTextBlock(node) {
  30                 return node && !!editor.schema.getTextBlockElements()[node.nodeName];
  31         }
  32
  33         editor.on('init', function() {
  34                 var dom = editor.dom, selection = editor.selection;
  35
  36                 /**
  37                  * Returns a range bookmark. This will convert indexed bookmarks into temporary span elements with
  38                  * index 0 so that they can be restored properly after the DOM has been modified. Text bookmarks will not have spans
  39                  * added to them since they can be restored after a dom operation.
  40                  *
  41                  * So this: <p><b>|</b><b>|</b></p>
  42                  * becomes: <p><b><span data-mce-type="bookmark">|</span></b><b data-mce-type="bookmark">|</span></b></p>
  43                  *
  44                  * @param  {DOMRange} rng DOM Range to get bookmark on.
  45                  * @return {Object} Bookmark object.
  46                  */
  47                 function createBookmark(rng) {
  48                         var bookmark = {};
  49
  50                         function setupEndPoint(start) {
  51                                 var offsetNode, container, offset;
  52
  53                                 container = rng[start ? 'startContainer' : 'endContainer'];
  54                                 offset = rng[start ? 'startOffset' : 'endOffset'];
  55
  56                                 if (container.nodeType == 1) {
  57                                         offsetNode = dom.create('span', {'data-mce-type': 'bookmark'});
  58
  59                                         if (container.hasChildNodes()) {
  60                                                 offset = Math.min(offset, container.childNodes.length - 1);
  61
  62                                                 if (start) {
  63                                                         container.insertBefore(offsetNode, container.childNodes[offset]);
  64                                                 } else {
  65                                                         dom.insertAfter(offsetNode, container.childNodes[offset]);
  66                                                 }
  67                                         } else {
  68                                                 container.appendChild(offsetNode);
  69                                         }
  70
  71                                         container = offsetNode;
  72                                         offset = 0;
  73                                 }
  74
  75                                 bookmark[start ? 'startContainer' : 'endContainer'] = container;
  76                                 bookmark[start ? 'startOffset' : 'endOffset'] = offset;
  77                         }
  78
  79                         setupEndPoint(true);
  80
  81                         if (!rng.collapsed) {
  82                                 setupEndPoint();
  83                         }
  84
  85                         return bookmark;
  86                 }
  87
  88                 /**
  89                  * Moves the selection to the current bookmark and removes any selection container wrappers.
  90                  *
  91                  * @param {Object} bookmark Bookmark object to move selection to.
  92                  */
  93                 function moveToBookmark(bookmark) {
  94                         function restoreEndPoint(start) {
  95                                 var container, offset, node;
  96
  97                                 function nodeIndex(container) {
  98                                         var node = container.parentNode.firstChild, idx = 0;
  99
 100                                         while (node) {
 101                                                 if (node == container) {
 102                                                         return idx;
 103                                                 }
 104
 105                                                 // Skip data-mce-type=bookmark nodes
 106                                                 if (node.nodeType != 1 || node.getAttribute('data-mce-type') != 'bookmark') {
 107                                                         idx++;
 108                                                 }
 109
 110                                                 node = node.nextSibling;
 111                                         }
 112
 113                                         return -1;
 114                                 }
 115
 116                                 container = node = bookmark[start ? 'startContainer' : 'endContainer'];
 117                                 offset = bookmark[start ? 'startOffset' : 'endOffset'];
 118
 119                                 if (!container) {
 120                                         return;
 121                                 }
 122
 123                                 if (container.nodeType == 1) {
 124                                         offset = nodeIndex(container);
 125                                         container = container.parentNode;
 126                                         dom.remove(node);
 127                                 }
 128
 129                                 bookmark[start ? 'startContainer' : 'endContainer'] = container;
 130                                 bookmark[start ? 'startOffset' : 'endOffset'] = offset;
 131                         }
 132
 133                         restoreEndPoint(true);
 134                         restoreEndPoint();
 135
 136                         var rng = dom.createRng();
 137
 138                         rng.setStart(bookmark.startContainer, bookmark.startOffset);
 139
 140                         if (bookmark.endContainer) {
 141                                 rng.setEnd(bookmark.endContainer, bookmark.endOffset);
 142                         }
 143
 144                         selection.setRng(rng);
 145                 }
 146
 147                 function createNewTextBlock(contentNode, blockName) {
 148                         var node, textBlock, fragment = dom.createFragment(), hasContentNode;
 149                         var blockElements = editor.schema.getBlockElements();
 150
 151                         if (editor.settings.forced_root_block) {
 152                                 blockName = blockName || editor.settings.forced_root_block;
 153                         }
 154
 155                         if (blockName) {
 156                                 textBlock = dom.create(blockName);
 157
 158                                 if (textBlock.tagName === editor.settings.forced_root_block) {
 159                                         dom.setAttribs(textBlock, editor.settings.forced_root_block_attrs);
 160                                 }
 161
 162                                 fragment.appendChild(textBlock);
 163                         }
 164
 165                         if (contentNode) {
 166                                 while ((node = contentNode.firstChild)) {
 167                                         var nodeName = node.nodeName;
 168
 169                                         if (!hasContentNode && (nodeName != 'SPAN' || node.getAttribute('data-mce-type') != 'bookmark')) {
 170                                                 hasContentNode = true;
 171                                         }
 172
 173                                         if (blockElements[nodeName]) {
 174                                                 fragment.appendChild(node);
 175                                                 textBlock = null;
 176                                         } else {
 177                                                 if (blockName) {
 178                                                         if (!textBlock) {
 179                                                                 textBlock = dom.create(blockName);
 180                                                                 fragment.appendChild(textBlock);
 181                                                         }
 182
 183                                                         textBlock.appendChild(node);
 184                                                 } else {
 185                                                         fragment.appendChild(node);
 186                                                 }
 187                                         }
 188                                 }
 189                         }
 190
 191                         if (!editor.settings.forced_root_block) {
 192                                 fragment.appendChild(dom.create('br'));
 193                         } else {
 194                                 // BR is needed in empty blocks on non IE browsers
 195                                 if (!hasContentNode && (!tinymce.Env.ie || tinymce.Env.ie > 10)) {
 196                                         textBlock.appendChild(dom.create('br', {'data-mce-bogus': '1'}));
 197                                 }
 198                         }
 199
 200                         return fragment;
 201                 }
 202
 203                 function getSelectedListItems() {
 204                         return tinymce.grep(selection.getSelectedBlocks(), function(block) {
 205                                 return /^(LI|DT|DD)$/.test(block.nodeName);
 206                         });
 207                 }
 208
 209                 function splitList(ul, li, newBlock) {
 210                         var tmpRng, fragment, bookmarks, node;
 211
 212                         function removeAndKeepBookmarks(targetNode) {
 213                                 tinymce.each(bookmarks, function(node) {
 214                                         targetNode.parentNode.insertBefore(node, li.parentNode);
 215                                 });
 216
 217                                 dom.remove(targetNode);
 218                         }
 219
 220                         bookmarks = dom.select('span[data-mce-type="bookmark"]', ul);
 221                         newBlock = newBlock || createNewTextBlock(li);
 222                         tmpRng = dom.createRng();
 223                         tmpRng.setStartAfter(li);
 224                         tmpRng.setEndAfter(ul);
 225                         fragment = tmpRng.extractContents();
 226
 227                         for (node = fragment.firstChild; node; node = node.firstChild) {
 228                                 if (node.nodeName == 'LI' && dom.isEmpty(node)) {
 229                                         dom.remove(node);
 230                                         break;
 231                                 }
 232                         }
 233
 234                         if (!dom.isEmpty(fragment)) {
 235                                 dom.insertAfter(fragment, ul);
 236                         }
 237
 238                         dom.insertAfter(newBlock, ul);
 239
 240                         if (dom.isEmpty(li.parentNode)) {
 241                                 removeAndKeepBookmarks(li.parentNode);
 242                         }
 243
 244                         dom.remove(li);
 245
 246                         if (dom.isEmpty(ul)) {
 247                                 dom.remove(ul);
 248                         }
 249                 }
 250
 251                 function mergeWithAdjacentLists(listBlock) {
 252                         var sibling, node;
 253
 254                         sibling = listBlock.nextSibling;
 255                         if (sibling && isListNode(sibling) && sibling.nodeName == listBlock.nodeName) {
 256                                 while ((node = sibling.firstChild)) {
 257                                         listBlock.appendChild(node);
 258                                 }
 259
 260                                 dom.remove(sibling);
 261                         }
 262
 263                         sibling = listBlock.previousSibling;
 264                         if (sibling && isListNode(sibling) && sibling.nodeName == listBlock.nodeName) {
 265                                 while ((node = sibling.firstChild)) {
 266                                         listBlock.insertBefore(node, listBlock.firstChild);
 267                                 }
 268
 269                                 dom.remove(sibling);
 270                         }
 271                 }
 272
 273                 /**
 274                  * Normalizes the all lists in the specified element.
 275                  */
 276                 function normalizeList(element) {
 277                         tinymce.each(tinymce.grep(dom.select('ol,ul', element)), function(ul) {
 278                                 var sibling, parentNode = ul.parentNode;
 279
 280                                 // Move UL/OL to previous LI if it's the only child of a LI
 281                                 if (parentNode.nodeName == 'LI' && parentNode.firstChild == ul) {
 282                                         sibling = parentNode.previousSibling;
 283                                         if (sibling && sibling.nodeName == 'LI') {
 284                                                 sibling.appendChild(ul);
 285
 286                                                 if (dom.isEmpty(parentNode)) {
 287                                                         dom.remove(parentNode);
 288                                                 }
 289                                         }
 290                                 }
 291
 292                                 // Append OL/UL to previous LI if it's in a parent OL/UL i.e. old HTML4
 293                                 if (isListNode(parentNode)) {
 294                                         sibling = parentNode.previousSibling;
 295                                         if (sibling && sibling.nodeName == 'LI') {
 296                                                 sibling.appendChild(ul);
 297                                         }
 298                                 }
 299                         });
 300                 }
 301
 302                 function outdent(li) {
 303                         var ul = li.parentNode, ulParent = ul.parentNode, newBlock;
 304
 305                         function removeEmptyLi(li) {
 306                                 if (dom.isEmpty(li)) {
 307                                         dom.remove(li);
 308                                 }
 309                         }
 310
 311                         if (li.nodeName == 'DD') {
 312                                 dom.rename(li, 'DT');
 313                                 return true;
 314                         }
 315
 316                         if (isFirstChild(li) && isLastChild(li)) {
 317                                 if (ulParent.nodeName == "LI") {
 318                                         dom.insertAfter(li, ulParent);
 319                                         removeEmptyLi(ulParent);
 320                                         dom.remove(ul);
 321                                 } else if (isListNode(ulParent)) {
 322                                         dom.remove(ul, true);
 323                                 } else {
 324                                         ulParent.insertBefore(createNewTextBlock(li), ul);
 325                                         dom.remove(ul);
 326                                 }
 327
 328                                 return true;
 329                         } else if (isFirstChild(li)) {
 330                                 if (ulParent.nodeName == "LI") {
 331                                         dom.insertAfter(li, ulParent);
 332                                         li.appendChild(ul);
 333                                         removeEmptyLi(ulParent);
 334                                 } else if (isListNode(ulParent)) {
 335                                         ulParent.insertBefore(li, ul);
 336                                 } else {
 337                                         ulParent.insertBefore(createNewTextBlock(li), ul);
 338                                         dom.remove(li);
 339                                 }
 340
 341                                 return true;
 342                         } else if (isLastChild(li)) {
 343                                 if (ulParent.nodeName == "LI") {
 344                                         dom.insertAfter(li, ulParent);
 345                                 } else if (isListNode(ulParent)) {
 346                                         dom.insertAfter(li, ul);
 347                                 } else {
 348                                         dom.insertAfter(createNewTextBlock(li), ul);
 349                                         dom.remove(li);
 350                                 }
 351
 352                                 return true;
 353                         } else {
 354                                 if (ulParent.nodeName == 'LI') {
 355                                         ul = ulParent;
 356                                         newBlock = createNewTextBlock(li, 'LI');
 357                                 } else if (isListNode(ulParent)) {
 358                                         newBlock = createNewTextBlock(li, 'LI');
 359                                 } else {
 360                                         newBlock = createNewTextBlock(li);
 361                                 }
 362
 363                                 splitList(ul, li, newBlock);
 364                                 normalizeList(ul.parentNode);
 365
 366                                 return true;
 367                         }
 368
 369                         return false;
 370                 }
 371
 372                 function indent(li) {
 373                         var sibling, newList;
 374
 375                         function mergeLists(from, to) {
 376                                 var node;
 377
 378                                 if (isListNode(from)) {
 379                                         while ((node = li.lastChild.firstChild)) {
 380                                                 to.appendChild(node);
 381                                         }
 382
 383                                         dom.remove(from);
 384                                 }
 385                         }
 386
 387                         if (li.nodeName == 'DT') {
 388                                 dom.rename(li, 'DD');
 389                                 return true;
 390                         }
 391
 392                         sibling = li.previousSibling;
 393
 394                         if (sibling && isListNode(sibling)) {
 395                                 sibling.appendChild(li);
 396                                 return true;
 397                         }
 398
 399                         if (sibling && sibling.nodeName == 'LI' && isListNode(sibling.lastChild)) {
 400                                 sibling.lastChild.appendChild(li);
 401                                 mergeLists(li.lastChild, sibling.lastChild);
 402                                 return true;
 403                         }
 404
 405                         sibling = li.nextSibling;
 406
 407                         if (sibling && isListNode(sibling)) {
 408                                 sibling.insertBefore(li, sibling.firstChild);
 409                                 return true;
 410                         }
 411
 412                         if (sibling && sibling.nodeName == 'LI' && isListNode(li.lastChild)) {
 413                                 return false;
 414                         }
 415
 416                         sibling = li.previousSibling;
 417                         if (sibling && sibling.nodeName == 'LI') {
 418                                 newList = dom.create(li.parentNode.nodeName);
 419                                 sibling.appendChild(newList);
 420                                 newList.appendChild(li);
 421                                 mergeLists(li.lastChild, newList);
 422                                 return true;
 423                         }
 424
 425                         return false;
 426                 }
 427
 428                 function indentSelection() {
 429                         var listElements = getSelectedListItems();
 430
 431                         if (listElements.length) {
 432                                 var bookmark = createBookmark(selection.getRng(true));
 433
 434                                 for (var i = 0; i < listElements.length; i++) {
 435                                         if (!indent(listElements[i]) && i === 0) {
 436                                                 break;
 437                                         }
 438                                 }
 439
 440                                 moveToBookmark(bookmark);
 441                                 editor.nodeChanged();
 442
 443                                 return true;
 444                         }
 445                 }
 446
 447                 function outdentSelection() {
 448                         var listElements = getSelectedListItems();
 449
 450                         if (listElements.length) {
 451                                 var bookmark = createBookmark(selection.getRng(true));
 452                                 var i, y, root = editor.getBody();
 453
 454                                 i = listElements.length;
 455                                 while (i--) {
 456                                         var node = listElements[i].parentNode;
 457
 458                                         while (node && node != root) {
 459                                                 y = listElements.length;
 460                                                 while (y--) {
 461                                                         if (listElements[y] === node) {
 462                                                                 listElements.splice(i, 1);
 463                                                                 break;
 464                                                         }
 465                                                 }
 466
 467                                                 node = node.parentNode;
 468                                         }
 469                                 }
 470
 471                                 for (i = 0; i < listElements.length; i++) {
 472                                         if (!outdent(listElements[i]) && i === 0) {
 473                                                 break;
 474                                         }
 475                                 }
 476
 477                                 moveToBookmark(bookmark);
 478                                 editor.nodeChanged();
 479
 480                                 return true;
 481                         }
 482                 }
 483
 484                 function applyList(listName) {
 485                         var rng = selection.getRng(true), bookmark = createBookmark(rng), listItemName = 'LI';
 486
 487                         listName = listName.toUpperCase();
 488
 489                         if (listName == 'DL') {
 490                                 listItemName = 'DT';
 491                         }
 492
 493                         function getSelectedTextBlocks() {
 494                                 var textBlocks = [], root = editor.getBody();
 495
 496                                 function getEndPointNode(start) {
 497                                         var container, offset;
 498
 499                                         container = rng[start ? 'startContainer' : 'endContainer'];
 500                                         offset = rng[start ? 'startOffset' : 'endOffset'];
 501
 502                                         // Resolve node index
 503                                         if (container.nodeType == 1) {
 504                                                 container = container.childNodes[Math.min(offset, container.childNodes.length - 1)] || container;
 505                                         }
 506
 507                                         while (container.parentNode != root) {
 508                                                 if (isTextBlock(container)) {
 509                                                         return container;
 510                                                 }
 511
 512                                                 if (/^(TD|TH)$/.test(container.parentNode.nodeName)) {
 513                                                         return container;
 514                                                 }
 515
 516                                                 container = container.parentNode;
 517                                         }
 518
 519                                         return container;
 520                                 }
 521
 522                                 var startNode = getEndPointNode(true);
 523                                 var endNode = getEndPointNode();
 524                                 var block, siblings = [];
 525
 526                                 for (var node = startNode; node; node = node.nextSibling) {
 527                                         siblings.push(node);
 528
 529                                         if (node == endNode) {
 530                                                 break;
 531                                         }
 532                                 }
 533
 534                                 tinymce.each(siblings, function(node) {
 535                                         if (isTextBlock(node)) {
 536                                                 textBlocks.push(node);
 537                                                 block = null;
 538                                                 return;
 539                                         }
 540
 541                                         if (dom.isBlock(node) || node.nodeName == 'BR') {
 542                                                 if (node.nodeName == 'BR') {
 543                                                         dom.remove(node);
 544                                                 }
 545
 546                                                 block = null;
 547                                                 return;
 548                                         }
 549
 550                                         var nextSibling = node.nextSibling;
 551                                         if (tinymce.dom.BookmarkManager.isBookmarkNode(node)) {
 552                                                 if (isTextBlock(nextSibling) || (!nextSibling && node.parentNode == root)) {
 553                                                         block = null;
 554                                                         return;
 555                                                 }
 556                                         }
 557
 558                                         if (!block) {
 559                                                 block = dom.create('p');
 560                                                 node.parentNode.insertBefore(block, node);
 561                                                 textBlocks.push(block);
 562                                         }
 563
 564                                         block.appendChild(node);
 565                                 });
 566
 567                                 return textBlocks;
 568                         }
 569
 570                         tinymce.each(getSelectedTextBlocks(), function(block) {
 571                                 var listBlock, sibling;
 572
 573                                 sibling = block.previousSibling;
 574                                 if (sibling && isListNode(sibling) && sibling.nodeName == listName) {
 575                                         listBlock = sibling;
 576                                         block = dom.rename(block, listItemName);
 577                                         sibling.appendChild(block);
 578                                 } else {
 579                                         listBlock = dom.create(listName);
 580                                         block.parentNode.insertBefore(listBlock, block);
 581                                         listBlock.appendChild(block);
 582                                         block = dom.rename(block, listItemName);
 583                                 }
 584
 585                                 mergeWithAdjacentLists(listBlock);
 586                         });
 587
 588                         moveToBookmark(bookmark);
 589                 }
 590
 591                 function removeList() {
 592                         var bookmark = createBookmark(selection.getRng(true)), root = editor.getBody();
 593
 594                         tinymce.each(getSelectedListItems(), function(li) {
 595                                 var node, rootList;
 596
 597                                 if (dom.isEmpty(li)) {
 598                                         outdent(li);
 599                                         return;
 600                                 }
 601
 602                                 for (node = li; node && node != root; node = node.parentNode) {
 603                                         if (isListNode(node)) {
 604                                                 rootList = node;
 605                                         }
 606                                 }
 607
 608                                 splitList(rootList, li);
 609                         });
 610
 611                         moveToBookmark(bookmark);
 612                 }
 613
 614                 function toggleList(listName) {
 615                         var parentList = dom.getParent(selection.getStart(), 'OL,UL,DL');
 616
 617                         if (parentList) {
 618                                 if (parentList.nodeName == listName) {
 619                                         removeList(listName);
 620                                 } else {
 621                                         var bookmark = createBookmark(selection.getRng(true));
 622                                         mergeWithAdjacentLists(dom.rename(parentList, listName));
 623                                         moveToBookmark(bookmark);
 624                                 }
 625                         } else {
 626                                 applyList(listName);
 627                         }
 628                 }
 629
 630                 function queryListCommandState(listName) {
 631                         return function() {
 632                                 var parentList = dom.getParent(editor.selection.getStart(), 'UL,OL,DL');
 633
 634                                 return parentList && parentList.nodeName == listName;
 635                         };
 636                 }
 637
 638                 self.backspaceDelete = function(isForward) {
 639                         function findNextCaretContainer(rng, isForward) {
 640                                 var node = rng.startContainer, offset = rng.startOffset;
 641                                 var nonEmptyBlocks, walker;
 642
 643                                 if (node.nodeType == 3 && (isForward ? offset < node.data.length : offset > 0)) {
 644                                         return node;
 645                                 }
 646
 647                                 nonEmptyBlocks = editor.schema.getNonEmptyElements();
 648                                 walker = new tinymce.dom.TreeWalker(rng.startContainer);
 649
 650                                 while ((node = walker[isForward ? 'next' : 'prev']())) {
 651                                         if (node.nodeName == 'LI' && !node.hasChildNodes()) {
 652                                                 return node;
 653                                         }
 654
 655                                         if (nonEmptyBlocks[node.nodeName]) {
 656                                                 return node;
 657                                         }
 658
 659                                         if (node.nodeType == 3 && node.data.length > 0) {
 660                                                 return node;
 661                                         }
 662                                 }
 663                         }
 664
 665                         function mergeLiElements(fromElm, toElm) {
 666                                 var node, listNode, ul = fromElm.parentNode;
 667
 668                                 if (isListNode(toElm.lastChild)) {
 669                                         listNode = toElm.lastChild;
 670                                 }
 671
 672                                 node = toElm.lastChild;
 673                                 if (node && node.nodeName == 'BR' && fromElm.hasChildNodes()) {
 674                                         dom.remove(node);
 675                                 }
 676
 677                                 if (dom.isEmpty(toElm)) {
 678                                         dom.$(toElm).empty();
 679                                 }
 680
 681                                 if (!dom.isEmpty(fromElm)) {
 682                                         while ((node = fromElm.firstChild)) {
 683                                                 toElm.appendChild(node);
 684                                         }
 685                                 }
 686
 687                                 if (listNode) {
 688                                         toElm.appendChild(listNode);
 689                                 }
 690
 691                                 dom.remove(fromElm);
 692
 693                                 if (dom.isEmpty(ul)) {
 694                                         dom.remove(ul);
 695                                 }
 696                         }
 697
 698                         if (selection.isCollapsed()) {
 699                                 var li = dom.getParent(selection.getStart(), 'LI');
 700
 701                                 if (li) {
 702                                         var rng = selection.getRng(true);
 703                                         var otherLi = dom.getParent(findNextCaretContainer(rng, isForward), 'LI');
 704
 705                                         if (otherLi && otherLi != li) {
 706                                                 var bookmark = createBookmark(rng);
 707
 708                                                 if (isForward) {
 709                                                         mergeLiElements(otherLi, li);
 710                                                 } else {
 711                                                         mergeLiElements(li, otherLi);
 712                                                 }
 713
 714                                                 moveToBookmark(bookmark);
 715
 716                                                 return true;
 717                                         } else if (!otherLi) {
 718                                                 if (!isForward && removeList(li.parentNode.nodeName)) {
 719                                                         return true;
 720                                                 }
 721                                         }
 722                                 }
 723                         }
 724                 };
 725
 726                 editor.on('BeforeExecCommand', function(e) {
 727                         var cmd = e.command.toLowerCase(), isHandled;
 728
 729                         if (cmd == "indent") {
 730                                 if (indentSelection()) {
 731                                         isHandled = true;
 732                                 }
 733                         } else if (cmd == "outdent") {
 734                                 if (outdentSelection()) {
 735                                         isHandled = true;
 736                                 }
 737                         }
 738
 739                         if (isHandled) {
 740                                 editor.fire('ExecCommand', {command: e.command});
 741                                 e.preventDefault();
 742                                 return true;
 743                         }
 744                 });
 745
 746                 editor.addCommand('InsertUnorderedList', function() {
 747                         toggleList('UL');
 748                 });
 749
 750                 editor.addCommand('InsertOrderedList', function() {
 751                         toggleList('OL');
 752                 });
 753
 754                 editor.addCommand('InsertDefinitionList', function() {
 755                         toggleList('DL');
 756                 });
 757
 758                 editor.addQueryStateHandler('InsertUnorderedList', queryListCommandState('UL'));
 759                 editor.addQueryStateHandler('InsertOrderedList', queryListCommandState('OL'));
 760                 editor.addQueryStateHandler('InsertDefinitionList', queryListCommandState('DL'));
 761
 762                 editor.on('keydown', function(e) {
 763                         // Check for tab but not ctrl/cmd+tab since it switches browser tabs
 764                         if (e.keyCode != 9 || tinymce.util.VK.metaKeyPressed(e)) {
 765                                 return;
 766                         }
 767
 768                         if (editor.dom.getParent(editor.selection.getStart(), 'LI,DT,DD')) {
 769                                 e.preventDefault();
 770
 771                                 if (e.shiftKey) {
 772                                         outdentSelection();
 773                                 } else {
 774                                         indentSelection();
 775                                 }
 776                         }
 777                 });
 778         });
 779
 780         editor.addButton('indent', {
 781                 icon: 'indent',
 782                 title: 'Increase indent',
 783                 cmd: 'Indent',
 784                 onPostRender: function() {
 785                         var ctrl = this;
 786
 787                         editor.on('nodechange', function() {
 788                                 var blocks = editor.selection.getSelectedBlocks();
 789                                 var disable = false;
 790
 791                                 for (var i = 0, l = blocks.length; !disable && i < l; i++) {
 792                                         var tag = blocks[i].nodeName;
 793
 794                                         disable = (tag == 'LI' && isFirstChild(blocks[i]) || tag == 'UL' || tag == 'OL' || tag == 'DD');
 795                                 }
 796
 797                                 ctrl.disabled(disable);
 798                         });
 799                 }
 800         });
 801
 802         editor.on('keydown', function(e) {
 803                 if (e.keyCode == tinymce.util.VK.BACKSPACE) {
 804                         if (self.backspaceDelete()) {
 805                                 e.preventDefault();
 806                         }
 807                 } else if (e.keyCode == tinymce.util.VK.DELETE) {
 808                         if (self.backspaceDelete(true)) {
 809                                 e.preventDefault();
 810                         }
 811                 }
 812         });
 813 });