/*

 * FCKeditor - The text editor for Internet - http://www.fckeditor.net

 * Copyright (C) 2003-2009 Frederico Caldeira Knabben

 *

 * == BEGIN LICENSE ==

 *

 * Licensed under the terms of any of the following licenses at your

 * choice:

 *

 *  - GNU General Public License Version 2 or later (the "GPL")

 *    http://www.gnu.org/licenses/gpl.html

 *

 *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")

 *    http://www.gnu.org/licenses/lgpl.html

 *

 *  - Mozilla Public License Version 1.1 or later (the "MPL")

 *    http://www.mozilla.org/MPL/MPL-1.1.html

 *

 * == END LICENSE ==

 *

 * FCKIndentCommand Class: controls block indentation.

 */



var FCKIndentCommand = function( name, offset )

{

	this.Name = name ;

	this.Offset = offset ;

	this.IndentCSSProperty = FCKConfig.ContentLangDirection.IEquals( 'ltr' ) ? 'marginLeft' : 'marginRight' ;

}



FCKIndentCommand._InitIndentModeParameters = function()

{

	if ( FCKConfig.IndentClasses && FCKConfig.IndentClasses.length > 0 )

	{

		this._UseIndentClasses = true ;

		this._IndentClassMap = {} ;

		for ( var i = 0 ; i < FCKConfig.IndentClasses.length ;i++ )

			this._IndentClassMap[FCKConfig.IndentClasses[i]] = i + 1 ;

		this._ClassNameRegex = new RegExp( '(?:^|\\s+)(' + FCKConfig.IndentClasses.join( '|' ) + ')(?=$|\\s)' ) ;

	}

	else

		this._UseIndentClasses = false ;

}





FCKIndentCommand.prototype =

