Ticket #2988: 2988_4.patch

File 2988_4.patch, 28.5 KB (added by Saare, 4 years ago)
  • _samples/fullpage.html

     
    5656
    5757                                CKEDITOR.replace( 'editor1',
    5858                                        {
    59                                                 fullPage : true
     59                                                fullPage : true,
     60                                                extraPlugins : 'docprops'
    6061                                        });
    6162
    6263                        //]]>
  • _source/core/dom/element.js

     
    429429                                                        name = 'className';
    430430                                                        break;
    431431
     432                                                case 'http-equiv':
     433                                                        name = 'httpEquiv';
     434                                                        break;
     435
    432436                                                case 'tabindex':
    433437                                                        var tabIndex = standard.call( this, name );
    434438
  • _source/lang/en.js

     
    766766        {
    767767                ltr : 'Text direction from left to right',
    768768                rtl : 'Text direction from right to left'
     769        },
     770
     771        docprops :
     772        {
     773                label : 'Document Properties',
     774                title : 'Document Properties',
     775                design : 'Design',
     776                meta : 'Meta Tags',
     777                chooseColor : 'Choose',
     778                other : 'Other...',
     779                docTitle :      'Page Title',
     780                charset :       'Character Set Encoding',
     781                charsetOther : 'Other Character Set Encoding',
     782                charsetASCII : 'ASCII',
     783                charsetCE : 'Central European',
     784                charsetCT : 'Chinese Traditional (Big5)',
     785                charsetCR : 'Cyrillic',
     786                charsetGR : 'Greek',
     787                charsetJP : 'Japanese',
     788                charsetKR : 'Korean',
     789                charsetTR : 'Turkish',
     790                charsetUN : 'Unicode (UTF-8)',
     791                charsetWE : 'Westren European',
     792                docType : 'Document Type Heading',
     793                docTypeOther : 'Other Document Type Heading',
     794                xhtmlDec : 'Include XHTML Declarations',
     795                bgColor : 'Background Color',
     796                bgImage : 'Background Image URL',
     797                bgFixed : 'Non-scrolling (Fixed) Background',
     798                txtColor : 'Text Color',
     799                margin : 'Page Margins',
     800                marginTop : 'Top',
     801                marginLeft : 'Left',
     802                marginRight : 'Right',
     803                marginBottom : 'Bottom',
     804                metaKeywords : 'Document Indexing Keywords (comma separated)',
     805                metaDescription : 'Document Description',
     806                metaAuthor : 'Author',
     807                metaCopyright : 'Copyright',
     808                previewHtml : '<p>This is some <strong>sample text</strong>. You are using <a href="javascript:void(0)">CKEditor</a>.</p>'
    769809        }
    770810};
  • _source/plugins/dialogui/plugin.js

     
    618618                                        for ( var i = 0, item ; i < elementDefinition.items.length && ( item = elementDefinition.items[i] ) ; i++ )
    619619                                        {
    620620                                                innerHTML.push( '<option value="',
    621                                                         CKEDITOR.tools.htmlEncode( item[1] !== undefined ? item[1] : item[0] ), '" /> ',
     621                                                        CKEDITOR.tools.htmlEncode( item[1] !== undefined ? item[1] : item[0] ).replace( /"/g, '&quot;' ), '" /> ',
    622622                                                        CKEDITOR.tools.htmlEncode( item[0] ) );
    623623                                        }
    624624
  • _source/plugins/docprops/dialogs/docprops.js

     
     1/*
     2Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
     3For licensing, see LICENSE.html or http://ckeditor.com/license
     4*/
     5
     6CKEDITOR.dialog.add( 'docProps', function( editor )
     7{
     8        var lang = editor.lang.docprops,
     9                langCommon = editor.lang.common,
     10                metaHash = {};
     11
     12        function getDialogValue( dialogName, callback )
     13        {
     14                var onOk = function()
     15                {
     16                        releaseHandlers( this );
     17                        callback( this, this._.parentDialog );
     18                };
     19                var releaseHandlers = function( dialog )
     20                {
     21                        dialog.removeListener( 'ok', onOk );
     22                        dialog.removeListener( 'cancel', releaseHandlers );
     23                };
     24                var bindToDialog = function( dialog )
     25                {
     26                        dialog.on( 'ok', onOk );
     27                        dialog.on( 'cancel', releaseHandlers );
     28                };
     29                editor.execCommand( dialogName );
     30                if ( editor._.storedDialogs.colordialog )
     31                        bindToDialog( editor._.storedDialogs.colordialog );
     32                else
     33                {
     34                        CKEDITOR.on( 'dialogDefinition', function( e )
     35                        {
     36                                if ( e.data.name != dialogName )
     37                                        return;
     38
     39                                var definition = e.data.definition;
     40
     41                                e.removeListener();
     42                                definition.onLoad = CKEDITOR.tools.override( definition.onLoad, function( orginal )
     43                                {
     44                                        return function()
     45                                        {
     46                                                bindToDialog( this );
     47                                                definition.onLoad = orginal;
     48                                                if ( typeof orginal == 'function' )
     49                                                        orginal.call( this );
     50                                        };
     51                                });
     52                        });
     53                }
     54        }
     55        function handleOther()
     56        {
     57                var dialog = this.getDialog(),
     58                        other = dialog.getContentElement( 'general', this.id + 'Other' );
     59                if ( !other )
     60                        return;
     61                if ( this.getValue() == 'other' )
     62                {
     63                        other.getInputElement().removeAttribute( 'readOnly' );
     64                        other.focus();
     65                        other.getElement().removeClass( 'cke_disabled' );
     66                }
     67                else
     68                {
     69                        other.getInputElement().setAttribute( 'readOnly', true );
     70                        other.getElement().addClass( 'cke_disabled' );
     71                }
     72        }
     73        function commitMeta( name, isHttp, value )
     74        {
     75                return function( doc, html, head )
     76                {
     77                        var hash = metaHash,
     78                                val = typeof value != 'undefined' ? value : this.getValue();
     79                        if ( !val && ( name in hash ) )
     80                                hash[ name ].remove();
     81                        else if ( val && ( name in hash ) )
     82                                hash[ name ].setAttribute( 'content', val );
     83                        else if ( val )
     84                        {
     85                                var meta = new CKEDITOR.dom.element( 'meta', editor.document );
     86                                meta.setAttribute( isHttp ? 'http-equiv' : 'name', name );
     87                                meta.setAttribute( 'content', val );
     88                                head.append( meta );
     89                        }
     90                };
     91        }
     92        function setupMeta( name, ret )
     93        {
     94                return function()
     95                {
     96                        var hash = metaHash,
     97                                result = ( name in hash ) ? hash[ name ].getAttribute( 'content' ) || '' : '';
     98                        if ( ret )
     99                                return result;
     100                        this.setValue( result );
     101                };
     102        }
     103        function commitMargin( name )
     104        {
     105                return function( doc, html, head, body )
     106                {
     107                        body.removeAttribute( 'margin' + name );
     108                        var val = this.getValue();
     109                        if ( val !== '' )
     110                                body.setStyle( 'margin-' + name, CKEDITOR.tools.cssLength( val ) );
     111                        else
     112                                body.removeStyle( 'margin-' + name );
     113                };
     114        }
     115
     116        function createMetaHash( doc )
     117        {
     118                var hash = {},
     119                        metas = doc.getElementsByTag( 'meta' ),
     120                        count = metas.count();
     121
     122                for ( var i = 0; i < count; i++ )
     123                {
     124                        var meta = metas.getItem( i );
     125                        hash[ meta.getAttribute( meta.hasAttribute( 'http-equiv' ) ? 'http-equiv' : 'name' ).toLowerCase() ] = meta;
     126                }
     127                return hash;
     128        }
     129        // We cannot just remove the style from the element, as it might be affected from non-inline stylesheets.
     130        // To get the proper result, we should manually set the inline style to its default value.
     131        function resetStyle( element, prop, resetVal )
     132        {
     133                element.removeStyle( prop );
     134                if ( element.getComputedStyle( prop ) != resetVal )
     135                        element.setStyle( prop, resetVal );
     136        }
     137
     138        // Utilty to shorten the creation of color fields in the dialog.
     139        var colorField = function( id, label, fieldProps )
     140        {
     141                return {
     142                        type : 'hbox',
     143                        padding : 0,
     144                        widths : [ '60%', '40%' ],
     145                        children : [
     146                                CKEDITOR.tools.extend( {
     147                                        type : 'text',
     148                                        id : id,
     149                                        label : lang[ label ]
     150                                }, fieldProps || {}, 1 ),
     151                                {
     152                                        type : 'button',
     153                                        id : id + 'Choose',
     154                                        label : lang.chooseColor,
     155                                        className : 'colorChooser',
     156                                        onClick : function()
     157                                        {
     158                                                var self = this;
     159                                                getDialogValue( 'colordialog', function( colorDialog )
     160                                                {
     161                                                        var dialog = self.getDialog();
     162                                                        dialog.getContentElement( dialog._.currentTabId, id ).setValue( colorDialog.getContentElement( 'picker', 'selectedColor' ).getValue() );
     163                                                });
     164                                        }
     165                                }
     166                        ]
     167                };
     168        };
     169        var previewSrc = 'javascript:' +
     170                'void((function(){' +
     171                        encodeURIComponent(
     172                                'document.open();' +
     173                                ( CKEDITOR.env.isCustomDomain() ? 'document.domain=\'' + document.domain + '\';' : '' ) +
     174                                'document.write( \'<html style="background-color: #ffffff; height: 100%"><head></head><body style="width: 100%; height: 100%; margin: 0px">' + lang.previewHtml + '</body></html>\' );' +
     175                                'document.close();'
     176                        ) +
     177                '})())';
     178
     179        return {
     180                title : lang.title,
     181                minHeight: 330,
     182                minWidth: 500,
     183                onShow : function()
     184                {
     185                        var doc = editor.document,
     186                                html = doc.getElementsByTag( 'html' ).getItem( 0 ),
     187                                head = doc.getHead(),
     188                                body = doc.getBody();
     189                        metaHash = createMetaHash( doc );
     190                        this.setupContent( doc, html, head, body );
     191                },
     192                onHide : function()
     193                {
     194                        metaHash = {};
     195                },
     196                onOk : function()
     197                {
     198                        var doc = editor.document,
     199                                html = doc.getElementsByTag( 'html' ).getItem( 0 ),
     200                                head = doc.getHead(),
     201                                body = doc.getBody();
     202                        this.commitContent( doc, html, head, body );
     203                },
     204                contents : [
     205                        {
     206                                id : 'general',
     207                                label : langCommon.generalTab,
     208                                elements : [
     209                                        {
     210                                                type : 'text',
     211                                                id : 'title',
     212                                                label : lang.docTitle,
     213                                                setup : function( doc )
     214                                                {
     215                                                        this.setValue( doc.getElementsByTag( 'title' ).getItem( 0 ).data( 'cke-title' ) );
     216                                                },
     217                                                commit : function( doc, html, head, body, isPreview )
     218                                                {
     219                                                        if ( isPreview )
     220                                                                return;
     221                                                        doc.getElementsByTag( 'title' ).getItem( 0 ).data( 'cke-title', this.getValue() );
     222                                                }
     223                                        },
     224                                        {
     225                                                type : 'hbox',
     226                                                children : [
     227                                                        {
     228                                                                type : 'select',
     229                                                                id : 'dir',
     230                                                                label : langCommon.langDir,
     231                                                                style : 'width: 100%',
     232                                                                items : [
     233                                                                        [ langCommon.notSet , '' ],
     234                                                                        [ langCommon.langDirLtr, 'ltr' ],
     235                                                                        [ langCommon.langDirRtl, 'rtl' ]
     236                                                                ],
     237                                                                setup : function( doc, html, head, body )
     238                                                                {
     239                                                                        this.setValue( body.getDirection() || '' );
     240                                                                },
     241                                                                commit : function( doc, html, head, body )
     242                                                                {
     243                                                                        var val = this.getValue();
     244                                                                        if ( val )
     245                                                                                body.setAttribute( 'dir', val );
     246                                                                        else
     247                                                                                body.removeAttribute( 'dir' );
     248                                                                        body.removeStyle( 'direction' );
     249                                                                }
     250                                                        },
     251                                                        {
     252                                                                type : 'text',
     253                                                                id : 'langCode',
     254                                                                label : langCommon.langCode,
     255                                                                setup : function( doc, html )
     256                                                                {
     257                                                                        this.setValue( html.getAttribute( 'xml:lang' ) || html.getAttribute( 'lang' ) || '' );
     258                                                                },
     259                                                                commit : function( doc, html, head, body, isPreview )
     260                                                                {
     261                                                                        if ( isPreview )
     262                                                                                return;
     263                                                                        var val = this.getValue();
     264                                                                        if ( val )
     265                                                                                html.setAttributes( { 'xml:lang' : val, lang : val } );
     266                                                                        else
     267                                                                                html.removeAttributes( { 'xml:lang' : 1, lang : 1 } );
     268                                                                }
     269                                                        }
     270                                                ]
     271                                        },
     272                                        {
     273                                                type : 'hbox',
     274                                                children : [
     275                                                        {
     276                                                                type : 'select',
     277                                                                id : 'charset',
     278                                                                label : lang.charset,
     279                                                                style : 'width: 100%',
     280                                                                items : [
     281                                                                        [ langCommon.notSet, '' ],
     282                                                                        [ lang.charsetASCII, 'us-ascii' ],
     283                                                                        [ lang.charsetCE, 'iso-8859-2' ],
     284                                                                        [ lang.charsetCT, 'big5' ],
     285                                                                        [ lang.charsetCR, 'iso-8859-5' ],
     286                                                                        [ lang.charsetGR, 'iso-8859-7' ],
     287                                                                        [ lang.charsetJP, 'iso-2022-jp' ],
     288                                                                        [ lang.charsetKR, 'iso-2022-kr' ],
     289                                                                        [ lang.charsetTR, 'iso-8859-9' ],
     290                                                                        [ lang.charsetUN, 'utf-8' ],
     291                                                                        [ lang.charsetWE, 'iso-8859-1' ],
     292                                                                        [ lang.other, 'other' ]
     293                                                                ],
     294                                                                'default' : '',
     295                                                                onChange : function()
     296                                                                {
     297                                                                        this.getDialog().selectedCharset = this.getValue() != 'other' ? this.getValue() : '';
     298                                                                        handleOther.call( this );
     299                                                                },
     300                                                                setup : function()
     301                                                                {
     302                                                                        this.metaCharset = ( 'charset' in metaHash );
     303
     304                                                                        var func = setupMeta( this.metaCharset ? 'charset' : 'content-type', 1, 1 ),
     305                                                                                val = func.call( this );
     306
     307                                                                        !this.metaCharset && val.match( /charset=[^=]+$/ ) && ( val = val.substring( val.indexOf( '=' ) + 1 ) );
     308
     309                                                                        if ( val )
     310                                                                        {
     311                                                                                this.setValue( val.toLowerCase() );
     312                                                                                if ( !this.getValue() )
     313                                                                                {
     314                                                                                        this.setValue( 'other' );
     315                                                                                        var other = this.getDialog().getContentElement( 'general', 'charsetOther' );
     316                                                                                        other && other.setValue( val );
     317                                                                                }
     318                                                                                this.getDialog().selectedCharset = val;
     319                                                                        }
     320
     321                                                                        handleOther.call( this );
     322                                                                },
     323                                                                commit : function( doc, html, head, body, isPreview )
     324                                                                {
     325                                                                        if ( isPreview )
     326                                                                                return;
     327                                                                        var value = this.getValue(),
     328                                                                                other = this.getDialog().getContentElement( 'general', 'charsetOther' );
     329
     330                                                                        value == 'other' && ( value = other ? other.getValue() : '' );
     331
     332                                                                        value && !this.metaCharset && ( value = ( metaHash[ 'content-type' ] ? metaHash[ 'content-type' ].getAttribute( 'content' ).split( ';' )[0] : 'text/html' ) + '; charset=' + value );
     333
     334                                                                        var func = commitMeta( this.metaCharset ? 'charset' : 'content-type', 1, value );
     335                                                                        func.call( this, doc, html, head );
     336                                                                }
     337                                                        },
     338                                                        {
     339                                                                type : 'text',
     340                                                                id : 'charsetOther',
     341                                                                label : lang.charsetOther,
     342                                                                onChange : function(){ this.getDialog().selectedCharset = this.getValue(); }
     343                                                        }
     344                                                ]
     345                                        },
     346                                        {
     347                                                type : 'hbox',
     348                                                children : [
     349                                                        {
     350                                                                type : 'select',
     351                                                                id : 'docType',
     352                                                                label : lang.docType,
     353                                                                style : 'width: 100%',
     354                                                                items : [
     355                                                                        [ langCommon.notSet , '' ],
     356                                                                        [ 'XHTML 1.1', '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">' ],
     357                                                                        [ 'XHTML 1.0 Transitional', '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">' ],
     358                                                                        [ 'XHTML 1.0 Strict', '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' ],
     359                                                                        [ 'XHTML 1.0 Frameset', '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">' ],
     360                                                                        [ 'HTML 5', '<!DOCTYPE html>' ],
     361                                                                        [ 'HTML 4.01 Transitional', '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">' ],
     362                                                                        [ 'HTML 4.01 Strict', '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">' ],
     363                                                                        [ 'HTML 4.01 Frameset', '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">' ],
     364                                                                        [ 'HTML 3.2', '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">' ],
     365                                                                        [ 'HTML 2.0', '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">' ],
     366                                                                        [ lang.other, 'other' ]
     367                                                                ],
     368                                                                onChange : handleOther,
     369                                                                setup : function()
     370                                                                {
     371                                                                        if ( editor.docType )
     372                                                                        {
     373                                                                                this.setValue( editor.docType );
     374                                                                                if ( !this.getValue() )
     375                                                                                {
     376                                                                                        this.setValue( 'other' );
     377                                                                                        var other = this.getDialog().getContentElement( 'general', 'docTypeOther' );
     378                                                                                        other && other.setValue( editor.docType );
     379                                                                                }
     380                                                                        }
     381                                                                        handleOther.call( this );
     382                                                                },
     383                                                                commit : function( doc, html, head, body, isPreview )
     384                                                                {
     385                                                                        if ( isPreview )
     386                                                                                return;
     387                                                                        var value = this.getValue(),
     388                                                                                other = this.getDialog().getContentElement( 'general', 'docTypeOther' );
     389                                                                        editor.docType = value == 'other' ? ( other ? other.getValue() : '' ) : value;
     390                                                                }
     391                                                        },
     392                                                        {
     393                                                                type : 'text',
     394                                                                id : 'docTypeOther',
     395                                                                label : lang.docTypeOther
     396                                                        }
     397                                                ]
     398                                        },
     399                                        {
     400                                                type : 'checkbox',
     401                                                id : 'xhtmlDec',
     402                                                label : lang.xhtmlDec,
     403                                                setup : function()
     404                                                {
     405                                                        this.setValue( !!editor.xmlDeclaration );
     406                                                },
     407                                                commit : function( doc, html, head, body, isPreview )
     408                                                {
     409                                                        if ( isPreview )
     410                                                                return;
     411                                                        if ( this.getValue() )
     412                                                        {
     413                                                                editor.xmlDeclaration = '<?xml version="1.0" encoding="' + ( this.getDialog().selectedCharset || 'utf-8' )+ '"?>' ;
     414                                                                html.setAttribute( 'xmlns', 'http://www.w3.org/1999/xhtml' );
     415                                                        }
     416                                                        else
     417                                                        {
     418                                                                editor.xmlDeclaration = '';
     419                                                                html.removeAttribute( 'xmlns' );
     420                                                        }
     421                                                }
     422                                        }
     423                                ]
     424                        },
     425                        {
     426                                id : 'design',
     427                                label : lang.design,
     428                                elements : [
     429                                        {
     430                                                type : 'hbox',
     431                                                widths : [ '60%', '40%' ],
     432                                                children : [
     433                                                        {
     434                                                                type : 'vbox',
     435                                                                children : [
     436                                                                        colorField( 'txtColor', 'txtColor',
     437                                                                        {
     438                                                                                setup : function( doc, html, head, body )
     439                                                                                {
     440                                                                                        this.setValue( body.getComputedStyle( 'color' ) );
     441                                                                                },
     442                                                                                commit : function( doc, html, head, body )
     443                                                                                {
     444                                                                                        body.removeAttribute( 'text' );
     445                                                                                        var val = this.getValue();
     446                                                                                        if ( val )
     447                                                                                                body.setStyle( 'color', val );
     448                                                                                        else
     449                                                                                                body.removeStyle( 'color' );
     450                                                                                }
     451                                                                        }),
     452                                                                        colorField( 'bgColor', 'bgColor', {
     453                                                                                setup : function( doc, html, head, body )
     454                                                                                {
     455                                                                                        var val = body.getComputedStyle( 'background-color' ) || '';
     456                                                                                        this.setValue( val == 'transparent' ? '' : val );
     457                                                                                },
     458                                                                                commit : function( doc, html, head, body )
     459                                                                                {
     460                                                                                        body.removeAttribute( 'bgcolor' );
     461                                                                                        var val = this.getValue();
     462                                                                                        if ( val )
     463                                                                                                body.setStyle( 'background-color', val );
     464                                                                                        else
     465                                                                                                resetStyle( body, 'background-color', 'transparent' );
     466                                                                                }
     467                                                                        }),
     468                                                                        {
     469                                                                                type : 'hbox',
     470                                                                                widths : [ '60%', '40%' ],
     471                                                                                padding : 0,
     472                                                                                children : [
     473                                                                                        {
     474                                                                                                type : 'text',
     475                                                                                                id : 'bgImage',
     476                                                                                                label : lang.bgImage,
     477                                                                                                setup : function( doc, html, head, body )
     478                                                                                                {
     479                                                                                                        var val = body.getComputedStyle( 'background-image' ) || '';
     480                                                                                                        if ( val == 'none' )
     481                                                                                                                val = '';
     482                                                                                                        else
     483                                                                                                        {
     484                                                                                                                val = val.replace( /url\(\s*(["']?)\s*([^\)]*)\s*\1\s*\)/i, function( match, quote, url )
     485                                                                                                                {
     486                                                                                                                        return url;
     487                                                                                                                });
     488                                                                                                        }
     489                                                                                                        this.setValue( val );
     490                                                                                                },
     491                                                                                                commit : function( doc, html, head, body )
     492                                                                                                {
     493                                                                                                        body.removeAttribute( 'background' );
     494                                                                                                        var val = this.getValue();
     495                                                                                                        if ( val )
     496                                                                                                                body.setStyle( 'background-image', 'url(' + val + ')' );
     497                                                                                                        else
     498                                                                                                                resetStyle( body, 'background-image', 'none' );
     499                                                                                                }
     500                                                                                        },
     501                                                                                        {
     502                                                                                                type : 'button',
     503                                                                                                id : 'bgImageChoose',
     504                                                                                                label : langCommon.browseServer,
     505                                                                                                style : 'display:inline-block;margin-top:10px;',
     506                                                                                                hidden : true,
     507                                                                                                filebrowser : 'bg:bgImage'
     508                                                                                        }
     509                                                                                ]
     510                                                                        },
     511                                                                        {
     512                                                                                type : 'checkbox',
     513                                                                                id : 'bgFixed',
     514                                                                                label : lang.bgFixed,
     515                                                                                setup : function( doc, html, head, body )
     516                                                                                {
     517                                                                                        this.setValue( body.getComputedStyle( 'background-attachment' ) == 'fixed' );
     518                                                                                },
     519                                                                                commit : function( doc, html, head, body )
     520                                                                                {
     521                                                                                        if ( this.getValue() )
     522                                                                                                body.setStyle( 'background-attachment', 'fixed' );
     523                                                                                        else
     524                                                                                                resetStyle( body, 'background-attachment', 'scroll' );
     525                                                                                }
     526                                                                        }
     527                                                                ]
     528                                                        },
     529                                                        {
     530                                                                type : 'vbox',
     531                                                                children : [
     532                                                                        {
     533                                                                                type : 'html',
     534                                                                                id : 'marginTitle',
     535                                                                                html : '<div style="text-align: center; margin: 0px auto; font-weight: bold">' + lang.margin + '</div>'
     536                                                                        },
     537                                                                        {
     538                                                                                type : 'text',
     539                                                                                id : 'marginTop',
     540                                                                                label : lang.marginTop,
     541                                                                                style : 'width: 80px; text-align: center; margin: 0px auto',
     542                                                                                controlStyle : 'text-align: center',
     543                                                                                setup : function( doc, html, head, body )
     544                                                                                {
     545                                                                                        this.setValue( body.getStyle( 'margin-top' ) || body.getAttribute( 'margintop' ) || '' );
     546                                                                                },
     547                                                                                commit : commitMargin( 'top' ),
     548                                                                                onLoad : function()
     549                                                                                {
     550                                                                                        this.getElement().getParent().setStyle( 'text-align', 'center' );
     551                                                                                }
     552                                                                        },
     553                                                                        {
     554                                                                                type : 'hbox',
     555                                                                                children : [
     556                                                                                        {
     557                                                                                                type : 'text',
     558                                                                                                id : 'marginLeft',
     559                                                                                                label : lang.marginLeft,
     560                                                                                                style : 'width: 80px; text-align: center; margin: 0px auto',
     561                                                                                                controlStyle : 'text-align: center',
     562                                                                                                setup : function( doc, html, head, body )
     563                                                                                                {
     564                                                                                                        this.setValue( body.getStyle( 'margin-left' ) || body.getAttribute( 'marginleft' ) || '' );
     565                                                                                                },
     566                                                                                                commit : commitMargin( 'left' ),
     567                                                                                                onLoad : function()
     568                                                                                                {
     569                                                                                                        this.getElement().getParent().setStyle( 'text-align', 'center' );
     570                                                                                                }
     571                                                                                        },
     572                                                                                        {
     573                                                                                                type : 'text',
     574                                                                                                id : 'marginRight',
     575                                                                                                label : lang.marginRight,
     576                                                                                                style : 'width: 80px; text-align: center; margin: 0px auto',
     577                                                                                                controlStyle : 'text-align: center',
     578                                                                                                setup : function( doc, html, head, body )
     579                                                                                                {
     580                                                                                                        this.setValue( body.getStyle( 'margin-right' ) || body.getAttribute( 'marginright' ) || '' );
     581                                                                                                },
     582                                                                                                commit : commitMargin( 'right' ),
     583                                                                                                onLoad : function()
     584                                                                                                {
     585                                                                                                        this.getElement().getParent().setStyle( 'text-align', 'center' );
     586                                                                                                }
     587                                                                                        }
     588                                                                                ]
     589                                                                        },
     590                                                                        {
     591                                                                                type : 'text',
     592                                                                                id : 'marginBottom',
     593                                                                                label : lang.marginBottom,
     594                                                                                style : 'width: 80px; text-align: center; margin: 0px auto',
     595                                                                                controlStyle : 'text-align: center',
     596                                                                                setup : function( doc, html, head, body )
     597                                                                                {
     598                                                                                        this.setValue( body.getStyle( 'margin-bottom' ) || body.getAttribute( 'marginbottom' ) || '' );
     599                                                                                },
     600                                                                                commit : commitMargin( 'bottom' ),
     601                                                                                onLoad : function()
     602                                                                                {
     603                                                                                        this.getElement().getParent().setStyle( 'text-align', 'center' );
     604                                                                                }
     605                                                                        }
     606                                                                ]
     607                                                        }
     608                                                ]
     609                                        }
     610                                ]
     611                        },
     612                        {
     613                                id : 'meta',
     614                                label : lang.meta,
     615                                elements : [
     616                                        {
     617                                                type : 'textarea',
     618                                                id : 'metaKeywords',
     619                                                label : lang.metaKeywords,
     620                                                setup : setupMeta( 'keywords' ),
     621                                                commit : commitMeta( 'keywords' )
     622                                        },
     623                                        {
     624                                                type : 'textarea',
     625                                                id : 'metaDescription',
     626                                                label : lang.metaDescription,
     627                                                setup : setupMeta( 'description' ),
     628                                                commit : commitMeta( 'description' )
     629                                        },
     630                                        {
     631                                                type : 'text',
     632                                                id : 'metaAuthor',
     633                                                label : lang.metaAuthor,
     634                                                setup : setupMeta( 'author' ),
     635                                                commit : commitMeta( 'author' )
     636                                        },
     637                                        {
     638                                                type : 'text',
     639                                                id : 'metaCopyright',
     640                                                label : lang.metaCopyright,
     641                                                setup : setupMeta( 'copyright' ),
     642                                                commit : commitMeta( 'copyright' )
     643                                        }
     644                                ]
     645                        },
     646                        {
     647                                id : 'preview',
     648                                label : langCommon.preview,
     649                                elements : [
     650                                        {
     651                                                type : 'html',
     652                                                id : 'previewHtml',
     653                                                html : '<iframe src="' + previewSrc + '" style="width: 100%; height: 310px" hidefocus="true" frameborder="0" ' +
     654                                                                'id="cke_docProps_preview_iframe"></iframe>',
     655                                                onLoad : function()
     656                                                {
     657                                                        this.getDialog().on( 'selectPage', function( ev )
     658                                                        {
     659                                                                if ( ev.data.page == 'preview' )
     660                                                                {
     661                                                                        var self = this;
     662                                                                        setTimeout( function()
     663                                                                        {
     664                                                                                var doc = CKEDITOR.document.getById( 'cke_docProps_preview_iframe' ).getFrameDocument(),
     665                                                                                        html = doc.getElementsByTag( 'html' ).getItem( 0 ),
     666                                                                                        head = doc.getHead(),
     667                                                                                        body = doc.getBody();
     668                                                                                self.commitContent( doc, html, head, body, 1 );
     669                                                                        }, 0 );
     670                                                                }
     671                                                        });
     672                                                        CKEDITOR.document.getById( 'cke_docProps_preview_iframe' ).getAscendant( 'table' ).setStyle( 'height', '100%' );
     673                                                }
     674                                        }
     675                                ]
     676                        }
     677                ]
     678        };
     679} );
  • _source/plugins/docprops/plugin.js

     
     1/*
     2Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
     3For licensing, see LICENSE.html or http://ckeditor.com/license
     4*/
     5
     6CKEDITOR.plugins.add( 'docprops',
     7{
     8        init : function( editor )
     9        {
     10                var cmd = new CKEDITOR.dialogCommand( 'docProps' );
     11                // Only applicable on full page mode.
     12                cmd.modes = { wysiwyg : editor.config.fullPage };
     13                editor.addCommand( 'docProps', cmd );
     14                CKEDITOR.dialog.add( 'docProps', this.path + 'dialogs/docprops.js' );
     15
     16                editor.ui.addButton( 'DocProps',
     17                {
     18                        label : editor.lang.docprops.label,
     19                        command : 'docProps'
     20                });
     21        }
     22});
  • _source/plugins/toolbar/plugin.js

     
    459459 * // This is actually the default value.
    460460 * config.toolbar_Full =
    461461 * [
    462  *     { name: 'document',    items : [ 'Source','-','Save','NewPage','Preview','Print','-','Templates' ] },
     462 *     { name: 'document',    items : [ 'Source','-','Save','NewPage','DocProps','Preview','Print','-','Templates' ] },
    463463 *     { name: 'clipboard',   items : [ 'Cut','Copy','Paste','PasteText','PasteFromWord','-','Undo','Redo' ] },
    464464 *     { name: 'editing',     items : [ 'Find','Replace','-','SelectAll','-','SpellChecker', 'Scayt' ] },
    465465 *     { name: 'forms',       items : [ 'Form', 'Checkbox', 'Radio', 'TextField', 'Textarea', 'Select', 'Button', 'ImageButton', 'HiddenField' ] },
     
    476476 */
    477477CKEDITOR.config.toolbar_Full =
    478478[
    479         { name: 'document',             items : [ 'Source','-','Save','NewPage','Preview','Print','-','Templates' ] },
     479        { name: 'document',             items : [ 'Source','-','Save','NewPage','DocProps','Preview','Print','-','Templates' ] },
    480480        { name: 'clipboard',    items : [ 'Cut','Copy','Paste','PasteText','PasteFromWord','-','Undo','Redo' ] },
    481481        { name: 'editing',              items : [ 'Find','Replace','-','SelectAll','-','SpellChecker', 'Scayt' ] },
    482482        { name: 'forms',                items : [ 'Form', 'Checkbox', 'Radio', 'TextField', 'Textarea', 'Select', 'Button', 'ImageButton', 'HiddenField' ] },
  • _source/plugins/wysiwygarea/plugin.js

     
    959959                                                                                {
    960960                                                                                        editor.docType = docType = match;
    961961                                                                                        return '';
     962                                                                                }).replace( /<\?xml\s[^\?]*\?>/i, function( match )
     963                                                                                {
     964                                                                                        editor.xmlDeclaration = match;
     965                                                                                        return '';
    962966                                                                                });
    963967                                                                }
    964968
     
    10311035                                                                var config = editor.config,
    10321036                                                                        fullPage = config.fullPage,
    10331037                                                                        docType = fullPage && editor.docType,
     1038                                                                        xmlDeclaration = fullPage && editor.xmlDeclaration,
    10341039                                                                        doc = iframe.getFrameDocument();
    10351040
    10361041                                                                var data = fullPage
     
    10481053                                                                if ( config.ignoreEmptyParagraph )
    10491054                                                                        data = data.replace( emptyParagraphRegexp, function( match, lookback ) { return lookback; } );
    10501055
     1056                                                                if ( xmlDeclaration )
     1057                                                                        data = xmlDeclaration + '\n' + data;
    10511058                                                                if ( docType )
    10521059                                                                        data = docType + '\n' + data;
    10531060
  • _source/skins/kama/icons.css

     
    88        background-position: 0 0;
    99}
    1010
     11.cke_skin_kama .cke_button_docProps .cke_icon
     12{
     13        background-position: 0 -16px;
     14}
     15
    1116.cke_skin_kama .cke_button_newpage .cke_icon
    1217{
    1318        background-position: 0 -48px;
© 2003 – 2015 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy