Ticket #9386: 9386_3.patch

File 9386_3.patch, 8.4 KB (added by Garry Yao, 7 years ago)
  • _source/plugins/selection/plugin.js

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    7272
    7373        function rangeRequiresFix( range )
    7474        {
    75                 function isInlineCt( node )
     75                function isTextCt( node, isAtEnd )
    7676                {
    77                         return node && node.type == CKEDITOR.NODE_ELEMENT
    78                                         && node.getName() in CKEDITOR.dtd.$removeEmpty;
     77                        if ( !node || node.type == CKEDITOR.NODE_TEXT )
     78                                return;
     79
     80                        var testRng = range.clone();
     81                        return testRng[ 'moveToElementEdit' + ( isAtEnd ? 'End' : 'Start' ) ]( node );
    7982                }
    8083
    81                 var start = range.startContainer,
    82                         offset = range.startOffset;
     84                var ct = range.startContainer;
    8385
    84                 if ( start.type == CKEDITOR.NODE_TEXT )
    85                         return false;
     86                var previous = range.getPreviousNode( isVisible, null, ct ),
     87                        next = range.getNextNode( isVisible, null, ct );
    8688
    87                 // 1. Empty inline element. <span>^</span>
    88                 // 2. Empty block. <p>^</p> (#7222)
    89                 // 3. Adjoin to inline element. <p><strong>text</strong>^</p>
    90                 return !CKEDITOR.tools.trim( start.getHtml() ) ? isInlineCt( start ) || start.isBlockBoundary()
    91                                 : isInlineCt( start.getChild( offset - 1 ) ) || isInlineCt( start.getChild( offset ) );
     89                // Any adjacent text container may absorb the cursor, e.g.
     90                // <p><strong>text</strong>^foo</p>
     91                // <p>foo^<strong>text</strong></p>
     92                // <div>^<p>foo</p></div>
     93                if ( isTextCt( previous ) || isTextCt( next, 1 ) )
     94                        return true;
     95
     96                // Empty block/inline element is also affected. <span>^</span>, <p>^</p> (#7222)
     97                if ( !( previous || next ) && !( ct.isBlockBoundary() && ct.getBogus() ) )
     98                        return true;
     99
     100                return false;
    92101        }
    93102
    94103        var selectAllCmd =
     
    17591768                        start.scrollIntoView();
    17601769                }
    17611770        };
    1762 })();
    17631771
    1764 ( function()
    1765 {
    17661772        var notWhitespaces = CKEDITOR.dom.walker.whitespaces( true ),
     1773                        isVisible = CKEDITOR.dom.walker.invisible( 1 );
    17671774                        fillerTextRegex = /\ufeff|\u00a0/,
    17681775                        nonCells = { table:1,tbody:1,tr:1 };
    17691776
  • _source/core/dom/walker.js

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    413413        {
    414414                return function( node )
    415415                {
    416                         var isWhitespace = node && ( node.type == CKEDITOR.NODE_TEXT )
    417                                                         && !CKEDITOR.tools.trim( node.getText() );
     416                        var isWhitespace;
     417                        if ( node && node.type == CKEDITOR.NODE_TEXT )
     418                        {
     419                                // whitespace, as well as the text cursor filler node we used in Webkit. (#9384)
     420                                isWhitespace = !CKEDITOR.tools.trim( node.getText() ) ||
     421                                        CKEDITOR.env.webkit && node.getText() == '\u200b';
     422                        }
     423
    418424                        return !! ( isReject ^ isWhitespace );
    419425                };
    420426        };
     
    428434                var whitespace = CKEDITOR.dom.walker.whitespaces();
    429435                return function( node )
    430436                {
    431                         // Nodes that take no spaces in wysiwyg:
    432                         // 1. White-spaces but not including NBSP;
    433                         // 2. Empty inline elements, e.g. <b></b> we're checking here
    434                         // 'offsetHeight' instead of 'offsetWidth' for properly excluding
    435                         // all sorts of empty paragraph, e.g. <br />.
    436                         var isInvisible = whitespace( node ) || node.is && !node.$.offsetHeight;
    437                         return !! ( isReject ^ isInvisible );
     437                        var invisible;
     438
     439                        if ( whitespace( node ) )
     440                                invisible = 1;
     441                        else
     442                        {
     443                                // Visibility should be checked on element.
     444                                if ( node.type == CKEDITOR.NODE_TEXT )
     445                                        node = node.getParent();
     446
     447                                // Nodes that take no spaces in wysiwyg:
     448                                // 1. White-spaces but not including NBSP;
     449                                // 2. Empty inline elements, e.g. <b></b> we're checking here
     450                                // 'offsetHeight' instead of 'offsetWidth' for properly excluding
     451                                // all sorts of empty paragraph, e.g. <br />.
     452                                invisible = !node.$.offsetHeight;
     453                        }
     454
     455                        return !! ( isReject ^ invisible );
    438456                };
    439457        };
    440458
  • _source/core/dom/range.js

    IDEA additional info:
    Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
    <+>UTF-8
     
    347347
    348348        // Creates the appropriate node evaluator for the dom walker used inside
    349349        // check(Start|End)OfBlock.
    350         function getCheckStartEndBlockEvalFunction( isStart )
     350        function getCheckStartEndBlockEvalFunction()
    351351        {
    352352                var skipBogus = false,
     353                        whitespaces = CKEDITOR.dom.walker.whitespaces(),
    353354                        bookmarkEvaluator = CKEDITOR.dom.walker.bookmark( true ),
    354355                        isBogus = CKEDITOR.dom.walker.bogus();
    355356
    356357                return function( node )
    357358                {
    358                         // First ignore bookmark nodes.
    359                         if ( bookmarkEvaluator( node ) )
     359                        // First skip empty nodes.
     360                        if ( bookmarkEvaluator( node ) || whitespaces( node ) )
    360361                                return true;
    361362
    362363                        // Skip the bogus node at the end of block.
     
    388389        // text node and non-empty elements unless it's being bookmark text.
    389390        function elementBoundaryEval( checkStart )
    390391        {
     392                var whitespaces = CKEDITOR.dom.walker.whitespaces(),
     393                        bookmark = CKEDITOR.dom.walker.bookmark( 1 );
     394
    391395                return function( node )
    392396                {
     397                        // First skip empty nodes.
     398                        if ( bookmark( node ) || whitespaces( node ) )
     399                                return true;
     400
    393401                        // Tolerant bogus br when checking at the end of block.
    394402                        // Reject any text node unless it's being bookmark
    395403                        // OR it's spaces.
    396404                        // Reject any element unless it's being invisible empty. (#3883)
    397405                        return !checkStart && isBogus( node ) ||
    398                                         ( node.type == CKEDITOR.NODE_TEXT ?
    399                                            !CKEDITOR.tools.trim( node.getText() ) || !!node.getParent().data( 'cke-bookmark' )
    400                                            : node.getName() in CKEDITOR.dtd.$removeEmpty );
     406                                                 node.type == CKEDITOR.NODE_ELEMENT &&
     407                                                 node.getName() in CKEDITOR.dtd.$removeEmpty;
    401408                };
    402409        }
    403410
     
    18411848                        walkerRange.setStartAt( path.block || path.blockLimit, CKEDITOR.POSITION_AFTER_START );
    18421849
    18431850                        var walker = new CKEDITOR.dom.walker( walkerRange );
    1844                         walker.evaluator = getCheckStartEndBlockEvalFunction( true );
     1851                        walker.evaluator = getCheckStartEndBlockEvalFunction();
    18451852
    18461853                        return walker.checkBackward();
    18471854                },
     
    18701877                        walkerRange.setEndAt( path.block || path.blockLimit, CKEDITOR.POSITION_BEFORE_END );
    18711878
    18721879                        var walker = new CKEDITOR.dom.walker( walkerRange );
    1873                         walker.evaluator = getCheckStartEndBlockEvalFunction( false );
     1880                        walker.evaluator = getCheckStartEndBlockEvalFunction();
    18741881
    18751882                        return walker.checkForward();
    18761883                },
    18771884
    18781885                /**
    1879                  * Check if elements at which the range boundaries anchor are read-only,
    1880                  * with respect to "contenteditable" attribute.
     1886                 * Traverse with {@link CKEDITOR.dom.walker} to retrieve the previous element before the range start.
     1887                 * @param {Function} evaluator Function used as the walker's evaluator.
     1888                 * @param {Function} [guard] Function used as the walker's guard.
     1889                 * @param {CKEDITOR.dom.element} [boundary] A range ancestor element in which the traversal is limited,
     1890                 * default to the root editable if not defined.
     1891                 *
     1892                 * @return {CKEDITOR.dom.element|null} The returned node from the traversal.
    18811893                 */
     1894                getPreviousNode : function( evaluator, guard, boundary ) {
     1895
     1896                        var walkerRange = this.clone();
     1897                        walkerRange.collapse( 1 );
     1898                        walkerRange.setStartAt( boundary || this.document.getBody(), CKEDITOR.POSITION_AFTER_START );
     1899
     1900                        var walker = new CKEDITOR.dom.walker( walkerRange );
     1901                        walker.evaluator = evaluator;
     1902                        walker.guard = guard;
     1903                        return walker.previous();
     1904                },
     1905
     1906                /**
     1907                 * Traverse with {@link CKEDITOR.dom.walker} to retrieve the next element before the range start.
     1908                 * @param {Function} evaluator Function used as the walker's evaluator.
     1909                 * @param {Function} [guard] Function used as the walker's guard.
     1910                 * @param {CKEDITOR.dom.element} [boundary] A range ancestor element in which the traversal is limited,
     1911                 * default to the root editable if not defined.
     1912                 *
     1913                 * @return {CKEDITOR.dom.element|null} The returned node from the traversal.
     1914                 */
     1915                getNextNode: function( evaluator, guard, boundary )
     1916                {
     1917                        var walkerRange = this.clone();
     1918                        walkerRange.collapse();
     1919                        walkerRange.setEndAt( boundary || this.document.getBody(), CKEDITOR.POSITION_BEFORE_END );
     1920
     1921                        var walker = new CKEDITOR.dom.walker( walkerRange );
     1922                        walker.evaluator = evaluator;
     1923                        walker.guard = guard;
     1924                        return walker.next();
     1925                },
     1926
    18821927                checkReadOnly : ( function()
    18831928                {
    18841929                        function checkNodesEditable( node, anotherEnd )
© 2003 – 2019 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy