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 });