Ticket #3018: 3018.patch

File 3018.patch, 20.5 KB (added by Frederico Caldeira Knabben, 11 years ago)
  • _source/core/config.js

     
    147147         * config.plugins = 'basicstyles,button,htmldataprocessor,toolbar,wysiwygarea';
    148148         */
    149149
    150         plugins : 'basicstyles,blockquote,button,clipboard,elementspath,find,flash,font,format,forms,horizontalrule,htmldataprocessor,image,indent,justify,keystrokes,link,list,newpage,pagebreak,pastefromword,pastetext,preview,print,removeformat,smiley,showblocks,sourcearea,table,specialchar,tab,templates,toolbar,undo,wysiwygarea',
     150        plugins : 'basicstyles,blockquote,button,clipboard,elementspath,find,flash,font,format,forms,horizontalrule,htmldataprocessor,image,indent,justify,keystrokes,link,list,newpage,pagebreak,pastefromword,pastetext,preview,print,removeformat,smiley,showblocks,sourcearea,stylescombo,table,specialchar,tab,templates,toolbar,undo,wysiwygarea',
    151151
    152152        /**
    153153         * The theme to be used to build the UI.
  • _source/lang/en.js

     
    438438
    439439        showBlocks : 'Show Blocks',
    440440
     441        stylesCombo :
     442        {
     443                label : 'Styles',
     444                panelTitle1 : 'Block Styles',
     445                panelTitle2 : 'Inline Styles',
     446                panelTitle3 : 'Object Styles'
     447        },
     448
    441449        format :
    442450        {
    443451                label : 'Format',
  • _source/plugins/font/plugin.js

     
    1 /*
     1/*
    22Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
    33For licensing, see LICENSE.html or http://ckeditor.com/license
    44*/
  • _source/plugins/listblock/plugin.js

     
    66CKEDITOR.plugins.add( 'listblock',
    77{
    88        requires : [ 'panel' ],
    9        
     9
    1010        onLoad : function()
    1111        {
    1212                CKEDITOR.ui.panel.prototype.addListBlock = function( name, multiSelect )
     
    2828                                        this._ =
    2929                                        {
    3030                                                pendingHtml : [],
    31                                                 items : {}
     31                                                items : {},
     32                                                groups : {}
    3233                                        };
    3334                                },
    3435
     
    8687                                        startGroup : function( title )
    8788                                        {
    8889                                                this._.close();
    89                                                 this._.pendingHtml.push( '<h1 class=cke_panel_grouptitle>', title, '</h1>' );
     90
     91                                                var id = CKEDITOR.tools.getNextNumber();
     92
     93                                                this._.groups[ title ] = id;
     94
     95                                                this._.pendingHtml.push( '<h1 id=cke_', id, ' class=cke_panel_grouptitle>', title, '</h1>' );
    9096                                        },
    9197
    9298                                        commit : function()
     
    107113                                                return !isMarked;
    108114                                        },
    109115
     116                                        hideGroup : function( groupTitle )
     117                                        {
     118                                                var group = this.element.getDocument().getById( 'cke_' + this._.groups[ groupTitle ] ),
     119                                                        list = group && group.getNext();
     120
     121                                                if ( group )
     122                                                {
     123                                                        group.setStyle( 'display', 'none' );
     124
     125                                                        if ( list && list.getName() == 'ul' )
     126                                                                list.setStyle( 'display', 'none' );
     127                                                }
     128                                        },
     129
     130                                        hideItem : function( value )
     131                                        {
     132                                                this.element.getDocument().getById( 'cke_' + this._.items[ value ] ).setStyle( 'display', 'none' );
     133                                        },
     134
     135                                        showAll : function()
     136                                        {
     137                                                var items = this._.items,
     138                                                        groups = this._.groups,
     139                                                        doc = this.element.getDocument();
     140
     141                                                for ( var value in items )
     142                                                {
     143                                                        doc.getById( 'cke_' + items[ value ] ).setStyle( 'display', '' );
     144                                                }
     145
     146                                                for ( title in groups )
     147                                                {
     148                                                        var group = doc.getById( 'cke_' + groups[ title ] ),
     149                                                                list = group.getNext();
     150
     151                                                        group.setStyle( 'display', '' );
     152
     153                                                        if ( list && list.getName() == 'ul' )
     154                                                                list.setStyle( 'display', '' );
     155                                                }
     156                                        },
     157
    110158                                        mark : function( value )
    111159                                        {
    112160                                                if ( !this.multiSelect )
  • _source/plugins/richcombo/plugin.js

     
    233233                {
    234234                        return this._.value || '';
    235235                },
     236               
     237                unmarkAll : function()
     238                {
     239                        this._.list.unmarkAll();
     240                },
    236241
     242                mark : function( value )
     243                {
     244                        this._.list.mark( value );
     245                },
     246               
     247                hideItem : function( value )
     248                {
     249                        this._.list.hideItem( value );
     250                },
     251               
     252                hideGroup : function( groupTitle )
     253                {
     254                        this._.list.hideGroup( groupTitle );
     255                },
     256               
     257                showAll : function()
     258                {
     259                        this._.list.showAll();
     260                },
     261
    237262                add : function( value, html, text )
    238263                {
    239264                        this._.items[ value ] = text || value;
     
    243268                startGroup : function( title )
    244269                {
    245270                        this._.list.startGroup( title );
     271                },
     272               
     273                commit : function()
     274                {
     275                        this._.list.commit();
    246276                }
    247277        }
    248278});
  • _source/plugins/styles/plugin.js

     
    8080        var blockElements       = { address:1,div:1,h1:1,h2:1,h3:1,h4:1,h5:1,h6:1,p:1,pre:1 };
    8181        var objectElements      = { a:1,embed:1,hr:1,img:1,li:1,object:1,ol:1,table:1,td:1,tr:1,ul:1 };
    8282
     83        var semicolonFixRegex = /\s*(?:;\s*|$)/;
     84
    8385        CKEDITOR.style = function( styleDefinition, variablesValues )
    8486        {
    8587                if ( variablesValues )
     
    135137                                                        removeInlineStyle
    136138                                                : null ).call( this, range );
    137139                },
     140               
     141                applyToObject : function( element )
     142                {
     143                        setupElement( element, this );
     144                },
    138145
    139146                /**
    140147                 * Get the style state inside an element path. Returns "true" if the
     
    202209                }
    203210        };
    204211
     212        // Build the cssText based on the styles definition.
     213        CKEDITOR.style.getStyleText = function( styleDefinition )
     214        {
     215                // If we have already computed it, just return it.
     216                var stylesDef = styleDefinition._ST;
     217                if ( stylesDef )
     218                        return stylesDef;
     219
     220                stylesDef = styleDefinition.styles;
     221
     222                // Builds the StyleText.
     223
     224                var stylesText = ( styleDefinition.attributes && styleDefinition.attributes[ 'style' ] ) || '';
     225
     226                if ( stylesText.length )
     227                        stylesText = stylesText.replace( semicolonFixRegex, ';' );
     228
     229                for ( var style in stylesDef )
     230                        stylesText += style + ':' + stylesDef[ style ] + ';';
     231
     232                // Browsers make some changes to the style when applying them. So, here
     233                // we normalize it to the browser format.
     234                if ( stylesText.length )
     235                {
     236                        stylesText = normalizeCssText( stylesText );
     237
     238                        if ( stylesText.length )
     239                                stylesText = stylesText.replace( semicolonFixRegex, ';' );
     240                }
     241
     242                // Return it, saving it to the next request.
     243                return ( styleDefinition._ST = stylesText );
     244        };
     245
    205246        function applyInlineStyle( range )
    206247        {
    207248                var document = range.document;
     
    668709                var def = style._.definition;
    669710
    670711                var elementName = style.element;
    671                 var attributes = def.attributes;
    672                 var styles = getStyleText( def );
    673712
    674713                // The "*" element name will always be a span for this function.
    675714                if ( elementName == '*' )
     
    677716
    678717                // Create the element.
    679718                el = new CKEDITOR.dom.element( elementName, targetDocument );
     719               
     720                return setupElement( el, style );
     721        }
     722       
     723        function setupElement( el, style )
     724        {
     725                var def = style._.definition;
     726                var attributes = def.attributes;
     727                var styles = CKEDITOR.style.getStyleText( def );
    680728
    681729                // Assign all defined attributes.
    682730                if ( attributes )
     
    734782                }
    735783
    736784                // Includes the style definitions.
    737                 var styleText = getStyleText( styleDefinition );
     785                var styleText = CKEDITOR.style.getStyleText( styleDefinition );
    738786                if ( styleText.length > 0 )
    739787                {
    740788                        if ( !attribs[ 'style' ] )
     
    750798                return ( styleDefinition._AC = attribs );
    751799        }
    752800
    753         var semicolonFixRegex = /\s*(?:;\s*|$)/;
    754 
    755         // Build the cssText based on the styles definition.
    756         function getStyleText( styleDefinition )
    757         {
    758                 // If we have already computed it, just return it.
    759                 var stylesDef = styleDefinition._ST;
    760                 if ( stylesDef )
    761                         return stylesDef;
    762 
    763                 stylesDef = styleDefinition.styles;
    764 
    765                 // Builds the StyleText.
    766 
    767                 var stylesText = ( styleDefinition.attributes && styleDefinition.attributes[ 'style' ] ) || '';
    768 
    769                 if ( stylesText.length )
    770                         stylesText = stylesText.replace( semicolonFixRegex, ';' );
    771 
    772                 for ( var style in stylesDef )
    773                         stylesText += style + ':' + stylesDef[ style ] + ';';
    774 
    775                 // Browsers make some changes to the style when applying them. So, here
    776                 // we normalize it to the browser format.
    777                 if ( stylesText.length )
    778                 {
    779                         stylesText = normalizeCssText( stylesText );
    780 
    781                         if ( stylesText.length )
    782                                 stylesText = stylesText.replace( semicolonFixRegex, ';' );
    783                 }
    784 
    785                 // Return it, saving it to the next request.
    786                 return ( styleDefinition._ST = stylesText );
    787         }
    788 
    789801        function normalizeCssText( unparsedCssText )
    790802        {
    791803                // Injects the style in a temporary span object, so the browser parses it,
  • _source/plugins/stylescombo/plugin.js

     
     1/*
     2Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
     3For licensing, see LICENSE.html or http://ckeditor.com/license
     4*/
     5
     6(function()
     7{
     8        CKEDITOR.plugins.add( 'stylescombo',
     9        {
     10                requires : [ 'richcombo', 'styles' ],
     11
     12                init : function( editor )
     13                {
     14                        var config = editor.config,
     15                                lang = editor.lang.stylesCombo,
     16                                pluginPath = this.path,
     17                                styles,
     18                                saveRanges;
     19
     20                        editor.ui.addRichCombo( 'Styles',
     21                                {
     22                                        label : lang.label,
     23                                        title : lang.panelTitle,
     24                                        className : 'cke_styles',
     25                                        multiSelect : true,
     26
     27                                        panel :
     28                                        {
     29                                                css : [ config.contentsCss, editor.skinPath + 'editor.css' ],
     30                                                className : 'cke_skin_default'
     31                                        },
     32
     33                                        init : function()
     34                                        {
     35                                                var combo = this,
     36                                                        stylesSet = config.stylesCombo_stylesSet.split( ':', 1 ),
     37                                                        stylesSetPath = stylesSet[ 1 ] || CKEDITOR.getUrl( pluginPath + 'styles/' + stylesSet[ 0 ] + '.js' ) ;
     38
     39                                                stylesSet = stylesSet[ 0 ];
     40
     41                                                CKEDITOR.loadStylesSet( stylesSet, stylesSetPath, function( stylesDefinitions )
     42                                                        {
     43                                                                var style,
     44                                                                        styleName,
     45                                                                        stylesList = [];
     46
     47                                                                styles = {};
     48
     49                                                                // Put all styles into an Array.
     50                                                                for ( var i = 0 ; i < stylesDefinitions.length ; i++ )
     51                                                                {
     52                                                                        var styleDefinition = stylesDefinitions[ i ];
     53
     54                                                                        styleName = styleDefinition.name;
     55
     56                                                                        style = styles[ styleName ] = new CKEDITOR.style( styleDefinition );
     57                                                                        style._name = styleName;
     58
     59                                                                        stylesList.push( style );
     60                                                                }
     61
     62                                                                // Sorts the Array, so the styles get grouped
     63                                                                // by type.
     64                                                                stylesList.sort( sortStyles );
     65
     66                                                                // Loop over the Array, adding all items to the
     67                                                                // combo.
     68                                                                var lastType;
     69                                                                for ( var i = 0 ; i < stylesList.length ; i++ )
     70                                                                {
     71                                                                        style = stylesList[ i ];
     72                                                                        styleName = style._name;
     73
     74                                                                        var type = style.type;
     75
     76                                                                        if ( type != lastType )
     77                                                                        {
     78                                                                                combo.startGroup( lang[ 'panelTitle' + String( type ) ] );
     79                                                                                lastType = type;
     80                                                                        }
     81
     82                                                                        combo.add(
     83                                                                                styleName,
     84                                                                                style.type == CKEDITOR.STYLE_OBJECT ? styleName : buildPreview( style._.definition ),
     85                                                                                styleName );
     86                                                                }
     87
     88                                                                combo.commit();
     89
     90                                                                combo.onOpen();
     91                                                        });
     92                                        },
     93
     94                                        onClick : function( value )
     95                                        {
     96                                                editor.focus();
     97
     98                                                var style = styles[ value ],
     99                                                        selection = editor.getSelection();
     100                                               
     101                                                if ( saveRanges )
     102                                                {
     103                                                        selection.selectRanges( saveRanges );
     104                                                        saveRanges = false;
     105                                                }
     106
     107                                                if ( style.type == CKEDITOR.STYLE_OBJECT )
     108                                                {
     109                                                        var element = selection.getSelectedElement();
     110                                                        if ( element )
     111                                                                style.applyToObject( element );
     112                                                       
     113                                                        return;
     114                                                }
     115                                               
     116                                                var elementPath = new CKEDITOR.dom.elementPath( selection.getStartElement() );
     117
     118                                                if ( style.type == CKEDITOR.STYLE_INLINE && style.checkActive( elementPath ) )
     119                                                        style.remove( editor.document );
     120                                                else
     121                                                        style.apply( editor.document );
     122                                        },
     123
     124                                        onRender : function()
     125                                        {
     126                                                editor.on( 'selectionChange', function( ev )
     127                                                        {
     128                                                                var currentTag = this.getValue();
     129
     130                                                                var elementPath = ev.data.path;
     131
     132                                                                for ( var tag in styles )
     133                                                                {
     134                                                                        if ( styles[ tag ].checkActive( elementPath ) )
     135                                                                        {
     136                                                                                if ( tag != currentTag )
     137                                                                                        this.setValue( tag );
     138                                                                                return;
     139                                                                        }
     140                                                                }
     141
     142                                                                // If no styles match, just empty it.
     143                                                                this.setValue( '' );
     144                                                        },
     145                                                        this);
     146                                        },
     147
     148                                        onOpen : function()
     149                                        {
     150                                                var selection = editor.getSelection();
     151
     152                                                if ( CKEDITOR.env.ie )
     153                                                {
     154                                                        editor.focus();
     155                                                        saveRanges = selection.getRanges();
     156                                                }
     157
     158                                                var elementPath,
     159                                                        element = selection.getSelectedElement(),
     160                                                        elementName = element && element.getName(),
     161                                                        isInline = elementName &&
     162                                                                !CKEDITOR.dtd.$block[ elementName ] &&
     163                                                                !CKEDITOR.dtd.$listItem[ elementName ] &&
     164                                                                !CKEDITOR.dtd.$tableContent[ elementName ];
     165
     166                                                var counter = [ 0, 0, 0, 0 ];
     167
     168                                                if ( !element || isInline )
     169                                                        elementPath = new CKEDITOR.dom.elementPath( selection.getStartElement() );
     170
     171                                                this.showAll();
     172                                                this.unmarkAll();
     173
     174                                                for ( var name in styles )
     175                                                {
     176                                                        var style = styles[ name ]
     177                                                                type = style.type;
     178
     179                                                        if ( type == CKEDITOR.STYLE_OBJECT )
     180                                                        {
     181                                                                if ( element && style.element == elementName )
     182                                                                {
     183                                                                        if ( style.checkElementRemovable( element, true ) )
     184                                                                                this.mark( name );
     185
     186                                                                        counter[ type ]++;
     187                                                                }
     188                                                                else
     189                                                                        this.hideItem( name );
     190                                                        }
     191                                                        else
     192                                                        {
     193                                                                if ( elementPath )
     194                                                                {
     195                                                                        if ( style.checkActive( elementPath ) )
     196                                                                                this.mark( name );
     197
     198                                                                        counter[ type ]++;
     199
     200                                                                }
     201                                                                else
     202                                                                        this.hideItem( name );
     203                                                        }
     204                                                }
     205
     206                                                if ( !counter[ CKEDITOR.STYLE_BLOCK ] )
     207                                                        this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_BLOCK ) ] );
     208
     209                                                if ( !counter[ CKEDITOR.STYLE_INLINE ] )
     210                                                        this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_INLINE ) ] );
     211
     212                                                if ( !counter[ CKEDITOR.STYLE_OBJECT ] )
     213                                                        this.hideGroup( lang[ 'panelTitle' + String( CKEDITOR.STYLE_OBJECT ) ] );
     214                                        },
     215
     216                                        onClose : function()
     217                                        {
     218                                                saveRanges = null;
     219                                        }
     220                                });
     221                }
     222        });
     223
     224        var stylesSets = {};
     225
     226        CKEDITOR.addStylesSet = function( name, styles )
     227        {
     228                stylesSets[ name ] = styles;
     229        };
     230
     231        CKEDITOR.loadStylesSet = function( name, url, callback )
     232        {
     233                var stylesSet = stylesSets[ name ];
     234
     235                if ( stylesSet )
     236                        return callback( stylesSets );
     237
     238                CKEDITOR.scriptLoader.load( url, function()
     239                        {
     240                                callback( stylesSets[ name ] );
     241                        });
     242        };
     243
     244        function buildPreview( styleDefinition )
     245        {
     246                var html = [];
     247
     248                var elementName = styleDefinition.element;
     249
     250                // Avoid <bdo> in the preview.
     251                if ( elementName == 'bdo' )
     252                        elementName = 'span';
     253
     254                html = [ '<', elementName ];
     255
     256                // Assign all defined attributes.
     257                var attribs     = styleDefinition.attributes;
     258                if ( attribs )
     259                {
     260                        for ( var att in attribs )
     261                        {
     262                                html.push( ' ', att, '="', attribs[ att ], '"' );
     263                        }
     264                }
     265
     266                // Assign the style attribute.
     267                var cssStyle = CKEDITOR.style.getStyleText( styleDefinition );
     268                if ( cssStyle )
     269                        html.push( ' style="', cssStyle, '"' );
     270
     271                html.push( '>', styleDefinition.name, '</', elementName, '>' );
     272
     273                return html.join( '' );
     274        }
     275
     276        function sortStyles( styleA, styleB )
     277        {
     278                var typeA = styleA.type,
     279                        typeB = styleB.type;
     280
     281                return typeA == typeB ? 0 :
     282                        typeA == CKEDITOR.STYLE_OBJECT ? -1 :
     283                        typeB == CKEDITOR.STYLE_OBJECT ? 1 :
     284                        typeB == CKEDITOR.STYLE_BLOCK ? 1 :
     285                        -1;
     286        }
     287})();
     288
     289CKEDITOR.config.stylesCombo_stylesSet = 'default';
  • _source/plugins/stylescombo/styles/default.js

     
     1/*
     2Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
     3For licensing, see LICENSE.html or http://ckeditor.com/license
     4*/
     5
     6CKEDITOR.addStylesSet( 'default',
     7[
     8        /* Block Styles */
     9
     10        // These styles are already available in the "Format" combo, so they are
     11        // not needed here by default. You may enable them to avoid placing the
     12        // "Format" combo in the toolbar, maintaining the same features.
     13        /*
     14        { name : 'Paragraph'            , element : 'p' },
     15        { name : 'Heading 1'            , element : 'h1' },
     16        { name : 'Heading 2'            , element : 'h2' },
     17        { name : 'Heading 3'            , element : 'h3' },
     18        { name : 'Heading 4'            , element : 'h4' },
     19        { name : 'Heading 5'            , element : 'h5' },
     20        { name : 'Heading 6'            , element : 'h6' },
     21        { name : 'Preformatted Text', element : 'pre' },
     22        { name : 'Address'                      , element : 'address' },
     23        */
     24
     25        { name : 'Blue Title'           , element : 'h3', styles : { 'color' : 'Blue' } },
     26        { name : 'Red Title'            , element : 'h3', styles : { 'color' : 'Red' } },
     27
     28        /* Inline Styles */
     29
     30        // These are core styles available as toolbar buttons. You may opt enabling
     31        // some of them in the Styles combo, removing them from the toolbar.
     32        /*
     33        { name : 'Strong'                       , element : 'strong', overrides : 'b' },
     34        { name : 'Emphasis'                     , element : 'em'        , overrides : 'i' },
     35        { name : 'Underline'            , element : 'u' },
     36        { name : 'Strikethrough'        , element : 'strike' },
     37        { name : 'Subscript'            , element : 'sub' },
     38        { name : 'Superscript'          , element : 'sup' },
     39        */
     40
     41        { name : 'Marker: Yellow'       , element : 'span', styles : { 'background-color' : 'Yellow' } },
     42        { name : 'Marker: Green'        , element : 'span', styles : { 'background-color' : 'Lime' } },
     43
     44        { name : 'Big'                          , element : 'big' },
     45        { name : 'Small'                        , element : 'small' },
     46        { name : 'Typewriter'           , element : 'tt' },
     47
     48        { name : 'Computer Code'        , element : 'code' },
     49        { name : 'Keyboard Phrase'      , element : 'kbd' },
     50        { name : 'Sample Text'          , element : 'samp' },
     51        { name : 'Variable'                     , element : 'var' },
     52
     53        { name : 'Deleted Text'         , element : 'del' },
     54        { name : 'Inserted Text'        , element : 'ins' },
     55
     56        { name : 'Cited Work'           , element : 'cite' },
     57        { name : 'Inline Quotation'     , element : 'q' },
     58
     59        { name : 'Language: RTL'        , element : 'span', attributes : { 'dir' : 'rtl' } },
     60        { name : 'Language: LTR'        , element : 'span', attributes : { 'dir' : 'ltr' } },
     61
     62        /* Object Styles */
     63
     64        {
     65                name : 'Image on Left',
     66                element : 'img',
     67                attributes :
     68                {
     69                        'style' : 'padding: 5px; margin-right: 5px',
     70                        'border' : '2',
     71                        'align' : 'left'
     72                }
     73        },
     74
     75        {
     76                name : 'Image on Right',
     77                element : 'img',
     78                attributes :
     79                {
     80                        'style' : 'padding: 5px; margin-left: 5px',
     81                        'border' : '2',
     82                        'align' : 'right'
     83                }
     84        }
     85]);
  • _source/plugins/toolbar/plugin.js

     
    221221        ['JustifyLeft','JustifyCenter','JustifyRight','JustifyBlock'],
    222222        ['Link','Unlink','Anchor'],     ['Image','Flash','Table','HorizontalRule','Smiley','SpecialChar','PageBreak'],
    223223        '/',
    224         ['Format','Font','FontSize'],
     224        ['Styles','Format','Font','FontSize'],
    225225        ['ShowBlocks']
    226226];
  • _source/skins/default/presets.css

     
    33For licensing, see LICENSE.html or http://ckeditor.com/license
    44*/
    55
     6/* "Styles" panel size */
     7.cke_skin_default.cke_panel.cke_styles
     8{
     9        width: 150px;
     10        height: 170px;
     11}
     12
    613/* "Format" panel size */
    714.cke_skin_default.cke_panel.cke_format
    815{
© 2003 – 2019 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy