Changeset 3113


Ignore:
Timestamp:
02/27/09 12:04:32 (5 years ago)
Author:
fredck
Message:

#2971 : Introduced the Format combo and the panel and combo systems.

Location:
CKEditor/trunk
Files:
12 added
15 edited

Legend:

Unmodified
Added
Removed
  • CKEditor/trunk/_source/core/config.js

    r3112 r3113  
    148148         */ 
    149149 
    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,showblocks,sourcearea,table,specialchar,tab,templates,toolbar,undo,wysiwygarea', 
     150        plugins : 'basicstyles,blockquote,button,clipboard,elementspath,find,flash,format,horizontalrule,htmldataprocessor,image,indent,justify,keystrokes,link,list,newpage,pagebreak,pastefromword,pastetext,preview,print,removeformat,smiley,showblocks,sourcearea,table,specialchar,tab,templates,toolbar,undo,wysiwygarea', 
    151151 
    152152        /** 
  • CKEditor/trunk/_source/core/dom/domobject.js

    r3086 r3113  
    148148        domObjectProto.setCustomData = function( key, value ) 
    149149        { 
    150                 var expandoNumber = this.$._cke_expando || ( this.$._cke_expando = CKEDITOR.tools.getNextNumber() ), 
     150                var expandoNumber = this.getUniqueId(), 
    151151                        dataSlot = customData[ expandoNumber ] || ( customData[ expandoNumber ] = {} ); 
    152152 
     
    187187        }; 
    188188 
     189        domObjectProto.getUniqueId = function() 
     190        { 
     191                return this.$._cke_expando || ( this.$._cke_expando = CKEDITOR.tools.getNextNumber() ); 
     192        }; 
     193 
    189194        // Implement CKEDITOR.event. 
    190195        CKEDITOR.event.implementOn( domObjectProto ); 
  • CKEditor/trunk/_source/core/dom/element.js

    r3110 r3113  
    168168                }, 
    169169 
     170                hasClass : function( className ) 
     171                { 
     172                        var regex = new RegExp( '(?:^|\\s+)' + className + '(?=\\s|$)', '' ); 
     173                        return regex.test( this.$.className ); 
     174                }, 
     175 
    170176                /** 
    171177                 * Append a node as a child of this element. 
     
    196202 
    197203                        return node; 
     204                }, 
     205 
     206                appendHtml : function( html ) 
     207                { 
     208                        var temp = new CKEDITOR.dom.element( 'div', this.getDocument() ); 
     209                        temp.setHtml( html ); 
     210                        temp.moveChildren( this ); 
    198211                }, 
    199212 
  • CKEditor/trunk/_source/core/editor.js

    r3094 r3113  
    7979                                        CKEDITOR.tools.extend( editor.config, instanceConfig, true ); 
    8080 
    81                                 // Fire the "configLoaded" event. 
    82                                 editor.fireOnce( 'configLoaded' ); 
    83  
    84                                 loadLang( editor ); 
     81                                onConfigLoaded( editor ); 
    8582                        }); 
    8683 
     
    9693 
    9794        // ##### END: Config Privates 
     95 
     96        var onConfigLoaded = function( editor ) 
     97        { 
     98                // Set config related properties. 
     99 
     100                editor.skinPath = CKEDITOR.getUrl( 
     101                        '_source/' +    // %REMOVE_LINE% 
     102                        'skins/' + editor.config.skin + '/' ); 
     103 
     104                // Fire the "configLoaded" event. 
     105                editor.fireOnce( 'configLoaded' ); 
     106 
     107                // Load language file. 
     108                loadLang( editor ); 
     109        }; 
    98110 
    99111        var loadLang = function( editor ) 
  • CKEditor/trunk/_source/core/plugins.js

    r2948 r3113  
    4949                                                if ( requiredPlugins.length ) 
    5050                                                        loadPlugins.call( this, requiredPlugins ); 
    51                                                 else if ( callback ) 
    52                                                         callback.call( scope || window, allPlugins ); 
     51                                                else 
     52                                                { 
     53                                                        // Call the "onLoad" function for all plugins. 
     54                                                        for ( pluginName in allPlugins ) 
     55                                                        { 
     56                                                                plugin = allPlugins[ pluginName ]; 
     57                                                                if ( plugin.onLoad && !plugin.onLoad._called ) 
     58                                                                { 
     59                                                                        plugin.onLoad(); 
     60                                                                        plugin.onLoad._called = 1; 
     61                                                                } 
     62                                                        } 
     63 
     64                                                        // Call the callback. 
     65                                                        if ( callback ) 
     66                                                                callback.call( scope || window, allPlugins ); 
     67                                                } 
    5368                                        } 
    5469                                        , this); 
  • CKEditor/trunk/_source/core/tools.js

    r3088 r3113  
    99 */ 
    1010 
    11 /** 
    12  * Utility functions. 
    13  * @namespace 
    14  * @example 
    15  */ 
    16 CKEDITOR.tools = 
     11(function() 
    1712{ 
    18         arrayCompare : function( arrayA, arrayB ) 
     13        var functions = []; 
     14 
     15        /** 
     16         * Utility functions. 
     17         * @namespace 
     18         * @example 
     19         */ 
     20        CKEDITOR.tools = 
    1921        { 
    20                 if ( !arrayA && !arrayB ) 
     22                arrayCompare : function( arrayA, arrayB ) 
     23                { 
     24                        if ( !arrayA && !arrayB ) 
     25                                return true; 
     26 
     27                        if ( !arrayA || !arrayB || arrayA.length != arrayB.length ) 
     28                                return false; 
     29 
     30                        for ( var i = 0 ; i < arrayA.length ; i++ ) 
     31                        { 
     32                                if ( arrayA[ i ] != arrayB[ i ] ) 
     33                                        return false; 
     34                        } 
     35 
    2136                        return true; 
    22  
    23                 if ( !arrayA || !arrayB || arrayA.length != arrayB.length ) 
    24                         return false; 
    25  
    26                 for ( var i = 0 ; i < arrayA.length ; i++ ) 
    27                 { 
    28                         if ( arrayA[ i ] != arrayB[ i ] ) 
    29                                 return false; 
     37                }, 
     38 
     39                /** 
     40                 * Copy the properties from one object to another. By default, properties 
     41                 * already present in the target object <strong>are not</strong> overwritten. 
     42                 * @param {Object} target The object to be extended. 
     43                 * @param {Object} source[,souce(n)] The objects from which copy 
     44                 *              properties. Any number of objects can be passed to this function. 
     45                 * @param {Boolean} [overwrite] Indicates that properties already present 
     46                 *              in the target object must be overwritten. This must be the last 
     47                 *              parameter in the function call. 
     48                 * @returns {Object} the extended object (target). 
     49                 * @example 
     50                 * // Create the sample object. 
     51                 * var myObject = 
     52                 * { 
     53                 *     prop1 : true 
     54                 * }; 
     55                 * 
     56                 * // Extend the above object with two properties. 
     57                 * CKEDITOR.tools.extend( myObject, 
     58                 *     { 
     59                 *         prop2 : true, 
     60                 *         prop3 : true 
     61                 *     } ); 
     62                 * 
     63                 * // Alert "prop1", "prop2" and "prop3". 
     64                 * for ( var p in myObject ) 
     65                 *     alert( p ); 
     66                 */ 
     67                extend : function( target ) 
     68                { 
     69                        var argsLength = arguments.length, 
     70                                overwrite = arguments[ argsLength - 1 ]; 
     71 
     72                        if ( typeof overwrite == 'boolean' ) 
     73                                argsLength--; 
     74                        else 
     75                                overwrite = false; 
     76 
     77                        for ( var i = 1 ; i < argsLength ; i++ ) 
     78                        { 
     79                                var source = arguments[ i ]; 
     80 
     81                                for ( var propertyName in source ) 
     82                                { 
     83                                        if ( overwrite || target[ propertyName ] == undefined ) 
     84                                                target[ propertyName ] = source[ propertyName ]; 
     85                                } 
     86                        } 
     87 
     88                        return target; 
     89                }, 
     90 
     91                /** 
     92                 * Creates an object which is an instance of a class which prototype is a 
     93                 * predefined object. All properties defined in the source object are 
     94                 * automatically inherited by the resulting object, including future 
     95                 * changes to it. 
     96                 * @param {Object} source The source object to be used as the prototype for 
     97                 *              the final object. 
     98                 * @returns {Object} The resulting copy. 
     99                 */ 
     100                prototypedCopy : function( source ) 
     101                { 
     102                        var copy = function() 
     103                        {}; 
     104                        copy.prototype = source; 
     105                        return new copy(); 
     106                }, 
     107 
     108                /** 
     109                 * Checks if an object is an Array. 
     110                 * @param {Object} object The object to be checked. 
     111                 * @type Boolean 
     112                 * @returns <i>true</i> if the object is an Array, otherwise <i>false</i>. 
     113                 * @example 
     114                 * alert( CKEDITOR.tools.isArray( [] ) );      // "true" 
     115                 * alert( CKEDITOR.tools.isArray( 'Test' ) );  // "false" 
     116                 */ 
     117                isArray : function( object ) 
     118                { 
     119                        return ( !!object && object instanceof Array ); 
     120                }, 
     121 
     122                /** 
     123                 * Transforms a CSS property name to its relative DOM style name. 
     124                 * @param {String} cssName The CSS property name. 
     125                 * @returns {String} The transformed name. 
     126                 * @example 
     127                 * alert( CKEDITOR.tools.cssStyleToDomStyle( 'background-color' ) );  // "backgroundColor" 
     128                 * alert( CKEDITOR.tools.cssStyleToDomStyle( 'float' ) );             // "cssFloat" 
     129                 */ 
     130                cssStyleToDomStyle : function( cssName ) 
     131                { 
     132                        if ( cssName == 'float' ) 
     133                                return 'cssFloat'; 
     134                        else 
     135                        { 
     136                                return cssName.replace( /-./g, function( match ) 
     137                                        { 
     138                                                return match.substr( 1 ).toUpperCase(); 
     139                                        }); 
     140                        } 
     141                }, 
     142 
     143                /** 
     144                 * Replace special HTML characters in a string with their relative HTML 
     145                 * entity values. 
     146                 * @param {String} text The string to be encoded. 
     147                 * @returns {String} The encode string. 
     148                 * @example 
     149                 * alert( CKEDITOR.tools.htmlEncode( 'A > B & C < D' ) );  // "A &amp;gt; B &amp;amp; C &amp;lt; D" 
     150                 */ 
     151                htmlEncode : function( text ) 
     152                { 
     153                        var standard = function( text ) 
     154                        { 
     155                                var span = new CKEDITOR.dom.element( 'span' ); 
     156                                span.setText( text ); 
     157                                return span.getHtml(); 
     158                        }; 
     159 
     160                        this.htmlEncode = ( standard( '>' ) == '>' ) ? 
     161                                function( text ) 
     162                                { 
     163                                        // WebKit does't encode the ">" character, which makes sense, but 
     164                                        // it's different than other browsers. 
     165                                        return standard( text ).replace( />/g, '&gt;' ); 
     166                                } : 
     167                                standard; 
     168 
     169                        return this.htmlEncode( text ); 
     170                }, 
     171 
     172                /** 
     173                 * Gets a unique number for this CKEDITOR execution session. It returns 
     174                 * progressive numbers starting at 1. 
     175                 * @function 
     176                 * @returns {Number} A unique number. 
     177                 * @example 
     178                 * alert( CKEDITOR.tools.<b>getNextNumber()</b> );  // "1" (e.g.) 
     179                 * alert( CKEDITOR.tools.<b>getNextNumber()</b> );  // "2" 
     180                 */ 
     181                getNextNumber : (function() 
     182                { 
     183                        var last = 0; 
     184                        return function() 
     185                        { 
     186                                return ++last; 
     187                        }; 
     188                })(), 
     189 
     190                /** 
     191                 * Creates a function override. 
     192                 * @param {Function} originalFunction The function to be overridden. 
     193                 * @param {Function} functionBuilder A function that returns the new 
     194                 *              function. The original function reference will be passed to this 
     195                 *              function. 
     196                 * @returns {Function} The new function. 
     197                 * @example 
     198                 * var example = 
     199                 * { 
     200                 *     myFunction : function( name ) 
     201                 *     { 
     202                 *         alert( 'Name: ' + name ); 
     203                 *     } 
     204                 * }; 
     205                 * 
     206                 * example.myFunction = CKEDITOR.tools.override( example.myFunction, function( myFunctionOriginal ) 
     207                 *     { 
     208                 *         return function( name ) 
     209                 *             { 
     210                 *                 alert( 'Override Name: ' + name ); 
     211                 *                 myFunctionOriginal.call( this, name ); 
     212                 *             }; 
     213                 *     }); 
     214                 */ 
     215                override : function( originalFunction, functionBuilder ) 
     216                { 
     217                        return functionBuilder( originalFunction ); 
     218                }, 
     219 
     220                /** 
     221                 * Executes a function after specified delay. 
     222                 * @param {Function} func The function to be executed. 
     223                 * @param {Number} [milliseconds] The amount of time (millisecods) to wait 
     224                 *              to fire the function execution. Defaults to zero. 
     225                 * @param {Object} [scope] The object to hold the function execution scope 
     226                 *              (the "this" object). By default the "window" object. 
     227                 * @param {Object|Array} [args] A single object, or an array of objects, to 
     228                 *              pass as arguments to the function. 
     229                 * @param {Object} [ownerWindow] The window that will be used to set the 
     230                 *              timeout. By default the current "window". 
     231                 * @returns {Object} A value that can be used to cancel the function execution. 
     232                 * @example 
     233                 * CKEDITOR.tools.<b>setTimeout( 
     234                 *     function() 
     235                 *     { 
     236                 *         alert( 'Executed after 2 seconds' ); 
     237                 *     }, 
     238                 *     2000 )</b>; 
     239                 */ 
     240                setTimeout : function( func, milliseconds, scope, args, ownerWindow ) 
     241                { 
     242                        if ( !ownerWindow ) 
     243                                ownerWindow = window; 
     244 
     245                        if ( !scope ) 
     246                                scope = ownerWindow; 
     247 
     248                        return ownerWindow.setTimeout( 
     249                                function() 
     250                                { 
     251                                        if ( args ) 
     252                                                func.apply( scope, [].concat( args ) ) ; 
     253                                        else 
     254                                                func.apply( scope ) ; 
     255                                }, 
     256                                milliseconds || 0 ); 
     257                }, 
     258 
     259                /** 
     260                 * Remove spaces from the start and the end of a string. The following 
     261                 * characters are removed: space, tab, line break, line feed. 
     262                 * @function 
     263                 * @param {String} str The text from which remove the spaces. 
     264                 * @returns {String} The modified string without the boundary spaces. 
     265                 * @example 
     266                 * alert( CKEDITOR.tools.trim( '  example ' );  // "example" 
     267                 */ 
     268                trim : (function() 
     269                { 
     270                        // We are not using \s because we don't want "non-breaking spaces" to be caught. 
     271                        var trimRegex = /(?:^[ \t\n\r]+)|(?:[ \t\n\r]+$)/g; 
     272                        return function( str ) 
     273                        { 
     274                                return str.replace( trimRegex, '' ) ; 
     275                        }; 
     276                })(), 
     277 
     278                /** 
     279                 * Remove spaces from the start (left) of a string. The following 
     280                 * characters are removed: space, tab, line break, line feed. 
     281                 * @function 
     282                 * @param {String} str The text from which remove the spaces. 
     283                 * @returns {String} The modified string excluding the removed spaces. 
     284                 * @example 
     285                 * alert( CKEDITOR.tools.ltrim( '  example ' );  // "example " 
     286                 */ 
     287                ltrim : (function() 
     288                { 
     289                        // We are not using \s because we don't want "non-breaking spaces" to be caught. 
     290                        var trimRegex = /^[ \t\n\r]+/g; 
     291                        return function( str ) 
     292                        { 
     293                                return str.replace( trimRegex, '' ) ; 
     294                        }; 
     295                })(), 
     296 
     297                /** 
     298                 * Remove spaces from the end (right) of a string. The following 
     299                 * characters are removed: space, tab, line break, line feed. 
     300                 * @function 
     301                 * @param {String} str The text from which remove the spaces. 
     302                 * @returns {String} The modified string excluding the removed spaces. 
     303                 * @example 
     304                 * alert( CKEDITOR.tools.ltrim( '  example ' );  // "  example" 
     305                 */ 
     306                rtrim : (function() 
     307                { 
     308                        // We are not using \s because we don't want "non-breaking spaces" to be caught. 
     309                        var trimRegex = /[ \t\n\r]+$/g; 
     310                        return function( str ) 
     311                        { 
     312                                return str.replace( trimRegex, '' ) ; 
     313                        }; 
     314                })(), 
     315 
     316                /** 
     317                 * Returns the index of an element in an array. 
     318                 * @param {Array} array The array to be searched. 
     319                 * @param {Object} entry The element to be found. 
     320                 * @returns {Number} The (zero based) index of the first entry that matches 
     321                 *              the entry, or -1 if not found. 
     322                 * @example 
     323                 * var letters = [ 'a', 'b', 0, 'c', false ];  
     324                 * alert( CKEDITOR.tools.indexOf( letters, '0' ) );  "-1" because 0 !== '0'  
     325                 * alert( CKEDITOR.tools.indexOf( letters, false ) );  "4" because 0 !== false  
     326                 */ 
     327                indexOf : 
     328                        // #2514: We should try to use Array.indexOf if it does exist. 
     329                        ( Array.prototype.indexOf ) ? 
     330                                function( array, entry ) 
     331                                        { 
     332                                                return array.indexOf( entry ); 
     333                                        } 
     334                        : 
     335                                function( array, entry ) 
     336                                { 
     337                                        for ( var i = 0, len = array.length ; i < len ; i++ ) 
     338                                        { 
     339                                                if ( array[ i ] === entry ) 
     340                                                        return i; 
     341                                        } 
     342                                        return -1; 
     343                                }, 
     344 
     345                bind : function( func, obj ) 
     346                { 
     347                        return function() { return func.apply( obj, arguments ); }; 
     348                }, 
     349 
     350                createClass : function( definition ) 
     351                { 
     352                        var $ = definition.$, 
     353                                baseClass = definition.base, 
     354                                privates = definition.privates || definition._, 
     355                                proto = definition.proto, 
     356                                statics = definition.statics; 
     357 
     358                        if ( privates ) 
     359                        { 
     360                                var originalConstructor = $; 
     361                                $ = function() 
     362                                { 
     363                                        originalConstructor.apply( this, arguments ); 
     364                                         
     365                                        // Create (and get) the private namespace. 
     366                                        var _ = this._ || ( this._ = {} ); 
     367                                         
     368                                        // Make some magic so "this" will refer to the main 
     369                                        // instance when coding private functions. 
     370                                        for ( var privateName in privates )  
     371                                        { 
     372                                                var priv = privates[ privateName ]; 
     373                                                 
     374                                                _[ privateName ] =  
     375                                                        ( typeof priv == 'function' ) ? CKEDITOR.tools.bind( priv, this ) : priv; 
     376                                        } 
     377                                }; 
     378                        } 
     379 
     380                        if ( baseClass ) 
     381                        { 
     382                                $.prototype = this.prototypedCopy( baseClass.prototype ); 
     383 
     384                                $.prototype.base = function() 
     385                                { 
     386                                        this.base = baseClass.prototype.base; 
     387                                        baseClass.apply( this, arguments ); 
     388                                        this.base = arguments.callee; 
     389                                }; 
     390                        } 
     391 
     392                        if ( proto ) 
     393                                this.extend( $.prototype, proto, true ); 
     394 
     395                        if ( statics ) 
     396                                this.extend( $, statics, true ); 
     397 
     398                        return $; 
     399                }, 
     400 
     401                addFunction : function( fn, scope ) 
     402                { 
     403                        return functions.push( function() 
     404                                { 
     405                                        fn.apply( scope || this, arguments ); 
     406                                }) - 1; 
     407                }, 
     408 
     409                callFunction : function( index ) 
     410                { 
     411                        var fn = functions[ index ]; 
     412                        return fn.apply( window, Array.prototype.slice.call( arguments, 1 ) ); 
    30413                } 
    31  
    32                 return true; 
    33         }, 
    34  
    35         /** 
    36          * Copy the properties from one object to another. By default, properties 
    37          * already present in the target object <strong>are not</strong> overwritten. 
    38          * @param {Object} target The object to be extended. 
    39          * @param {Object} source[,souce(n)] The objects from which copy 
    40          *              properties. Any number of objects can be passed to this function. 
    41          * @param {Boolean} [overwrite] Indicates that properties already present 
    42          *              in the target object must be overwritten. This must be the last 
    43          *              parameter in the function call. 
    44          * @returns {Object} the extended object (target). 
    45          * @example 
    46          * // Create the sample object. 
    47          * var myObject = 
    48          * { 
    49          *     prop1 : true 
    50          * }; 
    51          * 
    52          * // Extend the above object with two properties. 
    53          * CKEDITOR.tools.extend( myObject, 
    54          *     { 
    55          *         prop2 : true, 
    56          *         prop3 : true 
    57          *     } ); 
    58          * 
    59          * // Alert "prop1", "prop2" and "prop3". 
    60          * for ( var p in myObject ) 
    61          *     alert( p ); 
    62          */ 
    63         extend : function( target ) 
    64         { 
    65                 var argsLength = arguments.length, 
    66                         overwrite = arguments[ argsLength - 1 ]; 
    67  
    68                 if ( typeof overwrite == 'boolean' ) 
    69                         argsLength--; 
    70                 else 
    71                         overwrite = false; 
    72  
    73                 for ( var i = 1 ; i < argsLength ; i++ ) 
    74                 { 
    75                         var source = arguments[ i ]; 
    76  
    77                         for ( var propertyName in source ) 
    78                         { 
    79                                 if ( overwrite || target[ propertyName ] == undefined ) 
    80                                         target[ propertyName ] = source[ propertyName ]; 
    81                         } 
    82                 } 
    83  
    84                 return target; 
    85         }, 
    86  
    87         /** 
    88          * Creates an object which is an instance of a class which prototype is a 
    89          * predefined object. All properties defined in the source object are 
    90          * automatically inherited by the resulting object, including future 
    91          * changes to it. 
    92          * @param {Object} source The source object to be used as the prototype for 
    93          *              the final object. 
    94          * @returns {Object} The resulting copy. 
    95          */ 
    96         prototypedCopy : function( source ) 
    97         { 
    98                 var copy = function() 
    99                 {}; 
    100                 copy.prototype = source; 
    101                 return new copy(); 
    102         }, 
    103  
    104         /** 
    105          * Checks if an object is an Array. 
    106          * @param {Object} object The object to be checked. 
    107          * @type Boolean 
    108          * @returns <i>true</i> if the object is an Array, otherwise <i>false</i>. 
    109          * @example 
    110          * alert( CKEDITOR.tools.isArray( [] ) );      // "true" 
    111          * alert( CKEDITOR.tools.isArray( 'Test' ) );  // "false" 
    112          */ 
    113         isArray : function( object ) 
    114         { 
    115                 return ( !!object && object instanceof Array ); 
    116         }, 
    117  
    118         /** 
    119          * Transforms a CSS property name to its relative DOM style name. 
    120          * @param {String} cssName The CSS property name. 
    121          * @returns {String} The transformed name. 
    122          * @example 
    123          * alert( CKEDITOR.tools.cssStyleToDomStyle( 'background-color' ) );  // "backgroundColor" 
    124          * alert( CKEDITOR.tools.cssStyleToDomStyle( 'float' ) );             // "cssFloat" 
    125          */ 
    126         cssStyleToDomStyle : function( cssName ) 
    127         { 
    128                 if ( cssName == 'float' ) 
    129                         return 'cssFloat'; 
    130                 else 
    131                 { 
    132                         return cssName.replace( /-./g, function( match ) 
    133                                 { 
    134                                         return match.substr( 1 ).toUpperCase(); 
    135                                 }); 
    136                 } 
    137         }, 
    138  
    139         /** 
    140          * Replace special HTML characters in a string with their relative HTML 
    141          * entity values. 
    142          * @param {String} text The string to be encoded. 
    143          * @returns {String} The encode string. 
    144          * @example 
    145          * alert( CKEDITOR.tools.htmlEncode( 'A > B & C < D' ) );  // "A &amp;gt; B &amp;amp; C &amp;lt; D" 
    146          */ 
    147         htmlEncode : function( text ) 
    148         { 
    149                 var standard = function( text ) 
    150                 { 
    151                         var span = new CKEDITOR.dom.element( 'span' ); 
    152                         span.setText( text ); 
    153                         return span.getHtml(); 
    154                 }; 
    155  
    156                 this.htmlEncode = ( standard( '>' ) == '>' ) ? 
    157                         function( text ) 
    158                         { 
    159                                 // WebKit does't encode the ">" character, which makes sense, but 
    160                                 // it's different than other browsers. 
    161                                 return standard( text ).replace( />/g, '&gt;' ); 
    162                         } : 
    163                         standard; 
    164  
    165                 return this.htmlEncode( text ); 
    166         }, 
    167  
    168         /** 
    169          * Gets a unique number for this CKEDITOR execution session. It returns 
    170          * progressive numbers starting at 1. 
    171          * @function 
    172          * @returns {Number} A unique number. 
    173          * @example 
    174          * alert( CKEDITOR.tools.<b>getNextNumber()</b> );  // "1" (e.g.) 
    175          * alert( CKEDITOR.tools.<b>getNextNumber()</b> );  // "2" 
    176          */ 
    177         getNextNumber : (function() 
    178         { 
    179                 var last = 0; 
    180                 return function() 
    181                 { 
    182                         return ++last; 
    183                 }; 
    184         })(), 
    185  
    186         /** 
    187          * Creates a function override. 
    188          * @param {Function} originalFunction The function to be overridden. 
    189          * @param {Function} functionBuilder A function that returns the new 
    190          *              function. The original function reference will be passed to this 
    191          *              function. 
    192          * @returns {Function} The new function. 
    193          * @example 
    194          * var example = 
    195          * { 
    196          *     myFunction : function( name ) 
    197          *     { 
    198          *         alert( 'Name: ' + name ); 
    199          *     } 
    200          * }; 
    201          * 
    202          * example.myFunction = CKEDITOR.tools.override( example.myFunction, function( myFunctionOriginal ) 
    203          *     { 
    204          *         return function( name ) 
    205          *             { 
    206          *                 alert( 'Override Name: ' + name ); 
    207          *                 myFunctionOriginal.call( this, name ); 
    208          *             }; 
    209          *     }); 
    210          */ 
    211         override : function( originalFunction, functionBuilder ) 
    212         { 
    213                 return functionBuilder( originalFunction ); 
    214         }, 
    215  
    216         /** 
    217          * Executes a function after specified delay. 
    218          * @param {Function} func The function to be executed. 
    219          * @param {Number} [milliseconds] The amount of time (millisecods) to wait 
    220          *              to fire the function execution. Defaults to zero. 
    221          * @param {Object} [scope] The object to hold the function execution scope 
    222          *              (the "this" object). By default the "window" object. 
    223          * @param {Object|Array} [args] A single object, or an array of objects, to 
    224          *              pass as arguments to the function. 
    225          * @param {Object} [ownerWindow] The window that will be used to set the 
    226          *              timeout. By default the current "window". 
    227          * @returns {Object} A value that can be used to cancel the function execution. 
    228          * @example 
    229          * CKEDITOR.tools.<b>setTimeout( 
    230          *     function() 
    231          *     { 
    232          *         alert( 'Executed after 2 seconds' ); 
    233          *     }, 
    234          *     2000 )</b>; 
    235          */ 
    236         setTimeout : function( func, milliseconds, scope, args, ownerWindow ) 
    237         { 
    238                 if ( !ownerWindow ) 
    239                         ownerWindow = window; 
    240  
    241                 if ( !scope ) 
    242                         scope = ownerWindow; 
    243  
    244                 return ownerWindow.setTimeout( 
    245                         function() 
    246                         { 
    247                                 if ( args ) 
    248                                         func.apply( scope, [].concat( args ) ) ; 
    249                                 else 
    250                                         func.apply( scope ) ; 
    251                         }, 
    252                         milliseconds || 0 ); 
    253         }, 
    254  
    255         /** 
    256          * Remove spaces from the start and the end of a string. The following 
    257          * characters are removed: space, tab, line break, line feed. 
    258          * @function 
    259          * @param {String} str The text from which remove the spaces. 
    260          * @returns {String} The modified string without the boundary spaces. 
    261          * @example 
    262          * alert( CKEDITOR.tools.trim( '  example ' );  // "example" 
    263          */ 
    264         trim : (function() 
    265         { 
    266                 // We are not using \s because we don't want "non-breaking spaces" to be caught. 
    267                 var trimRegex = /(?:^[ \t\n\r]+)|(?:[ \t\n\r]+$)/g; 
    268                 return function( str ) 
    269                 { 
    270                         return str.replace( trimRegex, '' ) ; 
    271                 }; 
    272         })(), 
    273  
    274         /** 
    275          * Remove spaces from the start (left) of a string. The following 
    276          * characters are removed: space, tab, line break, line feed. 
    277          * @function 
    278          * @param {String} str The text from which remove the spaces. 
    279          * @returns {String} The modified string excluding the removed spaces. 
    280          * @example 
    281          * alert( CKEDITOR.tools.ltrim( '  example ' );  // "example " 
    282          */ 
    283         ltrim : (function() 
    284         { 
    285                 // We are not using \s because we don't want "non-breaking spaces" to be caught. 
    286                 var trimRegex = /^[ \t\n\r]+/g; 
    287                 return function( str ) 
    288                 { 
    289                         return str.replace( trimRegex, '' ) ; 
    290                 }; 
    291         })(), 
    292  
    293         /** 
    294          * Remove spaces from the end (right) of a string. The following 
    295          * characters are removed: space, tab, line break, line feed. 
    296          * @function 
    297          * @param {String} str The text from which remove the spaces. 
    298          * @returns {String} The modified string excluding the removed spaces. 
    299          * @example 
    300          * alert( CKEDITOR.tools.ltrim( '  example ' );  // "  example" 
    301          */ 
    302         rtrim : (function() 
    303         { 
    304                 // We are not using \s because we don't want "non-breaking spaces" to be caught. 
    305                 var trimRegex = /[ \t\n\r]+$/g; 
    306                 return function( str ) 
    307                 { 
    308                         return str.replace( trimRegex, '' ) ; 
    309                 }; 
    310         })(), 
    311  
    312         /** 
    313          * Returns the index of an element in an array. 
    314          * @param {Array} array The array to be searched. 
    315          * @param {Object} entry The element to be found. 
    316          * @returns {Number} The (zero based) index of the first entry that matches 
    317          *              the entry, or -1 if not found. 
    318          * @example 
    319          * var letters = [ 'a', 'b', 0, 'c', false ];  
    320          * alert( CKEDITOR.tools.indexOf( letters, '0' ) );  "-1" because 0 !== '0'  
    321          * alert( CKEDITOR.tools.indexOf( letters, false ) );  "4" because 0 !== false  
    322          */ 
    323         indexOf : 
    324                 // #2514: We should try to use Array.indexOf if it does exist. 
    325                 ( Array.prototype.indexOf ) ? 
    326                         function( array, entry ) 
    327                                 { 
    328                                         return array.indexOf( entry ); 
    329                                 } 
    330                 : 
    331                         function( array, entry ) 
    332                         { 
    333                                 for ( var i = 0, len = array.length ; i < len ; i++ ) 
    334                                 { 
    335                                         if ( array[ i ] === entry ) 
    336                                                 return i; 
    337                                 } 
    338                                 return -1; 
    339                         }, 
    340  
    341         bind : function( func, obj ) 
    342         { 
    343                 return function() { return func.apply( obj, arguments ); }; 
    344         } 
    345 }; 
     414        }; 
     415})(); 
    346416 
    347417// PACKAGER_RENAME( CKEDITOR.tools ) 
  • CKEditor/trunk/_source/core/ui.js

    r2948 r3113  
    4949        add : function( name, type, definition ) 
    5050        { 
    51                 var item = this._.handlers[ type ].create( definition ); 
    52                 item.name = name; 
    53                 this._.items[ name ] = item; 
     51                this._.items[ name ] = 
     52                { 
     53                        type : type, 
     54                        args : Array.prototype.slice.call( arguments, 2 ) 
     55                }; 
    5456        }, 
    5557 
     
    5961         * @example 
    6062         */ 
    61         get : function( name ) 
     63        create : function( name ) 
    6264        { 
    63                 return this._.items[ name ] || null; 
     65                var item        = this._.items[ name ], 
     66                        handler = item && this._.handlers[ item.type ]; 
     67                 
     68                return handler && handler.create.apply( this, item.args ); 
    6469        }, 
    6570 
  • CKEditor/trunk/_source/lang/en.js

    r3110 r3113  
    437437        }, 
    438438 
    439         showBlocks : 'Show Blocks' 
     439        showBlocks : 'Show Blocks', 
     440 
     441        format : 
     442        { 
     443                label : 'Format', 
     444                panelTitle : 'Paragraph Format', 
     445 
     446                tag_p : 'Normal', 
     447                tag_pre : 'Formatted', 
     448                tag_address : 'Address', 
     449                tag_h1 : 'Heading 1', 
     450                tag_h2 : 'Heading 2', 
     451                tag_h3 : 'Heading 3', 
     452                tag_h4 : 'Heading 4', 
     453                tag_h5 : 'Heading 5', 
     454                tag_h6 : 'Heading 6', 
     455                tag_div : 'Normal (DIV)' 
     456        } 
    440457}; 
  • CKEditor/trunk/_source/plugins/styles/plugin.js

    r3095 r3113  
    178178                { 
    179179                        if ( !element || element.getName() != this.element ) 
    180                                 return false ; 
     180                                return false; 
    181181 
    182182                        var def = this._.definition; 
     
    186186                        // If no attributes are defined in the element. 
    187187                        if ( !fullMatch && !element.hasAttributes() ) 
    188                                 return true ; 
     188                                return true; 
    189189 
    190190                        for ( var attName in attribs ) 
     
    526526        var applyBlockStyle = function( range ) 
    527527        { 
     528                // Bookmark the range so we can re-select it after processing. 
     529                var bookmark = range.createBookmark(); 
     530 
     531                var iterator = range.createIterator(); 
     532                iterator.enforceRealBlocks = true; 
     533 
     534                var block; 
     535                var doc = range.document; 
     536                var previousPreBlock; 
     537 
     538                while( ( block = iterator.getNextParagraph() ) )                // Only one = 
     539                { 
     540                        // Create the new node right before the current one. 
     541                        var newBlock = getElement( this, doc ); 
     542 
     543                        // Check if we are changing from/to <pre>. 
     544//                      var newBlockIsPre       = newBlock.nodeName.IEquals( 'pre' ); 
     545//                      var blockIsPre          = block.nodeName.IEquals( 'pre' ); 
     546 
     547//                      var toPre       = newBlockIsPre && !blockIsPre; 
     548//                      var fromPre     = !newBlockIsPre && blockIsPre; 
     549 
     550                        // Move everything from the current node to the new one. 
     551//                      if ( toPre ) 
     552//                              newBlock = this._ToPre( doc, block, newBlock ); 
     553//                      else if ( fromPre ) 
     554//                              newBlock = this._FromPre( doc, block, newBlock ); 
     555//                      else    // Convering from a regular block to another regular block. 
     556                                block.moveChildren( newBlock ); 
     557 
     558                        // Replace the current block. 
     559                        newBlock.insertBefore( block ); 
     560                        block.remove(); 
     561 
     562                        // Complete other tasks after inserting the node in the DOM. 
     563//                      if ( newBlockIsPre ) 
     564//                      { 
     565//                              if ( previousPreBlock ) 
     566//                                      this._CheckAndMergePre( previousPreBlock, newBlock ) ;  // Merge successive <pre> blocks. 
     567//                              previousPreBlock = newBlock; 
     568//                      } 
     569//                      else if ( fromPre ) 
     570//                              this._CheckAndSplitPre( newBlock ) ;    // Split <br><br> in successive <pre>s. 
     571                } 
     572 
     573                range.moveToBookmark( bookmark ); 
    528574        }; 
    529575 
  • CKEditor/trunk/_source/plugins/toolbar/plugin.js

    r3110 r3113  
    135135                                                                        item = CKEDITOR.ui.separator; 
    136136                                                                else 
    137                                                                         item = editor.ui.get( itemName ); 
     137                                                                        item = editor.ui.create( itemName ); 
    138138 
    139139                                                                if ( item ) 
     
    221221                'Image', 'Flash', '-', 
    222222                'Table', 'Smiley', 'HorizontalRule', 'SpecialChar', 'PageBreak', '-', 
    223                 'ShowBlocks' 
     223                'ShowBlocks', '-', 
     224                'Format' 
    224225        ] 
    225226]; 
  • CKEditor/trunk/_source/skins/default/editor.css

    r3016 r3113  
    77@import url("mainui.css"); 
    88@import url("toolbar.css"); 
     9@import url("panel.css"); 
     10@import url("richcombo.css"); 
    911@import url("elementspath.css"); 
    1012 
  • CKEditor/trunk/_source/tests/core/event.html

    r3017 r3113  
    450450                }, 
    451451 
     452                test_event_removeListener : function() 
     453                { 
     454                        // Create a testObject and implement CKEDITOR.event on it. 
     455                        var testObject = {}; 
     456                        CKEDITOR.event.implementOn( testObject ); 
     457 
     458                        var counter = 0; 
     459 
     460                        // Add two listeners for the same event "A". 
     461 
     462                        testObject.on( 'A', function( ev ) 
     463                                { 
     464                                        counter++; 
     465                                        ev.removeListener(); 
     466                                }); 
     467 
     468                        testObject.on( 'A', function( ev ) 
     469                                { 
     470                                        counter++; 
     471                                }); 
     472 
     473                        // Fire the event twice. 
     474                        testObject.fire( 'A' ); 
     475                        testObject.fire( 'A' ); 
     476 
     477                        assert.areSame( 3, counter ); 
     478                }, 
     479 
    452480                name : document.title 
    453481        }; 
  • CKEditor/trunk/_source/themes/default/theme.js

    r3016 r3113  
    5858                        var container = CKEDITOR.dom.element.createFromHtml( [ 
    5959                                '<span id="cke_', name, '" onmousedown="return false;" class="cke_container cke_skin_', editor.config.skin, ' ', browserCssClass, 
    60                                         ' cke_', editor.lang.dir, '" dir="', editor.lang.dir, '">' + 
     60                                        ' cke_', editor.lang.dir, '" dir="', editor.lang.dir, '" title="', ( CKEDITOR.env.gecko ? ' ' : '' ), '">' + 
    6161                                        '<table class="cke_editor" border="0" cellspacing="0" cellpadding="0" style="width:', width, ';height:', height, '"><tbody>' + 
    6262                                                '<tr', topHtml          ? '' : ' style="display:none"', '><td id="cke_top_'             , name, '" class="cke_top">'            , topHtml               , '</td></tr>' + 
  • CKEditor/trunk/ckeditor.pack

    r3093 r3113  
    4747                'CKEDITOR.SELECTION_TEXT' : 2, 
    4848                'CKEDITOR.SELECTION_ELEMENT' : 3, 
     49                'CKEDITOR.UI_RICHCOMBO' : 3, 
    4950                'CKEDITOR.DIALOG_RESIZE_NONE' : 0, 
    5051                'CKEDITOR.DIALOG_RESIZE_WIDTH' : 1, 
     
    5253                'CKEDITOR.DIALOG_RESIZE_BOTH' : 3, 
    5354                'CKEDITOR.VALIDATE_OR' : 1, 
    54                 'CKEDITOR.VALIDATE_AND' : 2 
     55                'CKEDITOR.VALIDATE_AND' : 2, 
     56                'CKEDITOR.UI_PANEL' : 2 
    5557        }, 
    5658 
     
    121123                                        '_source/plugins/elementspath/plugin.js', 
    122124                                        '_source/plugins/find/plugin.js', 
     125                                        '_source/plugins/flash/plugin.js', 
     126                                        '_source/plugins/format/plugin.js', 
    123127                                        '_source/plugins/horizontalrule/plugin.js', 
    124128                                        '_source/plugins/htmldataprocessor/plugin.js', 
     
    137141                                        '_source/plugins/removeformat/plugin.js', 
    138142                                        '_source/plugins/smiley/plugin.js', 
     143                                        '_source/plugins/showblocks/plugin.js', 
    139144                                        '_source/plugins/sourcearea/plugin.js', 
    140145                                        '_source/plugins/table/plugin.js', 
     
    148153                                        '_source/plugins/domiterator/plugin.js', 
    149154                                        '_source/plugins/selection/plugin.js', 
     155                                        '_source/plugins/fakeobjects/plugin.js', 
     156                                        '_source/plugins/richcombo/plugin.js', 
    150157                                        '_source/plugins/htmlwriter/plugin.js', 
    151                                         '_source/plugins/fakeobjects/plugin.js', 
    152158                                        '_source/plugins/dialog/plugin.js', 
    153159                                        '_source/plugins/editingblock/plugin.js', 
     160                                        '_source/plugins/floatpanel/plugin.js', 
     161                                        '_source/plugins/listblock/plugin.js', 
    154162                                        '_source/plugins/dialogui/plugin.js', 
     163                                        '_source/plugins/panel/plugin.js', 
    155164                                        '_source/skins/default/skin.js', 
    156165                                        '_source/themes/default/theme.js' 
  • CKEditor/trunk/contents.css

    r3043 r3113  
    1010        font-size: 12px; 
    1111 
     12        /* Text color */ 
     13        color: #222; 
     14 
    1215        /* Remove the background color to make it transparent */ 
    1316        background-color: #fff; 
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy