Ticket #2988: 2988_4.patch

File 2988_4.patch, 28.5 KB (added by Saare, 3 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 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy