Subversion Repositories Applications.papyrus

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