Changeset 441


Ignore:
Timestamp:
07/12/2007 05:18:48 PM (8 years ago)
Author:
martinkou
Message:

Removed mjk's table drag resize code from core.
Created dragresizetable plugin.
Added resize cell finding logic to dragresizetableplugin.

Location:
FCKeditor/branches/developers/martinkou
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • FCKeditor/branches/developers/martinkou/editor/_source/classes/fckspecialcombo.js

    r439 r441  
    177177
    178178        this._OuterTable.className = isEnabled ? '' : 'SC_FieldDisabled' ;
    179 }
    180 
    181 FCKSpecialCombo.prototype.ClearItems = function ()
    182 {
    183         if ( this.Items )
    184         {
    185                 for ( var key in this.Items )
    186                         this.Items[key] = null ;
    187         }
    188         while (this._ItemsHolderEl.firstChild)
    189                 this._ItemsHolderEl.removeChild(this._ItemsHolderEl.firstChild);
    190179}
    191180
  • FCKeditor/branches/developers/martinkou/editor/_source/internals/fckselection.js

    r439 r441  
    2424var FCKSelection = FCK.Selection = new Object() ;
    2525
    26 //Return the nearest ancestor to the current position of the caret.
    27 FCKSelection.GetCaretAncestor = function(strTag)
    28 {
    29         var e = FCKSelection.GetParentElement();
    30         var tn = e ?    FCKTools.GetElementAscensor(e,strTag) :
    31                                         FCKSelection.MoveToAncestorNode(strTag);
    32         return tn;
    33 }
    34 
    35 FCKSelection.SelectedText = function()
    36 {
    37         return FCKTools.HTMLToText( this.SelectedHTML() );
    38 }
  • FCKeditor/branches/developers/martinkou/editor/_source/internals/fcktablehandler.js

    r439 r441  
    415415}
    416416
    417 //Returns TRUE if any cell has width set
    418 FCKTableHandler.HasCellWidths = function( table )
    419 {
    420         for ( var r = 0; r < table.rows.length; r++ )
    421         {
    422                 for ( var c = 0; c < table.rows[r].cells.length; c++ )
    423                 {
    424                         if ( table.rows[r].cells[c].width ) return true;
    425                 }
    426         }
    427         return false;
    428 }
    429 
    430 //Clears all cell widths/heights ( letting the browser size everything )
    431 FCKTableHandler.ClearCellWidths = function( table )
    432 {
    433         for ( var r = 0; r < table.rows.length; r++ )
    434         {
    435                 for ( var c = 0; c < table.rows[r].cells.length; c++ )
    436                 {
    437                         table.rows[r].cells[c].width = "";
    438                         table.rows[r].cells[c].height = "";
    439                         table.rows[r].cells[c].removeAttribute( "WIDTH" );
    440                         table.rows[r].cells[c].removeAttribute( "HEIGHT" );
    441                 }
    442         }
    443 }
    444 
    445 //Cleanup table widths. If bPercent, recalculates table widths in %. If bClear,
    446 //moves all table widths as early as possible
    447 
    448 FCKTableHandler.CleanupTableWidths = function( table, bPercent, bClear, aMapIn )
    449 {
    450         var aMap = aMapIn ? aMapIn : this._CreateTableMap( table ) ;
    451         var nCols = aMap[0].length;
    452         var nRows = aMap.length;
    453         var nTotalWidth = 0;
    454         var aSizeCells = new Array();
    455         var aSizes = new Array();
    456         //work the table column-by-column
    457         for ( var nCol = 0; nCol < nCols; nCol++ )
    458         {
    459                 var nMax = 0;
    460                 var oCell = null;
    461                 //walk the rows for a specific column -- find the topmost non-colspan'd item
    462                 //and the maximum pixel width ( according to the browser )
    463                 for ( var nRow = 0; nRow < nRows; nRow++ )
    464                 {
    465                         if ( aMap[nRow][nCol].colSpan > 1 ) continue;
    466                         //use topmost non-colspan'd cell to put the width in
    467                         if ( !oCell ) oCell = aMap[nRow][nCol];
    468                         if ( aMap[nRow][nCol].offsetWidth > nMax ) nMax = aMap[nRow][nCol].offsetWidth;
    469                 }
    470                 aSizes[nCol] = nMax;
    471                 nTotalWidth += nMax;
    472                 aSizeCells[nCol] = oCell;
    473         }
    474         //if we were asked for percentage width, go through and convert the sizes to %. note
    475         //that we do this based on the calculated width of all the cells; this is more
    476         //reliable because offsetWidth, et al., includes table borders, padding, etc.
    477         for ( var nCol = 0; nCol < aSizeCells.length; nCol++ )
    478         {
    479                 if ( bPercent )
    480                 {
    481                         var nWidth = Math.round( 100 * (aSizeCells[nCol].offsetWidth/nTotalWidth ));
    482                         if ( nWidth == 0 ) nWidth = 1;
    483                         strWidth =  nWidth + "%";
    484                 }
    485                 else
    486                 {
    487                         strWidth =  aSizes[nCol];
    488                 }
    489 
    490                 //set all width attributes
    491                 for ( var nRow = 0; nRow < nRows; nRow++ )
    492                 {
    493                         if ( aMap[nRow][nCol].colSpan == 1 )
    494                         {
    495                                 aMap[nRow][nCol].width = bClear ? '' : strWidth;
    496                                 if ( bClear ) aMap[nRow][nCol].removeAttribute( "width" );
    497                                 aSizeCells[nCol].width = strWidth;
    498                         }
    499                 }
    500         }
    501 }
    502 
    503 // Move the cursor into the next ( or previous ) cell
    504 FCKTableHandler.MoveToNextCell = function( bRev )
    505 {
    506         var aCells = FCKTableHandler.GetSelectedCells();
    507         if ( aCells.length == 0 ) return;
    508         var oCell = aCells[0];
    509         var oNextCell = bRev ? oCell.previousSibling: oCell.nextSibling;
    510         if ( !oNextCell )
    511         {
    512                 var oNext;
    513                 var oRow = FCKTools.GetElementAscensor( oCell,"TR" );
    514                 if ( bRev )
    515                 {
    516                         if ( !(oNext = oRow.previousSibling )) return;
    517                         oNextCell=oNext.cells[oNext.cells.length - 1];
    518                 }
    519                 else
    520                 {
    521                         if ( !(oNext = oRow.nextSibling )) return;
    522                         oNextCell=oNext.cells[0];
    523                 }
    524         }
    525         FCKSelection.SelectNode( oNextCell );
    526         FCKSelection.Collapse();
    527 }
    528 //////////////////////////////////////////////////////////////////
    529 // Table Sizer
    530 //
    531 
    532 
    533 // Returns the closest sizeable cell to point (or the left of the specified point
    534 // if between cells). Generally, this will be a heading cell (i.e. a cell in
    535 // the first row). If *all* the candidate cells are colspan'd (heaven forbid),
    536 // don't allow sizing. x and y are in client coordinates
    537 
    538 FCKTableHandler.SizableCellFromPoint = function( table, ncx, ncy )
    539 {
    540         var aRows = table.rows ;
    541         var x = ncx - this._CalcPosition( table )[0];
    542         for ( var i = 0 ; i < aRows.length ; i++  )
    543         {
    544                 for ( var j = 0; j < aRows[i].cells.length - 1; j++ )
    545                 {
    546                         if ( aRows[i].cells[j + 1].offsetLeft > x )
    547                         {
    548                                 if ( aRows[i].cells[j].colSpan < 2 )
    549                                 {
    550                                         return aRows[i].cells[j];
    551                                 }
    552                                 else
    553                                 {
    554                                         break;
    555                                 }
    556                         }       
    557                 }
    558         }
    559         return null;
    560 }
    561 
    562 // Creates the table resize bar. If a table resize bar is present, uses it. You
    563 // must explicitly destroy the table resize bar with DestroyResizeBar after use.
    564 FCKTableHandler.CreateResizeBar = function()
    565 {
    566         if ( this.ResizeBar ) return this.ResizeBar;
    567         var oBar;       
    568         oBar = FCK.EditorDocument.createElement( "SPAN" );
    569 
    570         // setup the bar
    571         oBar.id = '__FCKResizeBar';
    572         oBar.style.position = "absolute";
    573         oBar.style.top = "0px";
    574         oBar.style.left = "0px";
    575         oBar.style.height = "0px";
    576         oBar.style.width = "2px";
    577         oBar.style.borderLeft = "1px solid #0033FF";
    578         oBar.style.display = "none";
    579         oBar.style.cursor = "e-resize";
    580 
    581         FCK.EditorDocument.body.appendChild( oBar );
    582         this.ResizeBar = oBar;
    583         return oBar;
    584 }
    585 
    586 // Destroys the table resize bar
    587 FCKTableHandler.DestroyResizeBar = function()
    588 {
    589         if ( !this.ResizeBar ) return;
    590         this.ResizeBar.parentNode.removeChild( FCKTableHandler.ResizeBar );
    591         this.ResizeBar = null;
    592 }
    593 
    594 // Figures out whether we want to size or let the browser do its thing. We can
    595 // size if the table is the target and we're between cells, OR if we're on
    596 // a table cell and on the far right edge of the cell within 3px of the edge
    597 // ( allows us to easily size tables with thin borders )
    598 
    599 FCKTableHandler.CanSizeHere = function( ev, cell, tbl )
    600 {
    601         var elem = ev.srcElement || ev.originalTarget;
    602         var aCellLoc = this._CalcPosition( cell );
    603         var aTableLoc = this._CalcPosition( tbl );
    604         //in the td client area, but not on the edge
    605         if ( elem != tbl ) return ( (aCellLoc[0] + cell.offsetWidth - ev.clientX ) < 3);
    606         //on the table edge
    607         if ( (aTableLoc[0] + tbl.offsetWidth - ev.clientX ) < 3 ||
    608                         ( aTableLoc[0] - ev.clientX ) < 3 ||
    609                         ( aTableLoc[1] + tbl.offsetHeight - ev.clientY < 3 ) ||
    610                         ( aTableLoc[1] - ev.clientY < 3 )) return false;
    611         return true;
    612 }
    613 
    614 
    615 // Sets up table sizing
    616 FCKTableHandler.StartTableSizing = function( ev, cell, tbl )
    617 {
    618         if ( !cell ) return null;
    619         this.tableMap = this._CreateTableMap( tbl ) ;
    620         var aCellLoc = this._GetCellLocation( this.tableMap, cell );                            //returns [row,col]
    621         if ( !aCellLoc ) return null;
    622         //we're in the last column, so we can't size
    623         if ( aCellLoc[1] == this.tableMap[aCellLoc[0]].length - 1 ) return null;
    624         var nTarget = aCellLoc[1] + 1;
    625         this.adjacentCell = null;
    626         for ( var i=0; i < this.tableMap.length; i++ )
    627         {
    628                 if ( this.tableMap[i][nTarget].colSpan < 2 )
    629                 {
    630                         this.adjacentCell = this.tableMap[i][nTarget];
    631                         break;
    632                 }
    633         }
    634         if ( this.adjacentCell == null ) return null;   //can't size, no adjacent col
    635         this.targetCell = cell;
    636         //ok. we have everything we need. off we go.
    637 
    638         //create the resize bar
    639         this.pixWidths = !( this.targetCell.width.search('%' ) == -1 || !this.targetCell.width);
    640         var oVBar = this.CreateResizeBar();
    641         //oVBar.style.left = FCK.EditorDocument.body.scrollLeft + this._CalcPosition( cell ) + cell.offsetWidth;
    642         //this.origPos = FCK.EditorDocument.body.scrollLeft + ev.clientX;
    643         this.origPos = FCK.EditorDocument.body.scrollLeft + this._CalcPosition( cell )[0] + cell.offsetWidth;
    644         oVBar.style.left = this.origPos;
    645         oVBar.style.cursor = "e-resize";
    646         oVBar.setAttribute( "UNSELECTABLE","on" );
    647         tbl.setAttribute( "UNSELECTABLE","on" );
    648         this.sizeOffset = ev.clientX - this.origPos;
    649         //minimum size is always the left edge of the cell + some safety margin.
    650         //max size is always the right edge of the next cell - some safety margin
    651         this.minSize = FCK.EditorDocument.body.scrollLeft + this._CalcPosition( cell )[0] + 10;
    652         this.maxSize = FCK.EditorDocument.body.scrollLeft + this._CalcPosition( this.adjacentCell )[0] + this.adjacentCell.offsetWidth - 10;
    653         oVBar.style.top = this._CalcPosition( tbl )[1];
    654         oVBar.style.height = tbl.clientHeight + ( tbl.border*2 );
    655         oVBar.style.display = "inline";
    656         this.CleanupTableWidths( tbl,false, true,this.tableMap );
    657         return true;
    658 }
    659 
    660 FCKTableHandler.FinishTableSizing = function()
    661 {
    662         var tbl = FCKTools.GetElementAscensor( this.targetCell,"TABLE" );
    663         var nTargetDiff = this.ResizeBar.offsetLeft - this.origPos;
    664         //widths are in pixels after StartTableSizing, so this is safe
    665         tbl.style.cursor = '';
    666         if ( tbl.runtimeStyle ) tbl.runtimeStyle.cursor = '';
    667         this.targetCell.width = parseInt( this.targetCell.width ) + nTargetDiff;
    668         this.adjacentCell.width = parseInt( this.adjacentCell.width ) - nTargetDiff;
    669         this.DestroyResizeBar();
    670         this.CleanupTableWidths( tbl,this.pixWidths,true,this.tableMap );
    671         this.targetCell = null;
    672         this.origPos = null;
    673         tbl.removeAttribute( "UNSELECTABLE" );
    674         if ( FCKBrowserInfo.IsGecko  ) tbl.style.MozUserSelect = "";
    675 }
    676 
    677 // Sizes the table to the given mouse position
    678 FCKTableHandler.SizeTo = function( x )
    679 {
    680         var nPos = x - this.sizeOffset;
    681         if ( nPos > this.maxSize ) nPos = this.maxSize;
    682         if ( nPos < this.minSize ) nPos = this.minSize;
    683         //runtimeStyle is way faster under IE
    684         if ( this.ResizeBar.runtimeStyle )
    685                 this.ResizeBar.runtimeStyle.left = nPos;
    686         else
    687                 this.ResizeBar.style.left = nPos;
    688         if ( FCKBrowserInfo.IsIE && FCK.EditorDocument.selection.type != 'None' )
    689                 FCK.EditorDocument.selection.collapse();
    690 }
    691 
    692 // returns TRUE if we are actively sizing a table
    693 FCKTableHandler.IsTableSizing = function()
    694 {
    695         return ( this.targetCell != null );
    696 }
    697 
    698 // figure out where ( with respect to the edge of the parent ) a given table/cell is
    699 FCKTableHandler._CalcPosition = function( ob )
    700 {
    701         var oParent=ob;
    702         var nY = 0;
    703         var nX = 0;
    704         while ( oParent && oParent.tagName != "BODY" )
    705         {
    706                 nX += oParent.offsetLeft;
    707                 nY += oParent.offsetTop;
    708                 oParent = oParent.offsetParent;
    709         }
    710         return [nX,nY];
    711 }
    712 
    713 FCKTableHandler.tbl_MouseDown = function ( FCK, e )
    714 {
    715         var elem = e.srcElement || e.originalTarget;
    716         var strTag = elem ? elem.tagName.toUpperCase() : null;
    717         //find the table we're part of, if we are
    718         if ( elem && (strTag == 'TABLE' || strTag == 'TD' || strTag == 'TH' ) )
    719         {
    720                 FCKTableHandler.targetCell = null;
    721                 var oTable = FCKTools.GetElementAscensor( elem, "TABLE" );
    722                 //figure out if there's a cell we can size
    723                 var oCell = FCKTableHandler.SizableCellFromPoint( oTable, e.clientX, e.clientY );
    724                 if ( !oCell ) return true;
    725                 if ( FCKTableHandler.CanSizeHere( e,oCell,oTable ) )
    726                 {
    727                         if ( FCKTableHandler.StartTableSizing( e,oCell, oTable ) )
    728                         {
    729                                 if ( oTable.runtimeStyle ) oTable.runtimeStyle.cursor = "e-resize";
    730                                 if ( FCKBrowserInfo.IsGecko  ) oTable.style.MozUserSelect = "none";
    731                                 e.cancelBubble  = true ;
    732                                 e.returnValue   = false ;
    733                                 return false;
    734                         }
    735                 }
    736         }
    737         return true;
    738 }
    739 
    740 FCKTableHandler.tbl_MouseUp = function ( FCK, e )
    741 {
    742         if ( FCKTableHandler.IsTableSizing( )) FCKTableHandler.FinishTableSizing();
    743 }
    744 
    745 FCKTableHandler.tbl_MouseMove = function ( FCK, e )
    746 {
    747         var elem = e.srcElement || e.originalTarget;
    748         if ( FCKTableHandler.IsTableSizing() )
    749         {
    750                 FCKTableHandler.SizeTo( e.clientX );
    751                 e.cancelBubble  = true ;
    752                 e.returnValue   = false ;
    753                 return false;
    754         }
    755 
    756         if ( elem.tagName.toUpperCase() == 'TABLE' )
    757         {
    758                 //let the browser handle global sizing and move if the user is on
    759                 //the RH edge of a table
    760                 if ( elem.clientWidth - e.offsetX < 3 ||
    761                                 elem.clientHeight - e.offsetY < 3 ||
    762                                 e.offsetX < 2 || e.offsetY < 2 )
    763                 {
    764                         elem.style.cursor = "";
    765                         return true;
    766                 }
    767                 //block browser sizing -- we're going to do it ourselves, thanks
    768                 if ( elem.runtimeStyle ) elem.runtimeStyle.cursor = "e-resize";
    769                 e.cancelBubble  = true ;
    770                 e.returnValue   = false ;
    771                 return false;
    772         }
    773         else if ( elem.tagName.toUpperCase() == 'TD' )
    774         {
    775                 var tbl = FCKTools.GetElementAscensor( elem, "TABLE" );
    776                 if ( e.offsetX >= (elem.offsetWidth - 4 ))
    777                 {
    778                         e.cancelBubble  = true ;
    779                         e.returnValue   = false ;
    780                         return false;
    781                 }
    782         }
    783         return true;
    784 }
    785 
    786 FCK.Events.AttachEvent( "OnMouseMove", FCKTableHandler.tbl_MouseMove );
    787 FCK.Events.AttachEvent( "OnMouseDown", FCKTableHandler.tbl_MouseDown );
    788 FCK.Events.AttachEvent( "OnMouseUp", FCKTableHandler.tbl_MouseUp );
    789 
    790417FCKTableHandler.ClearRow = function( tr )
    791418{
  • FCKeditor/branches/developers/martinkou/editor/_source/internals/fcktools.js

    r439 r441  
    9494                return '' ;
    9595
    96 }
    97 
    98 //convert text to Proper Case
    99 FCKTools.ProperCase = function( text )
    100 {
    101         var strPC = text.toLowerCase();
    102         return strPC.replace(/(\S)(\S*\s*)/g,
    103                                                 function(str,p1,p2)
    104                                                         {return p1.toUpperCase()+p2});
    105 }
    106 
    107 FCKTools.HTMLToText = function( st )
    108 {
    109         if ( !st )
    110                 return null;
    111                
    112         st = st.replace(/<([^>]*?)>/g,'');
    113         st = st.replace(/&nbsp;/gi,' ');
    114         return st;
    115         text = text.replace( /&/g, '&amp;' ) ;
    116         text = text.replace( /</g, '&lt;' ) ;
    117         text = text.replace( />/g, '&gt;' ) ;
    118 
    119         return text ;
    12096}
    12197
  • FCKeditor/branches/developers/martinkou/fckconfig.js

    r432 r441  
    4949
    5050// FCKConfig.Plugins.Add( 'autogrow' ) ;
     51FCKConfig.Plugins.Add( 'dragresizetable' );
    5152FCKConfig.AutoGrowMax = 400 ;
    5253
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy