Ticket #2885: 2885_9.patch

File 2885_9.patch, 24.0 KB (added by Martin Kou, 9 years ago)
  • _source/lang/en.js

     
    549549                tag_div : 'Normal (DIV)'
    550550        },
    551551
     552        div :
     553        {
     554                title                           : 'Create Div Container',
     555                toolbar                         : 'Create Div Container',
     556                cssClassInputLabel      : 'Stylesheet Classes',
     557                styleSelectLabel        : 'Style',
     558                IdInputLabel            : 'Id',
     559                languageCodeInputLabel  : ' Language Code',
     560                inlineStyleInputLabel   : 'Inline Style',
     561                advisoryTitleInputLabel : 'Advisory Title',
     562                langDirLabel            : 'Language Direction',
     563                langDirLTRLabel         : 'Left to Right (LTR)',
     564                langDirRTLLabel         : 'Right to Left (RTL)',
     565                edit                            : 'Edit Div Container',
     566                remove                          : 'Remove Div Container'
     567        },
     568
    552569        font :
    553570        {
    554571                label : 'Font',
  • _source/plugins/menu/plugin.js

     
    328328        'form,' +
    329329        'tablecell,tablecellproperties,tablerow,tablecolumn,table,'+
    330330        'anchor,link,image,flash,' +
    331         'checkbox,radio,textfield,hiddenfield,imagebutton,button,select,textarea';
     331        'checkbox,radio,textfield,hiddenfield,imagebutton,button,select,textarea,div';
  • _source/plugins/div/dialogs/div.js

     
     1/*
     2 * Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
     3 * For licensing, see LICENSE.html or http://ckeditor.com/license
     4 */
     5
     6(function()
     7{
     8       
     9        /**
     10         * Add to collection with DUP examination.
     11         * @param {Object} collection
     12         * @param {Object} element
     13         * @param {Object} database
     14         */
     15        function addSafely( collection, element, database )
     16        {
     17                // avoid duplicate
     18                if ( !element.getCustomData( 'block_processed' ) )
     19                {
     20                        CKEDITOR.dom.element.setMarker( database, element,
     21                                'block_processed', true );
     22                        collection.push( element );
     23                }
     24        }
     25       
     26        function getNonEmptyChildren( element )
     27        {
     28                var retval = [];
     29                var children = element.getChildren();
     30                for( var i = 0 ; i < children.count() ; i++ )
     31                {
     32                        var child = children.getItem( i );
     33                        if( ! ( child.type === CKEDITOR.NODE_TEXT
     34                                && /^[ \t\n\r]+$/.test( child.getText() ) ) )
     35                                retval.push( child );
     36                }
     37                return retval;
     38        }
     39
     40
     41        /**
     42         * Dialog reused by both 'creatediv' and 'editdiv' commands.
     43         * @param {Object} editor
     44         * @param {String} command      The command name which indicate what the current command is.
     45         */
     46        function divDialog( editor, command )
     47        {
     48                // Definition of elements at which div operation should stopped.
     49                var divLimitDefinition = ( function(){
     50                       
     51                        // Customzie from specialize blockLimit elements
     52                        var definition = CKEDITOR.tools.extend( {}, CKEDITOR.dtd.$blockLimit );
     53
     54                        // Exclude 'div' itself.
     55                        delete definition.div;
     56
     57                        // Exclude 'td' and 'th' when 'wrapping table'
     58                        if( editor.config.div_wrapTable )
     59                        {
     60                                delete definition.td;
     61                                delete definition.th;
     62                        }
     63                        return definition;
     64                })();
     65               
     66                // DTD of 'div' element
     67                var dtd = CKEDITOR.dtd.div;
     68               
     69                /**
     70                 * Get the first div limit element on the element's path.
     71                 * @param {Object} element
     72                 */
     73                function getDivLimitElement( element )
     74                {
     75                        var pathElements = new CKEDITOR.dom.elementPath( element ).elements;
     76                        var divLimit;
     77                        for ( var i = 0; i < pathElements.length ; i++ )
     78                        {
     79                                if ( pathElements[ i ].getName() in divLimitDefinition )
     80                                {
     81                                        divLimit = pathElements[ i ];
     82                                        break;
     83                                }
     84                        }
     85                        return divLimit;
     86                }
     87               
     88                /**
     89                 * Init all fields' setup/commit function.
     90                 * @memberof divDialog
     91                 */
     92                function setupFields()
     93                {
     94                        this.foreach( function( field )
     95                        {
     96                                // Exclude layout container elements
     97                                if( /^(?!vbox|hbox)/.test( field.type ) )
     98                                {
     99                                        if ( !field.setup )
     100                                        {
     101                                                // Read the dialog fields values from the specified
     102                                                // element attributes.
     103                                                field.setup = function( element )
     104                                                {
     105                                                        field.setValue( element.getAttribute( field.id ) || '' );
     106                                                };
     107                                        }
     108                                        if ( !field.commit )
     109                                        {
     110                                                // Set element attributes assigned by the dialog
     111                                                // fields.
     112                                                field.commit = function( element )
     113                                                {
     114                                                        var fieldValue = this.getValue();
     115                                                        // ignore default element attribute values
     116                                                        if ( 'dir' == field.id && element.getComputedStyle( 'direction' ) == fieldValue )
     117                                                                return true;
     118                                                        if ( fieldValue )
     119                                                                element.setAttribute( field.id, fieldValue );
     120                                                        else
     121                                                                element.removeAttribute( field.id );
     122                                                };
     123                                        }
     124                                }
     125                        } );
     126                }
     127               
     128                /**
     129                 * Either create or detect the desired block containers among the selected ranges.
     130                 * @param {Object} editor
     131                 * @param {Object} containerTagName The tagName of the container.
     132                 * @param {Object} isCreate Whether it's a creation process OR a detection process.
     133                 */     
     134                function applyDiv( editor, isCreate )
     135                {
     136                        // new adding containers OR detected pre-existed containers.
     137                        var containers = [];
     138                        // node markers store.
     139                        var database = {};
     140                        // All block level elements which contained by the ranges.
     141                        var containedBlocks = [], block;
     142       
     143                        // Get all ranges from the selection.
     144                        var selection = editor.document.getSelection();
     145                        var ranges = selection.getRanges();
     146                        var i, iterator;
     147
     148                        // Calcualte a default block tag if we need to create blocks.
     149                        var blockTag = editor.config.enterMode == CKEDITOR.ENTER_DIV ? 'div' : 'p';
     150       
     151                        // collect all included elements from dom-iterator
     152                        for( i = 0 ; i < ranges.length ; i++ )
     153                        {
     154                                iterator = ranges[ i ].createIterator();
     155                                while( ( block = iterator.getNextParagraph() ) )
     156                                {
     157                                        // include contents of blockLimit elements.
     158                                        if( block.getName() in divLimitDefinition )
     159                                        {
     160                                                var j, childNodes = block.getChildren();
     161                                                for ( j = 0 ; j < childNodes.count() ; j++ )
     162                                                        addSafely( containedBlocks, childNodes.getItem( j ) , database );
     163                                        }
     164                                        else
     165                                        {
     166                                                // Bypass dtd disallowed elements.     
     167                                                while( !dtd[ block.getName() ] && block.getName() != 'body' )
     168                                                        block = block.getParent();
     169                                                addSafely( containedBlocks, block, database );
     170                                        }
     171                                }
     172                        }
     173                       
     174                        CKEDITOR.dom.element.clearAllMarkers( database );
     175                       
     176                        var blockGroups = groupByDivLimit( containedBlocks );
     177                        var ancestor, blockEl, divElement;
     178
     179                        for( i = 0 ; i < blockGroups.length ; i++ )
     180                        {
     181                                var currentBlock = blockGroups[ i ][ 0 ];
     182                               
     183                                // Calculate the common parent node of all contained elements.
     184                                ancestor = currentBlock.getParent();
     185                                for ( var j = 1 ; j < blockGroups[ i ].length; j++ )
     186                                        ancestor = ancestor.getCommonAncestor( blockGroups[ i ][ j ] );
     187                               
     188                                if( isCreate )
     189                                        divElement = new CKEDITOR.dom.element( 'div', editor.document );
     190                               
     191                                // Normalize the blocks in each group to a common parent.
     192                                for( var j = 0; j < blockGroups[ i ].length ; j++ )
     193                                {
     194                                        currentBlock = blockGroups[ i ][ j ];
     195       
     196                                        while( !currentBlock.getParent().equals( ancestor ) )
     197                                                currentBlock = currentBlock.getParent();
     198
     199                                        blockGroups[ i ][ j ] = currentBlock;
     200                                }
     201
     202                                // Wrapped blocks counting
     203                                var childCount = 0;
     204                                for ( var j = 0 ; j < blockGroups[ i ].length ; j++ )
     205                                {
     206                                        currentBlock = blockGroups[ i ][ j ];
     207                                        // Avoid DUP
     208                                        if ( !currentBlock.getCustomData( 'block_processed' ) )
     209                                        {
     210                                                CKEDITOR.dom.element.setMarker( database, currentBlock, 'block_processed', true );
     211
     212                                                if( isCreate )
     213                                                {
     214                                                        // Establish new container, wrapping all elements in this group.
     215                                                        if( j == 0 )
     216                                                                divElement.insertBefore( currentBlock );
     217                                                        divElement.append( currentBlock );
     218                                                }
     219                                                else
     220                                                        childCount++;
     221                                        }
     222                                }
     223
     224                                CKEDITOR.dom.element.clearAllMarkers( database );
     225       
     226                                if( isCreate )
     227                                {
     228                                        // Drop pre-existed container, since new container already
     229                                        // established.
     230                                        if ( command == 'editdiv' &&
     231                                                        ancestor.getName() == 'div'
     232                                                        && 1 == getNonEmptyChildren( ancestor ).length )
     233                                                        ancestor.remove( true );
     234                                       
     235                                        // If any non-block nodes are added, shuffle them to new blocks.
     236                                        var fixedBlock = null;
     237                                        for ( var j = divElement.getChildCount() - 1 ; j >= 0 ; j-- )
     238                                        {
     239                                                var child = divElement.getChild( j );
     240
     241                                                if ( !( child.type == CKEDITOR.NODE_ELEMENT && CKEDITOR.dtd.$block[ child.getName() ] ) )
     242                                                {
     243                                                        if ( fixedBlock == null )
     244                                                        {
     245                                                                fixedBlock = editor.document.createElement( blockTag );
     246                                                                fixedBlock.insertAfter( child );
     247                                                        }
     248                                                        child.move( fixedBlock, true );
     249                                                }
     250                                                else
     251                                                        fixedBlock = null;
     252                                        }
     253
     254                                        // If the divElement has no blocks in it, append p or div.
     255                                        if ( divElement.getChildCount() < 1 )
     256                                        {
     257                                                var filler = editor.document.createElement( blockTag );
     258                                                if ( !CKEDITOR.env.ie )
     259                                                        filler.appendBogus();
     260                                                filler.appendTo( divElement );
     261                                        }
     262       
     263                                        containers.push( divElement );
     264                                }
     265                                else
     266                                {
     267                                        // discover existed container
     268                                        if ( ancestor.getName() == 'div'
     269                                                && childCount == getNonEmptyChildren( ancestor ).length )
     270                                                containers.push( ancestor );
     271                                }
     272                        }
     273       
     274                        return containers;
     275                }
     276               
     277                /**
     278                 * Divide a set of nodes to different groups by their path's blocklimit element.
     279                 * Note: the specified nodes should be in source order naturally, which mean they are supposed to producea by following class:
     280                 *  * CKEDITOR.dom.range.Iterator
     281                 *  * CKEDITOR.dom.domWalker
     282                 *  @return {Array []} the grouped nodes
     283                 */
     284                function groupByDivLimit( nodes )
     285                {
     286                        var groups = [],
     287                                lastDivLimit = null,
     288                                path, block;
     289                        for ( var i = 0 ; i < nodes.length ; i++ )
     290                        {
     291                                block = nodes[i];
     292                                var limit = getDivLimitElement( block );
     293                                if ( !limit.equals( lastDivLimit ) )
     294                                {
     295                                        lastDivLimit = limit ;
     296                                        groups.push( [] ) ;
     297                                }
     298                                groups[ groups.length - 1 ].push( block ) ;
     299                        }
     300                        return groups;
     301                }
     302               
     303                /**
     304                 * Hold a collection of created block container elements. 
     305                 */
     306                var containers = [];
     307                /**
     308                 * @type divDialog
     309                 */
     310                return {
     311                        title : editor.lang.div.title,
     312                        minWidth : 400,
     313                        minHeight : 165,
     314                        contents :
     315                        [
     316                        {
     317                                id :'info',
     318                                label :editor.lang.common.generalTab,
     319                                title :editor.lang.common.generalTab,
     320                                elements :
     321                                [
     322                                        {
     323                                                type :'hbox',
     324                                                widths : [ '50%', '50%' ],
     325                                                children :
     326                                                [
     327                                                        {
     328                                                                id :'elementStyle',
     329                                                                type :'select',
     330                                                                style :'width: 100%;',
     331                                                                label :editor.lang.div.styleSelectLabel,
     332                                                                'default' : '',
     333                                                                items : [],
     334                                                                setup : function( element )
     335                                                                {
     336                                                                        this.setValue( element.$.style.cssText || '' );
     337                                                                },
     338                                                                commit: function( element )
     339                                                                {
     340                                                                        if ( this.getValue() )
     341                                                                                element.$.style.cssText = this.getValue();
     342                                                                        else
     343                                                                                element.removeAttribute( 'style' );
     344                                                                }
     345                                                        },
     346                                                        {
     347                                                                id :'class',
     348                                                                type :'text',
     349                                                                label :editor.lang.common.cssClass,
     350                                                                'default' : ''
     351                                                        }
     352                                                ]
     353                                        }
     354                                ]
     355                        },
     356                        {
     357                                        id :'advanced',
     358                                        label :editor.lang.common.advancedTab,
     359                                        title :editor.lang.common.advancedTab,
     360                                        elements :
     361                                        [
     362                                        {
     363                                                type :'vbox',
     364                                                padding :1,
     365                                                children :
     366                                                [
     367                                                        {
     368                                                                type :'hbox',
     369                                                                widths : [ '50%', '50%' ],
     370                                                                children :
     371                                                                [
     372                                                                        {
     373                                                                                type :'text',
     374                                                                                id :'id',
     375                                                                                label :editor.lang.common.id,
     376                                                                                'default' : ''
     377                                                                        },
     378                                                                        {
     379                                                                                type :'text',
     380                                                                                id :'lang',
     381                                                                                label :editor.lang.link.langCode,
     382                                                                                'default' : ''
     383                                                                        }
     384                                                                ]
     385                                                        },
     386                                                        {
     387                                                                type :'hbox',
     388                                                                children :
     389                                                                [
     390                                                                                {
     391                                                                                        type :'text',
     392                                                                                        id :'style',
     393                                                                                        style :'width: 100%;',
     394                                                                                        label :editor.lang.common.cssStyle,
     395                                                                                        'default' : ''
     396                                                                                }
     397                                                                ]
     398                                                        },
     399                                                        {
     400                                                                type :'hbox',
     401                                                                children :
     402                                                                [
     403                                                                                {
     404                                                                                        type :'text',
     405                                                                                        id :'title',
     406                                                                                        style :'width: 100%;',
     407                                                                                        label :editor.lang.common.advisoryTitle,
     408                                                                                        'default' : ''
     409                                                                                }
     410                                                                ]
     411                                                        },
     412                                                        {
     413                                                                type :'select',
     414                                                                id :'dir',
     415                                                                style :'width: 100%;',
     416                                                                label :editor.lang.common.langDir,
     417                                                                'default' : '',
     418                                                                items :
     419                                                                [
     420                                                                        [
     421                                                                                editor.lang.common.langDirLtr,
     422                                                                                'ltr'
     423                                                                        ],
     424                                                                        [
     425                                                                                editor.lang.common.langDirRtl,
     426                                                                                'rtl'
     427                                                                        ]
     428                                                                ]
     429                                                        }
     430                                                ]
     431                                        }
     432                                        ]
     433                                }
     434                        ],
     435                        onLoad : function()
     436                        {
     437                                setupFields.call(this);
     438                        },
     439                        onShow : function()
     440                        {
     441                                containers = [];
     442                                // Whether always create new container regardless of existed
     443                                // ones.
     444                                if ( command == 'editdiv' )
     445                                {
     446                                        // Try to discover the containers that already existed in
     447                                        // ranges
     448                                        containers = applyDiv( editor );
     449                                        if( containers.length )
     450                                        {
     451                                                this._element = containers[ 0 ];
     452                                                // update dialog field values
     453                                                this.setupContent( this._element );
     454                                        }
     455                                }
     456                        },
     457                        onOk : function()
     458                        {
     459                                containers = applyDiv( editor, true );
     460                               
     461                                // Update elements attributes
     462                                for( var i = 0 ; i < containers.length ; i++ )
     463                                        this.commitContent( containers[ i ] );
     464                                this.hide();
     465                        }
     466                };
     467        }
     468       
     469        CKEDITOR.dialog.add( 'creatediv', function( editor )
     470                {
     471                        return divDialog( editor, 'creatediv' );
     472                } );
     473        CKEDITOR.dialog.add( 'editdiv', function( editor )
     474                {
     475                        return divDialog( editor, 'editdiv' );
     476                } );
     477})();
  • _source/plugins/div/plugin.js

    Property changes on: _source/plugins/div/dialogs/div.js
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1/*
     2Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
     3For licensing, see LICENSE.html or http://ckeditor.com/license
     4*/
     5
     6/**
     7 * @fileOverview The "div" plugin. It wraps the selected block level elements with a 'div' element with specified styles and attributes.
     8 *
     9 */
     10
     11(function()
     12{
     13        CKEDITOR.plugins.add( 'div',
     14        {
     15                requires : [ 'editingblock', 'domiterator' ],
     16
     17                init : function( editor )
     18                {
     19                        var lang = editor.lang.div;
     20
     21                        editor.addCommand( 'creatediv', new CKEDITOR.dialogCommand( 'creatediv' ) );
     22                        editor.addCommand( 'editdiv', new CKEDITOR.dialogCommand( 'editdiv' ) );
     23                        editor.addCommand( 'removediv',
     24                                {
     25                                        exec : function( editor )
     26                                        {
     27                                                var selection = editor.getSelection();
     28                                                if ( !selection )
     29                                                        return;
     30
     31                                                // Calculate the list of div containers to be removed.
     32                                                var ranges = selection.getRanges();
     33                                                var divContainers = [];
     34                                                var markers = {};
     35                                                for ( var i = 0 ; i < ranges.length ; i++ )
     36                                                {
     37                                                        var boundaryNodes = ranges[i].getBoundaryNodes();
     38                                                        var currentNode = boundaryNodes.startNode;
     39                                                        var endNode = boundaryNodes.endNode;
     40
     41                                                        if ( currentNode.equals( endNode ) )
     42                                                                endNode = endNode.getNextSourceNode();
     43
     44                                                        while ( currentNode && !currentNode.equals( endNode ) )
     45                                                        {
     46                                                                var path = new CKEDITOR.dom.elementPath( currentNode );
     47                                                                var div = path.blockLimit;
     48                                                                if ( div && div.getName() == 'div' && !div.getAttribute( '_cke_div_added' ) )
     49                                                                {
     50                                                                        divContainers.push( div );
     51                                                                        div.setAttribute( '_cke_div_added' );
     52                                                                }
     53                                                                currentNode = currentNode.getNextSourceNode();
     54                                                        }
     55                                                }
     56                                               
     57                                                // Remove the div containers, preserve children and selection.
     58                                                var bookmarks = selection.createBookmarks();
     59                                                for ( var i = 0 ; i < divContainers.length ; i++ )
     60                                                        divContainers[i].remove( true );
     61
     62                                                selection.selectBookmarks( bookmarks );
     63                                        }
     64                                } );
     65                               
     66                        editor.ui.addButton( 'CreateDiv',
     67                        {
     68                                label : lang.toolbar,
     69                                command :'creatediv'
     70                        } );
     71
     72                        if ( editor.addMenuItems )
     73                        {
     74                                editor.addMenuItems(
     75                                        {
     76                                                editdiv :
     77                                                {
     78                                                        label : lang.edit,
     79                                                        command : 'editdiv',
     80                                                        group : 'div',
     81                                                        order : 1
     82                                                },
     83
     84                                                removediv:
     85                                                {
     86                                                        label : lang.remove,
     87                                                        command : 'removediv',
     88                                                        group : 'div',
     89                                                        order : 5
     90                                                }
     91                                        } );
     92
     93                                if ( editor.contextMenu )
     94                                {
     95                                        editor.contextMenu.addListener( function( element, selection )
     96                                                {
     97                                                        if ( !element )
     98                                                                return null;
     99
     100                                                        var elementPath = new CKEDITOR.dom.elementPath( element );
     101                                                        var blockLimit = elementPath.blockLimit;
     102
     103                                                        if ( blockLimit && blockLimit.getName() == 'div' )
     104                                                        {
     105                                                                return {
     106                                                                        editdiv : CKEDITOR.TRISTATE_OFF,
     107                                                                        removediv : CKEDITOR.TRISTATE_OFF
     108                                                                }
     109                                                        }
     110
     111                                                        return null;
     112                                                } );
     113                                }
     114                        }
     115                       
     116                        CKEDITOR.dialog.add( 'creatediv', this.path + 'dialogs/div.js' );
     117                        CKEDITOR.dialog.add( 'editdiv', this.path + 'dialogs/div.js' );
     118                }
     119        } );
     120})();
     121
     122// Whether to wrap the whole table when created 'div' in table cell.
     123CKEDITOR.config.div_wrapTable = false;
  • _source/plugins/toolbar/plugin.js

    Property changes on: _source/plugins/div/plugin.js
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
    277277        ['Form', 'Checkbox', 'Radio', 'TextField', 'Textarea', 'Select', 'Button', 'ImageButton', 'HiddenField'],
    278278        '/',
    279279        ['Bold','Italic','Underline','Strike','-','Subscript','Superscript'],
    280         ['NumberedList','BulletedList','-','Outdent','Indent','Blockquote'],
     280        ['NumberedList','BulletedList','-','Outdent','Indent','Blockquote','CreateDiv'],
    281281        ['JustifyLeft','JustifyCenter','JustifyRight','JustifyBlock'],
    282282        ['Link','Unlink','Anchor'],     ['Image','Flash','Table','HorizontalRule','Smiley','SpecialChar','PageBreak'],
    283283        '/',
  • _source/skins/office2003/icons.css

     
    306306{
    307307        background-position: 0 -1040px;
    308308}
     309
     310.cke_skin_office2003 .cke_button_creatediv .cke_icon
     311{
     312        background-position: 0 -1168px;
     313}
     314
     315.cke_skin_office2003 .cke_button_editdiv .cke_icon
     316{
     317        background-position: 0 -1184px;
     318}
     319
     320.cke_skin_office2003 .cke_button_removediv .cke_icon
     321{
     322        background-position: 0 -1200px;
     323}
  • _source/skins/v2/icons.css

     
    306306{
    307307        background-position: 0 -1040px;
    308308}
     309
     310.cke_skin_v2 .cke_button_creatediv .cke_icon
     311{
     312        background-position: 0 -1168px;
     313}
     314
     315.cke_skin_v2 .cke_button_editdiv .cke_icon
     316{
     317        background-position: 0 -1184px;
     318}
     319
     320.cke_skin_v2 .cke_button_removediv .cke_icon
     321{
     322        background-position: 0 -1200px;
     323}
  • _source/core/config.js

     
    150150         * config.plugins = 'basicstyles,button,htmldataprocessor,toolbar,wysiwygarea';
    151151         */
    152152
    153         plugins : 'about,basicstyles,blockquote,button,clipboard,colorbutton,contextmenu,elementspath,enterkey,entities,find,flash,font,format,forms,horizontalrule,htmldataprocessor,image,indent,justify,keystrokes,link,list,maximize,newpage,pagebreak,pastefromword,pastetext,preview,print,removeformat,save,smiley,showblocks,sourcearea,stylescombo,table,tabletools,specialchar,tab,templates,toolbar,undo,wysiwygarea,wsc',
     153        plugins : 'about,basicstyles,blockquote,button,clipboard,colorbutton,contextmenu,div,elementspath,enterkey,entities,find,flash,font,format,forms,horizontalrule,htmldataprocessor,image,indent,justify,keystrokes,link,list,maximize,newpage,pagebreak,pastefromword,pastetext,preview,print,removeformat,save,smiley,showblocks,sourcearea,stylescombo,table,tabletools,specialchar,tab,templates,toolbar,undo,wysiwygarea,wsc',
    154154
    155155        /**
    156156         * The editor tabindex value.
  • _source/core/dtd.js

     
    6666                 */
    6767                $block : block,
    6868
     69                /**
     70                 * List of block limit elements.
     71                 * @type Object
     72                 * @example
     73                 */
     74                $blockLimit : { body:1,div:1,td:1,th:1,caption:1,form:1 },
     75
    6976                $body : X({script:1}, block),
    7077
    7178                /**
  • _source/core/dom/elementpath.js

     
    99        var pathBlockElements = { address:1,blockquote:1,dl:1,h1:1,h2:1,h3:1,h4:1,h5:1,h6:1,p:1,pre:1,li:1,dt:1,de:1 };
    1010
    1111        // Elements that may be considered the "Block limit" in an element path.
    12         var pathBlockLimitElements = { body:1,div:1,td:1,th:1,caption:1,form:1 };
     12        var pathBlockLimitElements = CKEDITOR.dtd.$blockLimit;
    1313
    1414        // Check if an element contains any block element.
    1515        var checkHasBlock = function( element )
  • _source/core/dom/element.js

     
    7575
    7676CKEDITOR.dom.element.setMarker = function( database, element, name, value )
    7777{
    78         var id = element.getCustomData( 'list_marker_id' ) ||
    79                         ( element.setCustomData( 'list_marker_id', CKEDITOR.tools.getNextNumber() ).getCustomData( 'list_marker_id' ) ),
    80                 markerNames = element.getCustomData( 'list_marker_names' ) ||
    81                         ( element.setCustomData( 'list_marker_names', {} ).getCustomData( 'list_marker_names' ) );
     78        var id = element.getCustomData( 'marker_id' ) ||
     79                        ( element.setCustomData( 'marker_id', CKEDITOR.tools.getNextNumber() ).getCustomData( 'marker_id' ) ),
     80                markerNames = element.getCustomData( 'marker_names' ) ||
     81                        ( element.setCustomData( 'marker_names', {} ).getCustomData( 'marker_names' ) );
    8282        database[id] = element;
    8383        markerNames[name] = 1;
    8484
     
    9393
    9494CKEDITOR.dom.element.clearMarkers = function( database, element, removeFromDatabase )
    9595{
    96         var names = element.getCustomData( 'list_marker_names' ),
    97                 id = element.getCustomData( 'list_marker_id' );
     96        var names = element.getCustomData( 'marker_names' ),
     97                id = element.getCustomData( 'marker_id' );
    9898        for ( var i in names )
    9999                element.removeCustomData( i );
    100         element.removeCustomData( 'list_marker_names' );
     100        element.removeCustomData( 'marker_names' );
    101101        if ( removeFromDatabase )
    102102        {
    103                 element.removeCustomData( 'list_marker_id' );
     103                element.removeCustomData( 'marker_id' );
    104104                delete database[id];
    105105        }
    106106};
     
    441441                {
    442442                        return new CKEDITOR.dom.nodeList( this.$.childNodes );
    443443                },
    444 
     444               
    445445                /**
    446446                 * Gets the current computed value of one of the element CSS style
    447447                 * properties.
© 2003 – 2017 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy