WB 2.08.x

var FCKDragTableHandler =

{

	"_DragState" : 0,

	"_LeftCell" : null,

	"_RightCell" : null,

	"_MouseMoveMode" : 0,	// 0 - find candidate cells for resizing, 1 - drag to resize

	"_ResizeBar" : null,

	"_OriginalX" : null,

	"_MinimumX" : null,

	"_MaximumX" : null,

	"_LastX" : null,

	"_TableMap" : null,

	"_doc" : document,

	"_IsInsideNode" : function( w, domNode, pos )

	{

		var myCoords = FCKTools.GetWindowPosition( w, domNode ) ;

		var xMin = myCoords.x ;

		var yMin = myCoords.y ;

		var xMax = parseInt( xMin, 10 ) + parseInt( domNode.offsetWidth, 10 ) ;

		var yMax = parseInt( yMin, 10 ) + parseInt( domNode.offsetHeight, 10 ) ;

		if ( pos.x >= xMin && pos.x <= xMax && pos.y >= yMin && pos.y <= yMax )

			return true;

		return false;

	},

	"_GetBorderCells" : function( w, tableNode, tableMap, mouse )

	{

		// Enumerate all the cells in the table.

		var cells = [] ;

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

		{

			var r = tableNode.rows[i] ;

			for ( var j = 0 ; j < r.cells.length ; j++ )

				cells.push( r.cells[j] ) ;

		}

		if ( cells.length < 1 )

			return null ;

		// Get the cells whose right or left border is nearest to the mouse cursor's x coordinate.

		var minRxDist = null ;

		var lxDist = null ;

		var minYDist = null ;

		var rbCell = null ;

		var lbCell = null ;

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

		{

			var pos = FCKTools.GetWindowPosition( w, cells[i] ) ;

			var rightX = pos.x + parseInt( cells[i].clientWidth, 10 ) ;

			var rxDist = mouse.x - rightX ;

			var yDist = mouse.y - ( pos.y + ( cells[i].clientHeight / 2 ) ) ;

			if ( minRxDist == null ||

					( Math.abs( rxDist ) <= Math.abs( minRxDist ) &&

					  ( minYDist == null || Math.abs( yDist ) <= Math.abs( minYDist ) ) ) )

			{

				minRxDist = rxDist ;

				minYDist = yDist ;

				rbCell = cells[i] ;

			}

		}

		/*

		var rowNode = FCKTools.GetElementAscensor( rbCell, "tr" ) ;

		var cellIndex = rbCell.cellIndex + 1 ;

		if ( cellIndex >= rowNode.cells.length )

			return null ;

		lbCell = rowNode.cells.item( cellIndex ) ;

		*/

		var rowIdx = rbCell.parentNode.rowIndex ;

		var colIdx = FCKTableHandler._GetCellIndexSpan( tableMap, rowIdx, rbCell ) ;

		var colSpan = isNaN( rbCell.colSpan ) ? 1 : rbCell.colSpan ;

		lbCell = tableMap[rowIdx][colIdx + colSpan] ;

		if ( ! lbCell )

			return null ;

		// Abort if too far from the border.

		lxDist = mouse.x - FCKTools.GetWindowPosition( w, lbCell ).x ;

		if ( lxDist < 0 && minRxDist < 0 && minRxDist < -2 )

			return null ;

		if ( lxDist > 0 && minRxDist > 0 && lxDist > 3 )

			return null ;

		return { "leftCell" : rbCell, "rightCell" : lbCell } ;

	},

	"_GetResizeBarPosition" : function()

	{

		var row = FCKTools.GetElementAscensor( this._RightCell, "tr" ) ;

		return FCKTableHandler._GetCellIndexSpan( this._TableMap, row.rowIndex, this._RightCell ) ;

	},

	"_ResizeBarMouseDownListener" : function( evt )

	{

		if ( FCKDragTableHandler._LeftCell )

			FCKDragTableHandler._MouseMoveMode = 1 ;

		if ( FCKBrowserInfo.IsIE )

			FCKDragTableHandler._ResizeBar.filters.item("DXImageTransform.Microsoft.Alpha").opacity = 50 ;

		else

			FCKDragTableHandler._ResizeBar.style.opacity = 0.5 ;

		FCKDragTableHandler._OriginalX = evt.clientX ;

		// Calculate maximum and minimum x-coordinate delta.

		var borderIndex = FCKDragTableHandler._GetResizeBarPosition() ;

		var offset = FCKDragTableHandler._GetIframeOffset();

		var table = FCKTools.GetElementAscensor( FCKDragTableHandler._LeftCell, "table" );

		var minX = null ;

		var maxX = null ;

		for ( var r = 0 ; r < FCKDragTableHandler._TableMap.length ; r++ )

		{

			var leftCell = FCKDragTableHandler._TableMap[r][borderIndex - 1] ;

			var rightCell = FCKDragTableHandler._TableMap[r][borderIndex] ;

			var leftPosition = FCKTools.GetWindowPosition( FCK.EditorWindow, leftCell ) ;

			var rightPosition = FCKTools.GetWindowPosition( FCK.EditorWindow, rightCell ) ;

			var leftPadding = FCKDragTableHandler._GetCellPadding( table, leftCell ) ;

			var rightPadding = FCKDragTableHandler._GetCellPadding( table, rightCell ) ;

			if ( minX == null || leftPosition.x + leftPadding > minX )

				minX = leftPosition.x + leftPadding ;

			if ( maxX == null || rightPosition.x + rightCell.clientWidth - rightPadding < maxX )

				maxX = rightPosition.x + rightCell.clientWidth - rightPadding ;

		}

		FCKDragTableHandler._MinimumX = minX + offset.x ;

		FCKDragTableHandler._MaximumX = maxX + offset.x ;

		FCKDragTableHandler._LastX = null ;

		if (evt.preventDefault)

			evt.preventDefault();

		else

			evt.returnValue = false;

	},

	"_ResizeBarMouseUpListener" : function( evt )

	{

		FCKDragTableHandler._MouseMoveMode = 0 ;

		FCKDragTableHandler._HideResizeBar() ;

		if ( FCKDragTableHandler._LastX == null )

			return ;

		// Calculate the delta value.

		var deltaX = FCKDragTableHandler._LastX - FCKDragTableHandler._OriginalX ;

		// Then, build an array of current column width values.

		// This algorithm can be very slow if the cells have insane colSpan values. (e.g. colSpan=1000).

		var table = FCKTools.GetElementAscensor( FCKDragTableHandler._LeftCell, "table" ) ;

		var colArray = [] ;

		var tableMap = FCKDragTableHandler._TableMap ;

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

		{

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

			{

				var cell = tableMap[i][j] ;

				var width = FCKDragTableHandler._GetCellWidth( table, cell ) ;

				var colSpan = isNaN( cell.colSpan) ? 1 : cell.colSpan ;

				if ( colArray.length <= j )

					colArray.push( { width : width / colSpan, colSpan : colSpan } ) ;

				else

				{

					var guessItem = colArray[j] ;

					if ( guessItem.colSpan > colSpan )

					{

						guessItem.width = width / colSpan ;

						guessItem.colSpan = colSpan ;

					}

				}

			}

		}

		// Find out the equivalent column index of the two cells selected for resizing.

		colIndex = FCKDragTableHandler._GetResizeBarPosition() ;

		// Note that colIndex must be at least 1 here, so it's safe to subtract 1 from it.

		colIndex-- ;

		// Modify the widths in the colArray according to the mouse coordinate delta value.

		colArray[colIndex].width += deltaX ;

		colArray[colIndex + 1].width -= deltaX ;

		// Clear all cell widths, delete all <col> elements from the table.

		for ( var r = 0 ; r < table.rows.length ; r++ )

		{

			var row = table.rows.item( r ) ;

			for ( var c = 0 ; c < row.cells.length ; c++ )

			{

				var cell = row.cells.item( c ) ;

				cell.width = "" ;

				cell.style.width = "" ;

			}

		}

		var colElements = table.getElementsByTagName( "col" ) ;

		for ( var i = colElements.length - 1 ; i >= 0 ; i-- )

			colElements[i].parentNode.removeChild( colElements[i] ) ;

		// Set new cell widths.

		var processedCells = [] ;

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

		{

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

			{

				var cell = tableMap[i][j] ;

				if ( cell._Processed )

					continue ;

				if ( tableMap[i][j-1] != cell )

					cell.width = colArray[j].width ;

				else

					cell.width = parseInt( cell.width, 10 ) + parseInt( colArray[j].width, 10 ) ;

				if ( tableMap[i][j+1] != cell )

				{

					processedCells.push( cell ) ;

					cell._Processed = true ;

				}

			}

		}

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

		{

			if ( FCKBrowserInfo.IsIE )

				processedCells[i].removeAttribute( '_Processed' ) ;

			else

				delete processedCells[i]._Processed ;

		}

		FCKDragTableHandler._LastX = null ;

	},

	"_ResizeBarMouseMoveListener" : function( evt )

	{

		if ( FCKDragTableHandler._MouseMoveMode == 0 )

			return FCKDragTableHandler._MouseFindHandler( FCK, evt ) ;

		else

			return FCKDragTableHandler._MouseDragHandler( FCK, evt ) ;

	},

	// Calculate the padding of a table cell.

	// It returns the value of paddingLeft + paddingRight of a table cell.

	// This function is used, in part, to calculate the width parameter that should be used for setting cell widths.

	// The equation in question is clientWidth = paddingLeft + paddingRight + width.

	// So that width = clientWidth - paddingLeft - paddingRight.

	// The return value of this function must be pixel accurate acorss all supported browsers, so be careful if you need to modify it.

	"_GetCellPadding" : function( table, cell )

	{

		var attrGuess = parseInt( table.cellPadding, 10 ) * 2 ;

		var cssGuess = null ;

		if ( typeof( window.getComputedStyle ) == "function" )

		{

			var styleObj = window.getComputedStyle( cell, null ) ;

			cssGuess = parseInt( styleObj.getPropertyValue( "padding-left" ), 10 ) +

				parseInt( styleObj.getPropertyValue( "padding-right" ), 10 ) ;

		}

		else

			cssGuess = parseInt( cell.currentStyle.paddingLeft, 10 ) + parseInt (cell.currentStyle.paddingRight, 10 ) ;

		var cssRuntime = cell.style.padding ;

		if ( isFinite( cssRuntime ) )

			cssGuess = parseInt( cssRuntime, 10 ) * 2 ;

		else

		{

			cssRuntime = cell.style.paddingLeft ;

			if ( isFinite( cssRuntime ) )

				cssGuess = parseInt( cssRuntime, 10 ) ;

			cssRuntime = cell.style.paddingRight ;

			if ( isFinite( cssRuntime ) )

				cssGuess += parseInt( cssRuntime, 10 ) ;

		}

		attrGuess = parseInt( attrGuess, 10 ) ;

		cssGuess = parseInt( cssGuess, 10 ) ;

		if ( isNaN( attrGuess ) )

			attrGuess = 0 ;

		if ( isNaN( cssGuess ) )

			cssGuess = 0 ;

		return Math.max( attrGuess, cssGuess ) ;

	},

	// Calculate the real width of the table cell.

	// The real width of the table cell is the pixel width that you can set to the width attribute of the table cell and after

	// that, the table cell should be of exactly the same width as before.

	// The real width of a table cell can be calculated as:

	// width = clientWidth - paddingLeft - paddingRight.

	"_GetCellWidth" : function( table, cell )

	{

		var clientWidth = cell.clientWidth ;

		if ( isNaN( clientWidth ) )

			clientWidth = 0 ;

		return clientWidth - this._GetCellPadding( table, cell ) ;

	},

	"MouseMoveListener" : function( FCK, evt )

	{

		if ( FCKDragTableHandler._MouseMoveMode == 0 )

			return FCKDragTableHandler._MouseFindHandler( FCK, evt ) ;

		else

			return FCKDragTableHandler._MouseDragHandler( FCK, evt ) ;

	},

	"_MouseFindHandler" : function( FCK, evt )

	{

		if ( FCK.MouseDownFlag )

			return ;

		var node = evt.srcElement || evt.target ;

		try

		{

			if ( ! node || node.nodeType != 1 )

			{

				this._HideResizeBar() ;

				return ;

			}

		}

		catch ( e )

		{

			this._HideResizeBar() ;

			return ;

		}

		// Since this function might be called from the editing area iframe or the outer fckeditor iframe,

		// the mouse point coordinates from evt.clientX/Y can have different reference points.

		// We need to resolve the mouse pointer position relative to the editing area iframe.

		var mouseX = evt.clientX ;

		var mouseY = evt.clientY ;

		if ( FCKTools.GetElementDocument( node ) == document )

		{

			var offset = this._GetIframeOffset() ;

			mouseX -= offset.x ;

			mouseY -= offset.y ;

		}

		if ( this._ResizeBar && this._LeftCell )

		{

			var leftPos = FCKTools.GetWindowPosition( FCK.EditorWindow, this._LeftCell ) ;

			var rightPos = FCKTools.GetWindowPosition( FCK.EditorWindow, this._RightCell ) ;

			var rxDist = mouseX - ( leftPos.x + this._LeftCell.clientWidth ) ;

			var lxDist = mouseX - rightPos.x ;

			var inRangeFlag = false ;

			if ( lxDist >= 0 && rxDist <= 0 )

				inRangeFlag = true ;

			else if ( rxDist > 0 && lxDist <= 3 )

				inRangeFlag = true ;

			else if ( lxDist < 0 && rxDist >= -2 )

				inRangeFlag = true ;

			if ( inRangeFlag )

			{

				this._ShowResizeBar( FCK.EditorWindow,

					FCKTools.GetElementAscensor( this._LeftCell, "table" ),

					{ "x" : mouseX, "y" : mouseY } ) ;

				return ;

			}

		}

		var tagName = node.tagName.toLowerCase() ;

		if ( tagName != "table" && tagName != "td" && tagName != "th" )

		{

			if ( this._LeftCell )

				this._LeftCell = this._RightCell = this._TableMap = null ;

			this._HideResizeBar() ;

			return ;

		}

		node = FCKTools.GetElementAscensor( node, "table" ) ;

		var tableMap = FCKTableHandler._CreateTableMap( node ) ;

		var cellTuple = this._GetBorderCells( FCK.EditorWindow, node, tableMap, { "x" : mouseX, "y" : mouseY } ) ;

		if ( cellTuple == null )

		{

			if ( this._LeftCell )

				this._LeftCell = this._RightCell = this._TableMap = null ;

			this._HideResizeBar() ;

		}

		else

		{

			this._LeftCell = cellTuple["leftCell"] ;

			this._RightCell = cellTuple["rightCell"] ;

			this._TableMap = tableMap ;

			this._ShowResizeBar( FCK.EditorWindow,

					FCKTools.GetElementAscensor( this._LeftCell, "table" ),

					{ "x" : mouseX, "y" : mouseY } ) ;

		}

	},

	"_MouseDragHandler" : function( FCK, evt )

	{

		var mouse = { "x" : evt.clientX, "y" : evt.clientY } ;

		// Convert mouse coordinates in reference to the outer iframe.

		var node = evt.srcElement || evt.target ;

		if ( FCKTools.GetElementDocument( node ) == FCK.EditorDocument )

		{

			var offset = this._GetIframeOffset() ;

			mouse.x += offset.x ;

			mouse.y += offset.y ;

		}

		// Calculate the mouse position delta and see if we've gone out of range.

		if ( mouse.x >= this._MaximumX - 5 )

			mouse.x = this._MaximumX - 5 ;

		if ( mouse.x <= this._MinimumX + 5 )

			mouse.x = this._MinimumX + 5 ;

		var docX = mouse.x + FCKTools.GetScrollPosition( window ).X ;

		this._ResizeBar.style.left = ( docX - this._ResizeBar.offsetWidth / 2 ) + "px" ;

		this._LastX = mouse.x ;

	},

	"_ShowResizeBar" : function( w, table, mouse )

	{

		if ( this._ResizeBar == null )

		{

			this._ResizeBar = this._doc.createElement( "div" ) ;

			var paddingBar = this._ResizeBar ;

			var paddingStyles = { 'position' : 'absolute', 'cursor' : 'e-resize' } ;

			if ( FCKBrowserInfo.IsIE )

				paddingStyles.filter = "progid:DXImageTransform.Microsoft.Alpha(opacity=10,enabled=true)" ;

			else

				paddingStyles.opacity = 0.10 ;

			FCKDomTools.SetElementStyles( paddingBar, paddingStyles ) ;

			this._avoidStyles( paddingBar );

			paddingBar.setAttribute('_fcktemp', true);

			this._doc.body.appendChild( paddingBar ) ;

			FCKTools.AddEventListener( paddingBar, "mousemove", this._ResizeBarMouseMoveListener ) ;

			FCKTools.AddEventListener( paddingBar, "mousedown", this._ResizeBarMouseDownListener ) ;

			FCKTools.AddEventListener( document, "mouseup", this._ResizeBarMouseUpListener ) ;

			FCKTools.AddEventListener( FCK.EditorDocument, "mouseup", this._ResizeBarMouseUpListener ) ;

			// IE doesn't let the tranparent part of the padding block to receive mouse events unless there's something inside.

			// So we need to create a spacer image to fill the block up.

			var filler = this._doc.createElement( "img" ) ;

			filler.setAttribute('_fcktemp', true);

			filler.border = 0 ;

			filler.src = FCKConfig.BasePath + "images/spacer.gif" ;

			filler.style.position = "absolute" ;

			paddingBar.appendChild( filler ) ;

			// Disable drag and drop, and selection for the filler image.

			var disabledListener = function( evt )

			{

				if ( evt.preventDefault )

					evt.preventDefault() ;

				else

					evt.returnValue = false ;

			}

			FCKTools.AddEventListener( filler, "dragstart", disabledListener ) ;

			FCKTools.AddEventListener( filler, "selectstart", disabledListener ) ;

		}

		var paddingBar = this._ResizeBar ;

		var offset = this._GetIframeOffset() ;

		var tablePos = this._GetTablePosition( w, table ) ;

		var barHeight = table.offsetHeight ;

		var barTop = offset.y + tablePos.y ;

		// Do not let the resize bar intrude into the toolbar area.

		if ( tablePos.y < 0 )

		{

			barHeight += tablePos.y ;

			barTop -= tablePos.y ;

		}

		var bw = parseInt( table.border, 10 ) ;

		if ( isNaN( bw ) )

			bw = 0 ;

		var cs = parseInt( table.cellSpacing, 10 ) ;

		if ( isNaN( cs ) )

			cs = 0 ;

		var barWidth = Math.max( bw+100, cs+100 ) ;

		var paddingStyles =

		{

			'top'		: barTop + 'px',

			'height'	: barHeight + 'px',

			'width'		: barWidth + 'px',

			'left'		: ( offset.x + mouse.x + FCKTools.GetScrollPosition( w ).X - barWidth / 2 ) + 'px'

		} ;

		if ( FCKBrowserInfo.IsIE )

			paddingBar.filters.item("DXImageTransform.Microsoft.Alpha").opacity = 10 ;

		else

			paddingStyles.opacity = 0.1 ;

		FCKDomTools.SetElementStyles( paddingBar, paddingStyles ) ;

		var filler = paddingBar.getElementsByTagName( "img" )[0] ;

		FCKDomTools.SetElementStyles( filler,

			{

				width	: paddingBar.offsetWidth + 'px',

				height	: barHeight + 'px'

			} ) ;

		barWidth = Math.max( bw, cs, 3 ) ;

		var visibleBar = null ;

		if ( paddingBar.getElementsByTagName( "div" ).length < 1 )

		{

			visibleBar = this._doc.createElement( "div" ) ;

			this._avoidStyles( visibleBar );

			visibleBar.setAttribute('_fcktemp', true);

			paddingBar.appendChild( visibleBar ) ;

		}

		else

			visibleBar = paddingBar.getElementsByTagName( "div" )[0] ;

		FCKDomTools.SetElementStyles( visibleBar,

			{

				position		: 'absolute',

				backgroundColor	: 'blue',

				width			: barWidth + 'px',

				height			: barHeight + 'px',

				left			: '50px',

				top				: '0px'

			} ) ;

	},

	"_HideResizeBar" : function()

	{

		if ( this._ResizeBar )

			// IE bug: display : none does not hide the resize bar for some reason.

			// so set the position to somewhere invisible.

			FCKDomTools.SetElementStyles( this._ResizeBar,

				{

					top		: '-100000px',

					left	: '-100000px'

				} ) ;

	},

	"_GetIframeOffset" : function ()

	{

		return FCKTools.GetDocumentPosition( window, FCK.EditingArea.IFrame ) ;

	},

	"_GetTablePosition" : function ( w, table )

	{

		return FCKTools.GetWindowPosition( w, table ) ;

	},

	"_avoidStyles" : function( element )

	{

		FCKDomTools.SetElementStyles( element,

			{

				padding		: '0',

				backgroundImage	: 'none',

				border		: '0'

			} ) ;

	},

	"Reset" : function()

	{

		FCKDragTableHandler._LeftCell = FCKDragTableHandler._RightCell = FCKDragTableHandler._TableMap = null ;

	}

};

FCK.Events.AttachEvent( "OnMouseMove", FCKDragTableHandler.MouseMoveListener ) ;

FCK.Events.AttachEvent( "OnAfterSetHTML", FCKDragTableHandler.Reset ) ;