Ticket #2916: 2916.patch

File 2916.patch, 34.5 KB (added by Martin Kou, 15 years ago)
  • _source/lang/en.js

     
    368368                width   : 'Width',
    369369                height  : 'Height',
    370370                hSpace  : 'HSpace',
    371                 vSpace  : 'VSpace'
     371                vSpace  : 'VSpace',
     372                validateSrc : 'URL must not be empty.',
     373                validateWidth : 'Width must be an integer.',
     374                validateHeight : 'Height must be an integer.',
     375                validateHSpace : 'HSpace must be an integer.',
     376                validateVSpace : 'VSpace must be an integer.'
    372377        },
    373378
    374379        smiley :
  • _source/plugins/wysiwygarea/plugin.js

     
    7474                }
    7575        };
    7676
     77        // ### protectCkeTags - START
     78        var protectCkeTagRegex = /(<\/?)(object|embed|param)/gi
     79        var protectCkeTags = function( html )
     80        {
     81                return html.replace( protectCkeTagRegex, '$1cke:$2' );
     82        };
     83        // ### protectCkeTags - END
     84
    7785        var onInsertElement = function( evt )
    7886        {
    7987                if ( this.mode == 'wysiwyg' )
     
    299307                                                                // Protect src or href attributes.
    300308                                                                data = protectUrls( data );
    301309
     310                                                                // Protect cke prefixed tags.
     311                                                                data = protectCkeTags( data );
     312
    302313                                                                data =
    303314                                                                        editor.config.docType +
    304315                                                                        '<html dir="' + editor.config.contentsLangDirection + '">' +
  • _source/plugins/fakeobjects/plugin.js

     
    55
    66CKEDITOR.plugins.add( 'fakeobjects' );
    77
    8 CKEDITOR.editor.prototype.createFakeElement = function( realElement, className, realElementType )
     8CKEDITOR.editor.prototype.createFakeElement = function( realElement, className, realElementType, isResizable )
    99{
    1010        var attributes =
    1111        {
     
    1515        };
    1616        if ( realElementType )
    1717                attributes._cke_real_element_type = realElementType;
     18        if ( isResizable )
     19                attributes._cke_resizable = isResizable;
    1820
    1921        return this.document.createElement( 'img', { attributes : attributes } );
    2022};
    2123
    2224CKEDITOR.editor.prototype.restoreRealElement = function( fakeElement )
    2325{
    24         var html = decodeURIComponent( fakeElement.getAttribute( '_cke_realelement' ) ),
    25                 realElement = CKEDITOR.dom.element.createFromHtml( html, this.document );
    26 
    27         if ( fakeElement.$.style.width )
    28                 realElement.setStyle( 'width', fakeElement.$.style.width );
    29         if ( fakeElement.$.style.height )
    30                 realElement.setStyle( 'height', fakeElement.$.style.height );
    31 
    32         return realElement;
     26        var html = decodeURIComponent( fakeElement.getAttribute( '_cke_realelement' ) );
     27        return CKEDITOR.dom.element.createFromHtml( html, this.document );
    3328};
  • _source/plugins/dialogui/plugin.js

     
    319319                                                html = [],
    320320                                                attributes = { 'class' : 'cke_dialog_ui_checkbox_input', type : 'checkbox' };
    321321                                        cleanInnerDefinition( myDefinition );
    322                                         if ( elementDefinition.checked )
     322                                        if ( elementDefinition[ 'default' ] )
    323323                                                attributes.checked = 'checked';
    324324                                        _.checkbox = new CKEDITOR.ui.dialog.uiElement( dialog, myDefinition, html, 'input', null, attributes );
    325325                                        html.push( ' ', CKEDITOR.tools.htmlEncode( elementDefinition.label ) );
  • _source/plugins/flash/dialogs/flash.js

     
     1/*
     2Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
     3For licensing, see LICENSE.html or http://ckeditor.com/license
     4*/
     5
     6(function()
     7{
     8        /*
     9         * It is possible to set things in three different places.
     10         * 1. As attributes in the object tag.
     11         * 2. As param tags under the object tag.
     12         * 3. As attributes in the embed tag.
     13         * It is possible for a single attribute to be present in more than one place.
     14         * So let's define a mapping between a sementic attribute and its syntactic
     15         * equivalents.
     16         * Then we'll set and retrieve attribute values according to the mapping,
     17         * instead of having to check and set each syntactic attribute every time.
     18         *
     19         * Reference: http://kb.adobe.com/selfservice/viewContent.do?externalId=tn_12701
     20         */
     21        var ATTRTYPE_OBJECT = 1,
     22                ATTRTYPE_PARAM = 2,
     23                ATTRTYPE_EMBED = 4;
     24
     25        var attributesMap =
     26        {
     27                id : [ { type : ATTRTYPE_OBJECT, name : CKEDITOR.env.ie ? '_cke_saved_id' : 'id' } ],
     28                classid : [ { type : ATTRTYPE_OBJECT, name : 'classid' } ],
     29                codebase : [ { type : ATTRTYPE_OBJECT, name : 'codebase'} ],
     30                pluginspage : [ { type : ATTRTYPE_EMBED, name : 'pluginspage' } ],
     31                src : [ { type : ATTRTYPE_PARAM, name : 'movie' }, { type : ATTRTYPE_EMBED, name : 'src' } ],
     32                name : [ { type : ATTRTYPE_EMBED, name : 'name' } ],
     33                align : [ { type : ATTRTYPE_OBJECT, name : 'align' } ],
     34                title : [ { type : ATTRTYPE_OBJECT, name : 'title' }, { type : ATTRTYPE_EMBED, name : 'title' } ],
     35                'class' : [ { type : ATTRTYPE_OBJECT, name : 'class' }, { type : ATTRTYPE_EMBED, name : 'class'} ],
     36                width : [ { type : ATTRTYPE_OBJECT, name : 'width' }, { type : ATTRTYPE_EMBED, name : 'width' } ],
     37                height : [ { type : ATTRTYPE_OBJECT, name : 'height' }, { type : ATTRTYPE_EMBED, name : 'height' } ],
     38                hSpace : [ { type : ATTRTYPE_OBJECT, name : 'hSpace' }, { type : ATTRTYPE_EMBED, name : 'hSpace' } ],
     39                vSpace : [ { type : ATTRTYPE_OBJECT, name : 'vSpace' }, { type : ATTRTYPE_EMBED, name : 'vSpace' } ],
     40                style : [ { type : ATTRTYPE_OBJECT, name : 'style' }, { type : ATTRTYPE_EMBED, name : 'style' } ],
     41                type : [ { type : ATTRTYPE_EMBED, name : 'type' } ]
     42        };
     43
     44        var names = [ 'play', 'loop', 'menu', 'quality', 'scale', 'salign', 'wmode', 'bgcolor', 'base', 'flashvars', 'allowScriptAccess',
     45                'allowFullScreen' ];
     46        for ( var i = 0 ; i < names.length ; i++ )
     47                attributesMap[ names[i] ] = [ { type : ATTRTYPE_EMBED, name : names[i] }, { type : ATTRTYPE_PARAM, name : names[i] } ];
     48        names = [ 'allowFullScreen', 'play', 'loop', 'menu' ];
     49        for ( var i = 0 ; i < names.length ; i++ )
     50                attributesMap[ names[i] ][0]['default'] = attributesMap[ names[i] ][1]['default'] = true;
     51
     52        function loadValue( objectNode, embedNode, paramMap )
     53        {
     54                var attributes = attributesMap[ this.id ];
     55                if ( !attributes )
     56                        return;
     57
     58                var isCheckbox = ( this instanceof CKEDITOR.ui.dialog.checkbox );
     59                for ( var i = 0 ; i < attributes.length ; i++ )
     60                {
     61                        var attrDef = attributes[ i ];
     62                        switch ( attrDef.type )
     63                        {
     64                                case ATTRTYPE_OBJECT:
     65                                        if ( !objectNode )
     66                                                continue;
     67                                        if ( objectNode.getAttribute( attrDef.name ) != null )
     68                                        {
     69                                                var value = objectNode.getAttribute( attrDef.name );
     70                                                if ( isCheckbox )
     71                                                        this.setValue( value.toLowerCase() == 'true' );
     72                                                else
     73                                                        this.setValue( value );
     74                                                return;
     75                                        }
     76                                        else if ( isCheckbox )
     77                                                this.setValue( !!attrDef[ 'default' ] );
     78                                case ATTRTYPE_PARAM:
     79                                        if ( !objectNode )
     80                                                continue;
     81                                        if ( attrDef.name in paramMap )
     82                                        {
     83                                                var value = paramMap[ attrDef.name ];
     84                                                if ( isCheckbox )
     85                                                        this.setValue( value.toLowerCase() == 'true' );
     86                                                else
     87                                                        this.setValue( value );
     88                                                return;
     89                                        }
     90                                        else if ( isCheckbox )
     91                                                this.setValue( !!attrDef[ 'default' ] );
     92                                case ATTRTYPE_EMBED:
     93                                        if ( !embedNode )
     94                                                continue;
     95                                        if ( embedNode.getAttribute( attrDef.name ) != null )
     96                                        {
     97                                                var value = embedNode.getAttribute( attrDef.name );
     98                                                if ( isCheckbox )
     99                                                        this.setValue( value.toLowerCase() == 'true' );
     100                                                else
     101                                                        this.setValue( value );
     102                                                return;
     103                                        }
     104                                        else if ( isCheckbox )
     105                                                this.setValue( !!attrDef[ 'default' ] );
     106                                default:
     107                        }
     108                }
     109        }
     110
     111        function commitValue( objectNode, embedNode, paramMap )
     112        {
     113                var attributes = attributesMap[ this.id ];
     114                if ( !attributes )
     115                        return;
     116
     117                var isRemove = ( this.getValue() === '' ),
     118                        isCheckbox = ( this instanceof CKEDITOR.ui.dialog.checkbox );
     119
     120                for ( var i = 0 ; i < attributes.length ; i++ )
     121                {
     122                        var attrDef = attributes[i];
     123                        switch ( attrDef.type )
     124                        {
     125                                case ATTRTYPE_OBJECT:
     126                                        if ( !objectNode )
     127                                                continue;
     128                                        var value = this.getValue();
     129                                        if ( isRemove || isCheckbox && value === attrDef[ 'default' ] )
     130                                                objectNode.removeAttribute( attrDef.name );
     131                                        else
     132                                                objectNode.setAttribute( attrDef.name, value );
     133                                        break;
     134                                case ATTRTYPE_PARAM:
     135                                        if ( !objectNode )
     136                                                continue;
     137                                        var value = this.getValue();
     138                                        if ( isRemove || isCheckbox && value === attrDef[ 'default' ] )
     139                                        {
     140                                                if ( attrDef.name in paramMap )
     141                                                        paramMap[ attrDef.name ].remove();
     142                                        }
     143                                        else
     144                                        {
     145                                                if ( attrDef.name in paramMap )
     146                                                        paramMap[ attrDef.name ].setAttribute( 'value', value );
     147                                                else
     148                                                {
     149                                                        var param = CKEDITOR.dom.element.createFromHtml( '<cke:param></cke:param>', objectNode.getDocument() );
     150                                                        param.setAttributes( { name : attrDef.name, value : value } );
     151                                                        if ( objectNode.getChildCount() < 1 )
     152                                                                param.appendTo( objectNode );
     153                                                        else
     154                                                                param.insertBefore( objectNode.getFirst() );
     155                                                }
     156                                        }
     157                                        break;
     158                                case ATTRTYPE_EMBED:
     159                                        if ( !embedNode )
     160                                                continue;
     161                                        var value = this.getValue();
     162                                        if ( isRemove || isCheckbox && value === attrDef[ 'default' ])
     163                                                embedNode.removeAttribute( attrDef.name );
     164                                        else
     165                                                embedNode.setAttribute( attrDef.name, value );
     166                                default:
     167                        }
     168                }
     169        }
     170
     171        CKEDITOR.dialog.add( 'flash', function( editor )
     172        {
     173                var makeObjectTag = !editor.config.flashEmbedTagOnly,
     174                        makeEmbedTag = editor.config.flashAddEmbedTag || editor.config.flashEmbedTagOnly;
     175
     176                var previewAreaHtml = '<div>' + CKEDITOR.tools.htmlEncode( editor.lang.image.preview ) +'<br>' +
     177                        '<div id="FlashPreviewLoader" style="display:none"><div class="loading">&nbsp;</div></div>' +
     178                        '<div id="FlashPreviewBox"></div></div>';
     179
     180                return {
     181                        title : editor.lang.flash.title,
     182                        minWidth : 450,
     183                        minHeight : 400,
     184                        onLoad : function()
     185                        {
     186                                if ( editor.config.flashUploadTab == false )
     187                                        this.hidePage( 'Upload' );              // Hide Upload tab.
     188
     189                                if ( editor.config.flashBrowseServer == false )
     190                                        this.getContentElement( 'info', 'browse' ).getElement().hide();
     191                        },
     192                        onShow : function()
     193                        {
     194                                // Clear previously saved elements.
     195                                this.fakeImage = this.objectNode = this.embedNode = null;
     196
     197                                // Try to detect any embed or object tag that has Flash parameters.
     198                                var fakeImage = this.getSelectedElement();
     199                                if ( fakeImage && fakeImage.getAttribute( '_cke_real_element_type' ) && fakeImage.getAttribute( '_cke_real_element_type' ) == 'flash' )
     200                                {
     201                                        this.fakeImage = fakeImage;
     202
     203                                        var realElement = editor.restoreRealElement( fakeImage ),
     204                                                objectNode = null, embedNode = null, paramMap = {};
     205                                        if ( realElement.getName() == 'cke:object' )
     206                                        {
     207                                                objectNode = realElement;
     208                                                var embedList = objectNode.getElementsByTag( 'embed', 'cke' );
     209                                                if ( embedList.count() > 0 )
     210                                                        embedNode = embedList.getItem( 0 );
     211                                                var paramList = objectNode.getElementsByTag( 'param', 'cke' );
     212                                                for ( var i = 0, length = paramList.count() ; i < length ; i++ )
     213                                                {
     214                                                        var item = paramList.getItem( i ),
     215                                                                name = item.getAttribute( 'name' ),
     216                                                                value = item.getAttribute( 'value' );
     217                                                        paramMap[ name ] = value;
     218                                                }
     219                                        }
     220                                        else if ( realElement.getName() == 'cke:embed' )
     221                                                embedNode = realElement;
     222
     223                                        this.objectNode = objectNode;
     224                                        this.embedNode = embedNode;
     225
     226                                        this.setupContent( objectNode, embedNode, paramMap, fakeImage );
     227                                }
     228                        },
     229                        onOk : function()
     230                        {
     231                                // If there's no selected object or embed, create one. Otherwise, reuse the
     232                                // selected object and embed nodes.
     233                                var objectNode = null,
     234                                        embedNode = null,
     235                                        paramMap = null;
     236                                if ( !this.fakeImage )
     237                                {
     238                                        if ( makeObjectTag )
     239                                        {
     240                                                objectNode = CKEDITOR.dom.element.createFromHtml( '<cke:object></cke:object>', editor.document );
     241                                                var attributes = {
     242                                                        classid : 'clsid:d27cdb6e-ae6d-11cf-96b8-444553540000',
     243                                                        codebase : 'http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,40,0'
     244                                                };
     245                                                objectNode.setAttributes( attributes );
     246                                        }
     247                                        if ( makeEmbedTag )
     248                                        {
     249                                                embedNode = CKEDITOR.dom.element.createFromHtml( '<cke:embed></cke:embed>', editor.document );
     250                                                embedNode.setAttributes(
     251                                                        {
     252                                                                type : 'application/x-shockwave-flash',
     253                                                                pluginspage : 'http://www.macromedia.com/go/getflashplayer'
     254                                                        } );
     255                                                if ( objectNode )
     256                                                        embedNode.appendTo( objectNode );
     257                                        }
     258                                }
     259                                else
     260                                {
     261                                        objectNode = this.objectNode;
     262                                        embedNode = this.embedNode;
     263                                }
     264
     265                                // Produce the paramMap if there's an object tag.
     266                                if ( objectNode )
     267                                {
     268                                        paramMap = {};
     269                                        var paramList = objectNode.getElementsByTag( 'param', 'cke' );
     270                                        for ( var i = 0, length = paramList.count() ; i < length ; i++ )
     271                                                paramMap[ paramList.getItem( i ).getAttribute( 'name' ) ] = paramList.getItem( i );
     272                                }
     273
     274                                // Apply or remove flash parameters.
     275                                var extraStyles = {};
     276                                this.commitContent( objectNode, embedNode, paramMap, extraStyles );
     277
     278                                // Refresh the fake image.
     279                                var newFakeImage = editor.createFakeElement( objectNode || embedNode, 'cke_flash', 'flash', true );
     280                                newFakeImage.setStyles( extraStyles );
     281                                if ( this.fakeImage )
     282                                        newFakeImage.replace( this.fakeImage );
     283                                else
     284                                {
     285                                        this.restoreSelection();
     286                                        editor.insertElement( newFakeImage );
     287                                }
     288                        },
     289                        contents : [
     290                                {
     291                                        id : 'info',
     292                                        label : editor.lang.common.generalTab,
     293                                        accessKey : 'I',
     294                                        elements :
     295                                        [
     296                                                {
     297                                                        type : 'vbox',
     298                                                        padding : 0,
     299                                                        children :
     300                                                        [
     301                                                                {
     302                                                                        type : 'html',
     303                                                                        html : '<span>' + CKEDITOR.tools.htmlEncode( editor.lang.image.url ) + '</span>'
     304                                                                },
     305                                                                {
     306                                                                        type : 'hbox',
     307                                                                        widths : [ '280px', '110px' ],
     308                                                                        align : 'right',
     309                                                                        children :
     310                                                                        [
     311                                                                                {
     312                                                                                        id : 'src',
     313                                                                                        type : 'text',
     314                                                                                        label : '',
     315                                                                                        validate : CKEDITOR.dialog.validate.notEmpty( editor.lang.flash.validateSrc ),
     316                                                                                        setup : loadValue,
     317                                                                                        commit : commitValue
     318                                                                                },
     319                                                                                {
     320                                                                                        type : 'button',
     321                                                                                        id : 'browse',
     322                                                                                        align : 'center',
     323                                                                                        label : editor.lang.common.browseServer
     324                                                                                }
     325                                                                        ]
     326                                                                }
     327                                                        ]
     328                                                },
     329                                                {
     330                                                        type : 'hbox',
     331                                                        widths : [ '25%', '25%', '25%', '25%', '25%' ],
     332                                                        children :
     333                                                        [
     334                                                                {
     335                                                                        type : 'text',
     336                                                                        id : 'width',
     337                                                                        label : editor.lang.flash.width,
     338                                                                        validate : CKEDITOR.dialog.validate.integer( editor.lang.flash.validateWidth ),
     339                                                                        setup : function( objectNode, embedNode, paramMap, fakeImage )
     340                                                                        {
     341                                                                                loadValue.apply( this, arguments );
     342                                                                                if ( fakeImage )
     343                                                                                {
     344                                                                                        var fakeImageWidth = parseInt( fakeImage.$.style.width, 10 );
     345                                                                                        if ( !isNaN( fakeImageWidth ) )
     346                                                                                                this.setValue( fakeImageWidth );
     347                                                                                }
     348                                                                        },
     349                                                                        commit : function( objectNode, embedNode, paramMap, extraStyles )
     350                                                                        {
     351                                                                                commitValue.apply( this, arguments );
     352                                                                                if ( this.getValue() != '' )
     353                                                                                        extraStyles.width = this.getValue() + 'px';
     354                                                                        }
     355                                                                },
     356                                                                {
     357                                                                        type : 'text',
     358                                                                        id : 'height',
     359                                                                        label : editor.lang.flash.height,
     360                                                                        validate : CKEDITOR.dialog.validate.integer( editor.lang.flash.validateHeight ),
     361                                                                        setup : function( objectNode, embedNode, paramMap, fakeImage )
     362                                                                        {
     363                                                                                loadValue.apply( this, arguments );
     364                                                                                if ( fakeImage )
     365                                                                                {
     366                                                                                        var fakeImageHeight = parseInt( fakeImage.$.style.height, 10 );
     367                                                                                        if ( !isNaN( fakeImageHeight ) )
     368                                                                                                this.setValue( fakeImageHeight );
     369                                                                                }
     370                                                                        },
     371                                                                        commit : function( objectNode, embedNode, paramMap, extraStyles )
     372                                                                        {
     373                                                                                commitValue.apply( this, arguments );
     374                                                                                if ( this.getValue() != '' )
     375                                                                                        extraStyles.height = this.getValue() + 'px';
     376                                                                        }
     377                                                                },
     378                                                                {
     379                                                                        type : 'text',
     380                                                                        id : 'hSpace',
     381                                                                        label : editor.lang.flash.hSpace,
     382                                                                        validate : CKEDITOR.dialog.validate.integer( editor.lang.flash.validateHSpace ),
     383                                                                        setup : loadValue,
     384                                                                        commit : commitValue
     385                                                                },
     386                                                                {
     387                                                                        type : 'text',
     388                                                                        id : 'vSpace',
     389                                                                        label : editor.lang.flash.vSpace,
     390                                                                        validate : CKEDITOR.dialog.validate.integer( editor.lang.flash.validateVSpace ),
     391                                                                        setup : loadValue,
     392                                                                        commit : commitValue
     393                                                                }
     394                                                        ]
     395                                                },
     396
     397                                                {
     398                                                        type : 'vbox',
     399                                                        children :
     400                                                        [
     401                                                                {
     402                                                                        type : 'html',
     403                                                                        style : 'width:95%;',
     404                                                                        html : previewAreaHtml
     405                                                                }
     406                                                        ]
     407                                                }
     408                                        ]
     409                                },
     410                                {
     411                                        id : 'Upload',
     412                                        label : editor.lang.common.upload,
     413                                        elements :
     414                                        [
     415                                                {
     416                                                        type : 'file',
     417                                                        id : 'upload',
     418                                                        label : editor.lang.common.upload,
     419                                                        action : editor.config.image_uploadAction,
     420                                                        size : 38
     421                                                },
     422                                                {
     423                                                        type : 'fileButton',
     424                                                        id : 'uploadButton',
     425                                                        label : editor.lang.common.uploadSubmit,
     426                                                        'for' : [ 'Upload', 'upload' ]
     427                                                }
     428                                        ]
     429                                },
     430                                {
     431                                        id : 'properties',
     432                                        label : editor.lang.flash.propertiesTab,
     433                                        elements :
     434                                        [
     435                                                {
     436                                                        type : 'hbox',
     437                                                        widths : [ '50%', '50%' ],
     438                                                        children :
     439                                                        [
     440                                                                {
     441                                                                        id : 'scale',
     442                                                                        type : 'select',
     443                                                                        label : editor.lang.flash.scale,
     444                                                                        'default' : '',
     445                                                                        style : 'width : 100%;',
     446                                                                        items :
     447                                                                        [
     448                                                                                [ editor.lang.common.notSet , ''],
     449                                                                                [ editor.lang.flash.scaleAll, 'showall' ],
     450                                                                                [ editor.lang.flash.scaleNoBorder, 'noborder' ],
     451                                                                                [ editor.lang.flash.scaleFit, 'exactfit' ]
     452                                                                        ],
     453                                                                        setup : loadValue,
     454                                                                        commit : commitValue
     455                                                                },
     456                                                                {
     457                                                                        id : 'allowScriptAccess',
     458                                                                        type : 'select',
     459                                                                        label : editor.lang.flash.access,
     460                                                                        'default' : '',
     461                                                                        style : 'width : 100%;',
     462                                                                        items :
     463                                                                        [
     464                                                                                [ editor.lang.common.notSet , ''],
     465                                                                                [ editor.lang.flash.accessAlways, 'always' ],
     466                                                                                [ editor.lang.flash.accessSameDomain, 'samedomain' ],
     467                                                                                [ editor.lang.flash.accessNever, 'never' ]
     468                                                                        ],
     469                                                                        setup : loadValue,
     470                                                                        commit : commitValue
     471                                                                }
     472                                                        ]
     473                                                },
     474                                                {
     475                                                        type : 'hbox',
     476                                                        widths : [ '50%', '50%' ],
     477                                                        children :
     478                                                        [
     479                                                                {
     480                                                                        id : 'wmode',
     481                                                                        type : 'select',
     482                                                                        label : editor.lang.flash.windowMode,
     483                                                                        'default' : '',
     484                                                                        style : 'width : 100%;',
     485                                                                        items :
     486                                                                        [
     487                                                                                [ editor.lang.common.notSet , ''],
     488                                                                                [ 'window' ],
     489                                                                                [ 'opaque' ],
     490                                                                                [ 'transparent' ]
     491                                                                        ],
     492                                                                        setup : loadValue,
     493                                                                        commit : commitValue
     494                                                                },
     495                                                                {
     496                                                                        id : 'quality',
     497                                                                        type : 'select',
     498                                                                        label : editor.lang.flash.quality,
     499                                                                        'default' : 'high',
     500                                                                        style : 'width : 100%;',
     501                                                                        items :
     502                                                                        [
     503                                                                                [ editor.lang.common.notSet , ''],
     504                                                                                [ 'best' ],
     505                                                                                [ 'high' ],
     506                                                                                [ 'autohigh' ],
     507                                                                                [ 'medium' ],
     508                                                                                [ 'autolow' ],
     509                                                                                [ 'low' ]
     510                                                                        ],
     511                                                                        setup : loadValue,
     512                                                                        commit : commitValue
     513                                                                },
     514                                                        ]
     515                                                },
     516                                                {
     517                                                        type : 'hbox',
     518                                                        widths : [ '50%', '50%' ],
     519                                                        children :
     520                                                        [
     521                                                                {
     522                                                                        id : 'align',
     523                                                                        type : 'select',
     524                                                                        label : editor.lang.flash.align,
     525                                                                        'default' : '',
     526                                                                        style : 'width : 100%;',
     527                                                                        items :
     528                                                                        [
     529                                                                                [ editor.lang.common.notSet , ''],
     530                                                                                [ editor.lang.image.alignLeft , 'left'],
     531                                                                                [ editor.lang.image.alignAbsBottom , 'absBottom'],
     532                                                                                [ editor.lang.image.alignAbsMiddle , 'absMiddle'],
     533                                                                                [ editor.lang.image.alignBaseline , 'baseline'],
     534                                                                                [ editor.lang.image.alignBottom , 'bottom'],
     535                                                                                [ editor.lang.image.alignMiddle , 'middle'],
     536                                                                                [ editor.lang.image.alignRight , 'right'],
     537                                                                                [ editor.lang.image.alignTextTop , 'textTop'],
     538                                                                                [ editor.lang.image.alignTop , 'top']
     539                                                                        ],
     540                                                                        setup : loadValue,
     541                                                                        commit : commitValue
     542                                                                },
     543                                                                {
     544                                                                        type : 'html',
     545                                                                        html : '<div></div>'
     546                                                                }
     547                                                        ]
     548                                                },
     549                                                {
     550                                                        type : 'vbox',
     551                                                        padding : 0,
     552                                                        children :
     553                                                        [
     554                                                                {
     555                                                                        type : 'html',
     556                                                                        html : CKEDITOR.tools.htmlEncode( editor.lang.flash.flashvars )
     557                                                                },
     558                                                                {
     559                                                                        type : 'checkbox',
     560                                                                        id : 'menu',
     561                                                                        label : editor.lang.flash.chkMenu,
     562                                                                        'default' : true,
     563                                                                        setup : loadValue,
     564                                                                        commit : commitValue
     565                                                                },
     566                                                                {
     567                                                                        type : 'checkbox',
     568                                                                        id : 'play',
     569                                                                        label : editor.lang.flash.chkPlay,
     570                                                                        'default' : true,
     571                                                                        setup : loadValue,
     572                                                                        commit : commitValue
     573                                                                },
     574                                                                {
     575                                                                        type : 'checkbox',
     576                                                                        id : 'loop',
     577                                                                        label : editor.lang.flash.chkLoop,
     578                                                                        'default' : true,
     579                                                                        setup : loadValue,
     580                                                                        commit : commitValue
     581                                                                },
     582                                                                {
     583                                                                        type : 'checkbox',
     584                                                                        id : 'allowFullScreen',
     585                                                                        label : editor.lang.flash.chkFull,
     586                                                                        'default' : true,
     587                                                                        setup : loadValue,
     588                                                                        commit : commitValue
     589                                                                }
     590                                                        ]
     591                                                }
     592                                        ]
     593                                },
     594                                {
     595                                        id : 'advanced',
     596                                        label : editor.lang.common.advancedTab,
     597                                        elements :
     598                                        [
     599                                                {
     600                                                        type : 'hbox',
     601                                                        widths : [ '45%', '55%' ],
     602                                                        children :
     603                                                        [
     604                                                                {
     605                                                                        type : 'text',
     606                                                                        id : 'id',
     607                                                                        label : editor.lang.common.id,
     608                                                                        setup : loadValue,
     609                                                                        commit : commitValue
     610                                                                },
     611                                                                {
     612                                                                        type : 'text',
     613                                                                        id : 'title',
     614                                                                        label : editor.lang.common.advisoryTitle,
     615                                                                        setup : loadValue,
     616                                                                        commit : commitValue
     617                                                                }
     618                                                        ]
     619                                                },
     620                                                {
     621                                                        type : 'hbox',
     622                                                        widths : [ '45%', '55%' ],
     623                                                        children :
     624                                                        [
     625                                                                {
     626                                                                        type : 'text',
     627                                                                        id : 'bgcolor',
     628                                                                        label : editor.lang.flash.bgcolor,
     629                                                                        setup : loadValue,
     630                                                                        commit : commitValue
     631                                                                },
     632                                                                {
     633                                                                        type : 'text',
     634                                                                        id : 'class',
     635                                                                        label : editor.lang.common.cssClass,
     636                                                                        setup : loadValue,
     637                                                                        commit : commitValue
     638                                                                }
     639                                                        ]
     640                                                },
     641                                                {
     642                                                        type : 'text',
     643                                                        id : 'style',
     644                                                        label : editor.lang.common.cssStyle,
     645                                                        setup : loadValue,
     646                                                        commit : commitValue
     647                                                }
     648                                        ]
     649                                }
     650                        ]
     651                };
     652        } );
     653})();
  • _source/plugins/flash/plugin.js

    Cannot display: file marked as a binary type.
    svn:mime-type = application/octet-stream
    
    Property changes on: _source/plugins/flash/images/flashlogo.gif
    ___________________________________________________________________
    Added: svn:mime-type
       + application/octet-stream
    
     
     1/*
     2Copyright (c) 2003-2009, CKSource - Frederico Knabben. All rights reserved.
     3For licensing, see LICENSE.html or http://ckeditor.com/license
     4*/
     5
     6CKEDITOR.plugins.add( 'flash',
     7{
     8        init : function( editor )
     9        {
     10                var flash = CKEDITOR.plugins.flash,
     11                        flashFilenameRegex = /\.swf(?:$|\?)/i,
     12                        numberRegex = /^\d+(?:\.\d+)?$/;
     13       
     14                function cssifyLength( length )
     15                {
     16                        if ( numberRegex.test( length ) )
     17                                return length + 'px';
     18                        return length;
     19                }
     20
     21                editor.addCommand( 'flash', new CKEDITOR.dialogCommand( 'flash' ) );
     22                editor.ui.addButton( 'Flash',
     23                        {
     24                                label : editor.lang.common.flash,
     25                                command : 'flash'
     26                        });
     27                CKEDITOR.dialog.add( 'flash', this.path + 'dialogs/flash.js' );
     28
     29                editor.addCss(
     30                        'img.cke_flash' +
     31                        '{' +
     32                                'background-image: url(' + CKEDITOR.getUrl( this.path + 'images/flashlogo.gif' ) + ');' +
     33                                'background-position: center center;' +
     34                                'background-repeat: no-repeat;' +
     35                                'border: 1px solid #a9a9a9;' +
     36                                'width: 80px;' +
     37                                'height: 80px;' +
     38                        '}'
     39                        );
     40
     41                editor.on( 'contentDom', function()
     42                        {
     43                                var rawObjectNodes = editor.document.$.getElementsByTagName( CKEDITOR.env.ie ? 'object' : 'cke:object' );
     44                                for ( var i = rawObjectNodes.length - 1, objectNode ; i >= 0 ; i-- )
     45                                {
     46                                        objectNode = new CKEDITOR.dom.element( rawObjectNodes[ i ] );
     47                                        if ( String( objectNode.getAttribute( 'classid' ) ).toLowerCase() != 'clsid:d27cdb6e-ae6d-11cf-96b8-444553540000' )
     48                                                continue;
     49
     50                                        var fakeElement = editor.createFakeElement( objectNode, 'cke_flash', 'flash', true );
     51                                        if ( objectNode.getAttribute( 'width' ) != null )
     52                                                fakeElement.setStyle( 'width', cssifyLength( objectNode.getAttribute( 'width' ) ) );
     53                                        if ( objectNode.getAttribute( 'height' ) != null )
     54                                                fakeElement.setStyle( 'height', cssifyLength( objectNode.getAttribute( 'height' ) ) );
     55                                        fakeElement.replace( objectNode );
     56                                }
     57
     58                                var rawEmbedNodes = editor.document.$.getElementsByTagName( CKEDITOR.env.ie ? 'embed' : 'cke:embed' );
     59                                for ( var i = rawEmbedNodes.length - 1, embedNode ; i >= 0 ; i-- )
     60                                {
     61                                        embedNode = new CKEDITOR.dom.element( rawEmbedNodes[ i ] );
     62                                        if ( embedNode.getAttribute( 'type' ) != 'application/x-shockwave-flash'
     63                                                && !flashFilenameRegex.test( embedNode.getAttribute( 'src' ) ) )
     64                                                continue;
     65                                        var fakeElement = editor.createFakeElement( embedNode, 'cke_flash', 'flash', true );
     66                                        if ( embedNode.getAttribute( 'width' ) != null )
     67                                                fakeElement.setStyle( 'width', cssifyLength( embedNode.getAttribute( 'width' ) ) );
     68                                        if ( embedNode.getAttribute( 'height' ) != null )
     69                                                fakeElement.setStyle( 'height', cssifyLength( embedNode.getAttribute( 'height' ) ) );
     70                                        fakeElement.replace( embedNode );
     71                                }
     72                        } );
     73        },
     74
     75        requires : [ 'fakeobjects' ]
     76} );
     77
     78CKEDITOR.tools.extend( CKEDITOR.config,
     79{
     80        flashUploadTab : true,
     81        flashUploadAction : 'nowhere.php',
     82        flashBrowseServer : true,
     83
     84        /**
     85         * Save as EMBED tag only. This tag is unrecommended.
     86         * @type Boolean
     87         * @default false
     88         */
     89        flashEmbedTagOnly : false,
     90
     91        /**
     92         * Add EMBED tag as alternative: &lt;object&gt&lt;embed&gt&lt;/embed&gt&lt;/object&gt
     93         * @type Boolean
     94         * @default false
     95         */
     96        flashAddEmbedTag : true,
     97
     98        /**
     99         * Use embedTagOnly and addEmbedTag values on edit.
     100         * @type Boolean
     101         * @default false
     102         */
     103        flashConvertOnEdit : false
     104} );
  • _source/plugins/toolbar/plugin.js

     
    218218                'Subscript', 'Superscript', '-',
    219219                'SelectAll', 'RemoveFormat', '-',
    220220                'Link', 'Unlink', 'Anchor', '-',
    221                 'Image', '-',
     221                'Image', 'Flash', '-',
    222222                'Table', 'Smiley', 'HorizontalRule', 'SpecialChar', 'PageBreak'
    223223        ]
    224224];
  • _source/skins/default/dialog.css

     
    666666{
    667667        white-space : normal;
    668668        border : 2px ridge black;
    669         overflow : scroll;
     669        overflow : auto;
    670670        height : 160px;
    671671        width : 390px;
    672672        padding : 2px;
  • _source/skins/default/toolbar.css

     
    389389        background-position: 0 -1152px;
    390390}
    391391
     392.cke_skin_default a.cke_button_flash .cke_icon
     393{
     394        background-position: 0 -592px;
     395}
     396
    392397.cke_skin_default a.cke_button_pastefromword .cke_icon
    393398{
    394399        background-position: 0 -160px;
  • _source/core/config.js

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

     
    1919        if ( attributes._cke_saved_href )
    2020                attributes.href = attributes._cke_saved_href;
    2121
    22         /**
    23          * The element name.
    24          * @type String
    25          * @example
    26          */
    2722        this.name = name;
    2823
    2924        /**
     
    6762        };
    6863
    6964        var ckeAttrRegex = /^_cke/,
    70                 ckeClassRegex = /(^|\s+)cke_[^\s]*/g;
     65                ckeNamespaceRegex = /^cke:/,
     66                ckeClassRegex = /(^|\s+)cke_[^\s]*/g,
     67                ckeStyleWidthRegex = /width\s*:\s*(\d+)/i,
     68                ckeStyleHeightRegex = /height\s*:\s*(\d+)/i;
    7169
    7270        CKEDITOR.htmlParser.element.prototype =
    7371        {
     
    107105                writeHtml : function( writer )
    108106                {
    109107                        var attributes = this.attributes;
     108
     109                        // Don't write <?xml:namespace prefix="cke"> tags, the cke namespace should be invisible.
     110                        if ( this.name == '?xml:namespace' && attributes.prefix == 'cke' )
     111                                return;
    110112                       
    111113                        // The "_cke_realelement" attribute indicates that the current
    112114                        // element is a placeholder for another element.
    113115                        if ( attributes._cke_realelement )
    114116                        {
    115117                                var realFragment = new CKEDITOR.htmlParser.fragment.fromHtml( decodeURIComponent( attributes._cke_realelement ) );
     118
     119                                // If _cke_resizable is set, and the fake element contains inline CSS width
     120                                // and height; then sync the width and height to the real element.
     121                                if ( attributes._cke_resizable && ( 'style' in attributes ) )
     122                                {
     123                                        var match = ckeStyleWidthRegex.exec( attributes.style ),
     124                                                width = match ? match[1] : null;
     125                                        match = ckeStyleHeightRegex.exec( attributes.style );
     126                                        var height = match ? match[1] : null;
     127                                       
     128                                        // Find out the first child in the fragment whose name isn't
     129                                        // ?xml:namespace.
     130                                        var targetElement = null;
     131                                        for ( var i = 0 ; i < realFragment.children.length ; i++ )
     132                                        {
     133                                                if ( realFragment.children[i].name != '?xml:namespace' )
     134                                                {
     135                                                        targetElement = realFragment.children[i];
     136                                                        break;
     137                                                }
     138                                        }
     139
     140                                        if ( targetElement && ( width != null || height != null ) )
     141                                        {
     142                                                targetElement.attributes.width = width;
     143                                                targetElement.attributes.height = height;
     144
     145                                                // Special case for #2916: If there's an EMBED inside an OBJECT, we need
     146                                                // to set the EMBED's dimensions as well.
     147                                                if ( targetElement.name == 'cke:object' )
     148                                                {
     149                                                        for ( var i = 0 ; i < targetElement.children.length ; i++ )
     150                                                        {
     151                                                                var child = targetElement.children[i];
     152                                                                if ( child.name == 'cke:embed' )
     153                                                                {
     154                                                                        child.attributes.width = width;
     155                                                                        child.attributes.height = height;
     156                                                                        break;
     157                                                                }
     158                                                        }
     159                                                }
     160                                        }
     161                                }
     162
    116163                                realFragment.writeHtml( writer );
    117164                                return;
    118165                        }
     
    125172                                return;
    126173                        }
    127174               
     175                        // Ignore cke: prefixes when writing HTML.
     176                        var writeName = this.name.replace( ckeNamespaceRegex, '' );
     177
    128178                        // Open element tag.
    129                         writer.openTag( this.name, this.attributes );
     179                        writer.openTag( writeName, this.attributes );
    130180
    131181                        // Copy all attributes to an array.
    132182                        var attribsArray = [];
     
    158208                        }
    159209
    160210                        // Close the tag.
    161                         writer.openTagClose( this.name, this.isEmpty );
     211                        writer.openTagClose( writeName, this.isEmpty );
    162212
    163213                        if ( !this.isEmpty )
    164214                        {
     
    166216                                CKEDITOR.htmlParser.fragment.prototype.writeHtml.apply( this, arguments );
    167217
    168218                                // Close the element.
    169                                 writer.closeTag( this.name );
     219                                writer.closeTag( writeName );
    170220                        }
    171221                }
    172222        };
  • _source/core/dom/element.js

     
    432432                        return dtd;
    433433                },
    434434
    435                 getElementsByTag : function( tagName )
     435                getElementsByTag : function( tagName, prefix )
    436436                {
     437                        if ( !CKEDITOR.env.ie && prefix )
     438                                tagName = prefix + ':' + tagName;
    437439                        return new CKEDITOR.dom.nodeList( this.$.getElementsByTagName( tagName ) );
    438440                },
    439441
     
    551553                        // Cache the lowercased name inside a closure.
    552554                        var nodeName = this.$.nodeName.toLowerCase();
    553555
     556                        if ( CKEDITOR.env.ie )
     557                        {
     558                                var scopeName = this.$.scopeName.toLowerCase();
     559                                if ( scopeName != 'html' )
     560                                        nodeName = scopeName + ':' + nodeName;
     561                        }
     562
    554563                        return (
    555564                        /** @ignore */
    556565                        this.getName = function()
© 2003 – 2022, CKSource sp. z o.o. sp.k. All rights reserved. | Terms of use | Privacy policy