{

	Execute : function()

	{

		// Save an undo snapshot before doing anything.

		FCKUndo.SaveUndoStep() ;



		var range = new FCKDomRange( FCK.EditorWindow ) ;

		range.MoveToSelection() ;

		var bookmark = range.CreateBookmark() ;



		// Two cases to handle here: either we're in a list, or not.

		// If we're in a list, then the indent/outdent operations would be done on the list nodes.

		// Otherwise, apply the operation on the nearest block nodes.

		var nearestListBlock = FCKDomTools.GetCommonParentNode( range.StartNode || range.StartContainer ,

				range.EndNode || range.EndContainer,

				['ul', 'ol'] ) ;

		if ( nearestListBlock )

			this._IndentList( range, nearestListBlock ) ;

		else

			this._IndentBlock( range ) ;



		range.MoveToBookmark( bookmark ) ;

		range.Select() ;



		FCK.Focus() ;

		FCK.Events.FireEvent( 'OnSelectionChange' ) ;

	},



	GetState : function()

	{

		// Disabled if not WYSIWYG.

		if ( FCK.EditMode != FCK_EDITMODE_WYSIWYG || ! FCK.EditorWindow )

			return FCK_TRISTATE_DISABLED ;



		// Initialize parameters if not already initialzed.

		if ( FCKIndentCommand._UseIndentClasses == undefined )

			FCKIndentCommand._InitIndentModeParameters() ;



		// If we're not in a list, and the starting block's indentation is zero, and the current

		// command is the outdent command, then we should return FCK_TRISTATE_DISABLED.

		var startContainer = FCKSelection.GetBoundaryParentElement( true ) ;

		var endContainer = FCKSelection.GetBoundaryParentElement( false ) ;

		var listNode = FCKDomTools.GetCommonParentNode( startContainer, endContainer, ['ul','ol'] ) ;



		if ( listNode )

		{

			if ( this.Name.IEquals( 'outdent' ) )

				return FCK_TRISTATE_OFF ;

			var firstItem = FCKTools.GetElementAscensor( startContainer, 'li' ) ;

			if ( !firstItem || !firstItem.previousSibling )

				return FCK_TRISTATE_DISABLED ;

			return FCK_TRISTATE_OFF ;

		}

		if ( ! FCKIndentCommand._UseIndentClasses && this.Name.IEquals( 'indent' ) )

			return FCK_TRISTATE_OFF;



		var path = new FCKElementPath( startContainer ) ;

		var firstBlock = path.Block || path.BlockLimit ;

		if ( !firstBlock )

			return FCK_TRISTATE_DISABLED ;



		if ( FCKIndentCommand._UseIndentClasses )

		{

			var indentClass = firstBlock.className.match( FCKIndentCommand._ClassNameRegex ) ;

			var indentStep = 0 ;

			if ( indentClass != null )

			{

				indentClass = indentClass[1] ;

				indentStep = FCKIndentCommand._IndentClassMap[indentClass] ;

			}

			if ( ( this.Name == 'outdent' && indentStep == 0 ) ||

					( this.Name == 'indent' && indentStep == FCKConfig.IndentClasses.length ) )

				return FCK_TRISTATE_DISABLED ;

			return FCK_TRISTATE_OFF ;

		}

		else

		{

			var indent = parseInt( firstBlock.style[this.IndentCSSProperty], 10 ) ;

			if ( isNaN( indent ) )

				indent = 0 ;

			if ( indent <= 0 )

				return FCK_TRISTATE_DISABLED ;

			return FCK_TRISTATE_OFF ;

		}

	},



	_IndentBlock : function( range )

	{

		var iterator = new FCKDomRangeIterator( range ) ;

		iterator.EnforceRealBlocks = true ;



		range.Expand( 'block_contents' ) ;

		var commonParents = FCKDomTools.GetCommonParents( range.StartContainer, range.EndContainer ) ;

		var nearestParent = commonParents[commonParents.length - 1] ;

		var block ;



		while ( ( block = iterator.GetNextParagraph() ) )

		{

			// We don't want to indent subtrees recursively, so only perform the indent operation

			// if the block itself is the nearestParent, or the block's parent is the nearestParent.

			if ( ! ( block == nearestParent || block.parentNode == nearestParent ) )

				continue ;



			if ( FCKIndentCommand._UseIndentClasses )

			{

				// Transform current class name to indent step index.

				var indentClass = block.className.match( FCKIndentCommand._ClassNameRegex ) ;

				var indentStep = 0 ;

				if ( indentClass != null )

				{

					indentClass = indentClass[1] ;

					indentStep = FCKIndentCommand._IndentClassMap[indentClass] ;

				}



				// Operate on indent step index, transform indent step index back to class name.

				if ( this.Name.IEquals( 'outdent' ) )

					indentStep-- ;

				else if ( this.Name.IEquals( 'indent' ) )

					indentStep++ ;

				indentStep = Math.min( indentStep, FCKConfig.IndentClasses.length ) ;

				indentStep = Math.max( indentStep, 0 ) ;

				var className = block.className.replace( FCKIndentCommand._ClassNameRegex, '' ) ;

				if ( indentStep < 1 )

					block.className = className ;

				else

					block.className = ( className.length > 0 ? className + ' ' : '' ) +

						FCKConfig.IndentClasses[indentStep - 1] ;

			}

			else

			{

				// Offset distance is assumed to be in pixels for now.

				var currentOffset = parseInt( block.style[this.IndentCSSProperty], 10 ) ;

				if ( isNaN( currentOffset ) )

					currentOffset = 0 ;

				currentOffset += this.Offset ;

				currentOffset = Math.max( currentOffset, 0 ) ;

				currentOffset = Math.ceil( currentOffset / this.Offset ) * this.Offset ;

				block.style[this.IndentCSSProperty] = currentOffset ? currentOffset + FCKConfig.IndentUnit : '' ;

				if ( block.getAttribute( 'style' ) == '' )

					block.removeAttribute( 'style' ) ;

			}

		}

	},



	_IndentList : function( range, listNode )

	{

		// Our starting and ending points of the range might be inside some blocks under a list item...

		// So before playing with the iterator, we need to expand the block to include the list items.

		var startContainer = range.StartContainer ;

		var endContainer = range.EndContainer ;

		while ( startContainer && startContainer.parentNode != listNode )

			startContainer = startContainer.parentNode ;

		while ( endContainer && endContainer.parentNode != listNode )

			endContainer = endContainer.parentNode ;



		if ( ! startContainer || ! endContainer )

			return ;



		// Now we can iterate over the individual items on the same tree depth.

		var block = startContainer ;

		var itemsToMove = [] ;

		var stopFlag = false ;

		while ( stopFlag == false )

		{

			if ( block == endContainer )

				stopFlag = true ;

			itemsToMove.push( block ) ;

			block = block.nextSibling ;

		}

		if ( itemsToMove.length < 1 )

			return ;



		// Do indent or outdent operations on the array model of the list, not the list's DOM tree itself.

		// The array model demands that it knows as much as possible about the surrounding lists, we need

		// to feed it the further ancestor node that is still a list.

		var listParents = FCKDomTools.GetParents( listNode ) ;

		for ( var i = 0 ; i < listParents.length ; i++ )

		{

			if ( listParents[i].nodeName.IEquals( ['ul', 'ol'] ) )

			{

				listNode = listParents[i] ;

				break ;

			}

		}

		var indentOffset = this.Name.IEquals( 'indent' ) ? 1 : -1 ;

		var startItem = itemsToMove[0] ;

		var lastItem = itemsToMove[ itemsToMove.length - 1 ] ;

		var markerObj = {} ;



		// Convert the list DOM tree into a one dimensional array.

		var listArray = FCKDomTools.ListToArray( listNode, markerObj ) ;



		// Apply indenting or outdenting on the array.

		var baseIndent = listArray[lastItem._FCK_ListArray_Index].indent ;

		for ( var i = startItem._FCK_ListArray_Index ; i <= lastItem._FCK_ListArray_Index ; i++ )

			listArray[i].indent += indentOffset ;

		for ( var i = lastItem._FCK_ListArray_Index + 1 ; i < listArray.length && listArray[i].indent > baseIndent ; i++ )

			listArray[i].indent += indentOffset ;



		/* For debug use only

		var PrintArray = function( listArray, doc )

		{

			var s = [] ;

			for ( var i = 0 ; i < listArray.length ; i++ )

			{

				for ( var j in listArray[i] )

				{

					if ( j != 'contents' )

						s.push( j + ":" + listArray[i][j] + "; " ) ;

					else

					{

						var docFrag = doc.createDocumentFragment() ;

						var tmpNode = doc.createElement( 'span' ) ;

						for ( var k = 0 ; k < listArray[i][j].length ; k++ )

							docFrag.appendChild( listArray[i][j][k].cloneNode( true ) ) ;

						tmpNode.appendChild( docFrag ) ;

						s.push( j + ":" + tmpNode.innerHTML + "; ") ;

					}

				}

				s.push( '\n' ) ;

			}

			alert( s.join('') ) ;

		}

		PrintArray( listArray, FCK.EditorDocument ) ;

		*/



		// Convert the array back to a DOM forest (yes we might have a few subtrees now).

		// And replace the old list with the new forest.

		var newList = FCKDomTools.ArrayToList( listArray ) ;

		if ( newList )

			listNode.parentNode.replaceChild( newList.listNode, listNode ) ;



		// Clean up the markers.

		FCKDomTools.ClearAllMarkers( markerObj ) ;

	}

} ;