Ticket #2656: 2656.patch

commandclasses/fcktablecommand.js

@@ -81 +81 @@
         {
                 switch ( this.Name )
                 {
+                        case 'TableInsertRowAfter' :
+                                return FCKTableHandler.checkFlatRow( false ) ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+                        case 'TableInsertRowBefore' :
+                                return FCKTableHandler.checkFlatRow( true ) ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+                        case 'TableInsertColumnAfter' :
+                                return FCKTableHandler.checkFlatColumn( false ) ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
+                        case 'TableInsertColumnBefore' :
+                                return FCKTableHandler.checkFlatColumn( true ) ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ;
                         case 'TableHorizontalSplitCell' :
                         case 'TableVerticalSplitCell' :
                                 if ( FCKTableHandler.GetSelectedCells().length == 1 )

internals/fck_contextmenu.js

@@ -93 +93 @@
 
                                         menu.AddSeparator() ;
                                         oItem = menu.AddItem( 'Row'                     , FCKLang.RowCM ) ;
-                                        oItem.AddItem( 'TableInsertRowBefore'           , FCKLang.InsertRowBefore, 70 ) ;
-                                        oItem.AddItem( 'TableInsertRowAfter'            , FCKLang.InsertRowAfter, 62 ) ;
+                                        oItem.AddItem( 'TableInsertRowBefore'           , FCKLang.InsertRowBefore, 70,
+                                                FCKCommands.GetCommand( 'TableInsertRowBefore' ).GetState() == FCK_TRISTATE_DISABLED) ;
+                                        oItem.AddItem( 'TableInsertRowAfter'            , FCKLang.InsertRowAfter, 62,
+                                                FCKCommands.GetCommand( 'TableInsertRowAfter' ).GetState() == FCK_TRISTATE_DISABLED) ;
                                         oItem.AddItem( 'TableDeleteRows'        , FCKLang.DeleteRows, 63 ) ;
 
                                         menu.AddSeparator() ;
                                         oItem = menu.AddItem( 'Column'          , FCKLang.ColumnCM ) ;
-                                        oItem.AddItem( 'TableInsertColumnBefore', FCKLang.InsertColumnBefore, 71 ) ;
-                                        oItem.AddItem( 'TableInsertColumnAfter' , FCKLang.InsertColumnAfter, 64 ) ;
+                                        oItem.AddItem( 'TableInsertColumnBefore', FCKLang.InsertColumnBefore, 71,
+                                                FCKCommands.GetCommand( 'TableInsertColumnBefore' ).GetState() == FCK_TRISTATE_DISABLED) ;
+                                        oItem.AddItem( 'TableInsertColumnAfter' , FCKLang.InsertColumnAfter, 64,
+                                                FCKCommands.GetCommand( 'TableInsertColumnAfter' ).GetState() == FCK_TRISTATE_DISABLED) ;
                                         oItem.AddItem( 'TableDeleteColumns'     , FCKLang.DeleteColumns, 65 ) ;
                                 }
 

internals/fcktablehandler.js

@@ -25 +25 @@
 
 FCKTableHandler.InsertRow = function( insertBefore )
 {
-        // Get the row where the selection is placed in.
-        var oRow = FCKSelection.MoveToAncestorNode( 'TR' ) ;
-        if ( !oRow ) return ;
+        // Get all selected cells.
+        var cells = this.GetSelectedCells() ;
+        if ( cells.length < 1 )
+                return ;
 
-        // Create a clone of the row.
-        var oNewRow = oRow.cloneNode( true ) ;
+        var refCell = cells[0] ;
+        var rowSpan = isNaN( refCell.rowSpan ) ? 1 : refCell.rowSpan ;
+        var rowIdx = refCell.parentNode.rowIndex ;
+        if( !insertBefore && rowSpan > 1)
+                rowIdx = rowIdx + rowSpan - 1 ;
+        var oRow = refCell.parentNode.parentNode.parentNode.rows[rowIdx] ;
 
-        // Insert the new row (copy) before of it.
-        oRow.parentNode.insertBefore( oNewRow, oRow ) ;
+        // Count the number of columns of the table via the tablemap.
+        var tableMap = this._CreateTableMap( refCell ) ;
+        var maxCol = 0 ;
+        for ( var i = 0 ; i < tableMap.length ; i++ )
+        {
+                for ( var j = 0 ; j < tableMap[i].length ; j++ )
+                {
+                        if ( j > maxCol )
+                                maxCol = j ;
+                }
+        }
 
-        // Clean one of the rows to produce the illusion of inserting an empty row before or after.
-        FCKTableHandler.ClearRow( insertBefore ? oNewRow : oRow ) ;
+        // Build the new row.
+        var oNewRow = FCK.EditorDocument.createElement( 'tr' ) ;
+        for ( i = 0; i <= maxCol; i++ )
+        {
+                var newCell = FCK.EditorDocument.createElement( refCell.nodeName ) ;
+                if ( FCKBrowserInfo.IsGeckoLike )
+                        FCKTools.AppendBogusBr( newCell ) ;
+
+                oNewRow.appendChild( newCell ) ;
+        }
+
+        // Insert the new row.
+        if( insertBefore )
+                oRow.parentNode.insertBefore( oNewRow, oRow ) ;
+        else
+                FCKDomTools.InsertAfterNode ( oRow, oNewRow ) ;
 }
 
+FCKTableHandler.checkFlatRow = function( insertBefore )
+{
+        // Get all selected cells.
+        var cells = this.GetSelectedCells() ;
+        if ( cells.length < 1 )
+                return ;
+
+        var refCell = cells[0] ;
+        var tableMap = this._CreateTableMap( refCell ) ;
+        var rowStep = ( insertBefore ) ? -1 : 1 ;
+
+        var rowIdx = refCell.parentNode.rowIndex ;
+        var rowSpan = isNaN( refCell.rowSpan ) ? 1 : refCell.rowSpan ;
+        if( !insertBefore && rowSpan > 1)
+                rowIdx = rowIdx + rowSpan - 1 ;
+
+        for ( var i = 0 ; i < tableMap.length ; i++ )
+        {
+                for ( var j = 0; j < tableMap[i].length ; j++ )
+                {
+                        if ( tableMap[rowIdx+rowStep] && tableMap[rowIdx+rowStep][j] == tableMap[rowIdx][j] )
+                                return false ;
+                }
+        }
+        return true ;
+}
+
 FCKTableHandler.DeleteRows = function( row )
 {
         // If no row has been passed as a parameter,
@@ -103 +158 @@
 
 FCKTableHandler.InsertColumn = function( insertBefore )
 {
-        // Get the cell where the selection is placed in.
-        var oCell = null ;
-        var nodes = this.GetSelectedCells() ;
-
-        if ( nodes && nodes.length )
-                oCell = nodes[ insertBefore ? 0 : ( nodes.length - 1 ) ] ;
-
-        if ( ! oCell )
+        // Get all selected cells.
+        var cells = this.GetSelectedCells() ;
+        if ( cells.length < 1 )
                 return ;
 
-        // Get the cell's table.
-        var oTable = FCKTools.GetElementAscensor( oCell, 'TABLE' ) ;
+        var oCell = cells[0] ;
+        var tableMap = this._CreateTableMap( oCell ) ;
+        var rowIdx = oCell.parentNode.rowIndex ;
+        var colIdx = FCKTableHandler._GetCellIndexSpan( tableMap, rowIdx, oCell ) ;
 
-        var iIndex = oCell.cellIndex ;
+        var colSpan = isNaN( oCell.colSpan ) ? 1 : oCell.colSpan ;
+        if( !insertBefore && colSpan > 1 )
+                colIdx = colIdx + colSpan - 1 ;
 
-        // Loop through all rows available in the table.
-        for ( var i = 0 ; i < oTable.rows.length ; i++ )
+        // Build newTableMap.
+        var newTableMap = new Array() ;
+        for ( var i = 0 ; i < tableMap.length ; i++ )
         {
-                // Get the row.
-                var oRow = oTable.rows[i] ;
+                var newRow = new Array() ;
+                for ( var j = 0; j < tableMap[i].length ; j++ )
+                {
+                        var newCell = FCK.EditorDocument.createElement( tableMap[i][j].nodeName ) ;
+                        if ( FCKBrowserInfo.IsGeckoLike )
+                                FCKTools.AppendBogusBr( newCell ) ;
 
-                // If the row doesn't have enough cells, ignore it.
-                if ( oRow.cells.length < ( iIndex + 1 ) )
-                        continue ;
+                        if( insertBefore && j == colIdx )
+                                newRow.push( newCell ) ;
 
-                oCell = oRow.cells[iIndex].cloneNode(false) ;
+                        newRow.push( tableMap[i][j] ) ;
 
-                if ( FCKBrowserInfo.IsGeckoLike )
-                        FCKTools.AppendBogusBr( oCell ) ;
+                        if( !insertBefore && j == colIdx )
+                                newRow.push( newCell ) ;
+                }
+                newTableMap.push( newRow ) ;
+        }
 
-                // Get back the currently selected cell.
-                var oBaseCell = oRow.cells[iIndex] ;
+        this._InstallTableMap( newTableMap, oCell.parentNode.parentNode.parentNode ) ;
+}
 
-                oRow.insertBefore( oCell, ( insertBefore ? oBaseCell : oBaseCell.nextSibling ) ) ;
+FCKTableHandler.checkFlatColumn = function( insertBefore )
+{
+        // Get all selected cells.
+        var cells = this.GetSelectedCells() ;
+        if ( cells.length < 1 )
+                return ;
+
+        var refCell = cells[0] ;
+        var tableMap = this._CreateTableMap( refCell ) ;
+        var colStep = ( insertBefore ) ? -1 : 1 ;
+        var rowIdx = refCell.parentNode.rowIndex ;
+
+        var colIdx = this._GetCellIndexSpan( tableMap, rowIdx, cells[0] ) ;
+        var colSpan = isNaN( refCell.colSpan ) ? 1 : refCell.colSpan ;
+        if( !insertBefore && colSpan > 1)
+                colIdx = colIdx + colSpan - 1 ;
+
+        for ( var i = 0 ; i < tableMap.length ; i++ )
+        {
+                for ( var j = 0; j < tableMap[i].length ; j++ )
+                {
+                        if ( tableMap[i][colIdx+colStep] && tableMap[i][colIdx+colStep] == tableMap[i][colIdx] )
+                                return false ;
+                }
         }
+        return true ;
 }
 
 FCKTableHandler.DeleteColumns = function( oCell )