| [ Index ] |
PHP Cross Reference of Drupal 6 (gatewave) |
[Summary view] [Print] [Text view]
1 /* 2 Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved. 3 For licensing, see LICENSE.html or http://ckeditor.com/license 4 */ 5 6 /** 7 * @fileOverview Defines the {@link CKEDITOR.tools} object, which contains 8 * utility functions. 9 */ 10 11 (function() 12 { 13 var functions = []; 14 15 CKEDITOR.on( 'reset', function() 16 { 17 functions = []; 18 }); 19 20 /** 21 * Utility functions. 22 * @namespace 23 * @example 24 */ 25 CKEDITOR.tools = 26 { 27 /** 28 * Compare the elements of two arrays. 29 * @param {Array} arrayA An array to be compared. 30 * @param {Array} arrayB The other array to be compared. 31 * @returns {Boolean} "true" is the arrays have the same lenght and 32 * their elements match. 33 * @example 34 * var a = [ 1, 'a', 3 ]; 35 * var b = [ 1, 3, 'a' ]; 36 * var c = [ 1, 'a', 3 ]; 37 * var d = [ 1, 'a', 3, 4 ]; 38 * 39 * alert( CKEDITOR.tools.arrayCompare( a, b ) ); // false 40 * alert( CKEDITOR.tools.arrayCompare( a, c ) ); // true 41 * alert( CKEDITOR.tools.arrayCompare( a, d ) ); // false 42 */ 43 arrayCompare : function( arrayA, arrayB ) 44 { 45 if ( !arrayA && !arrayB ) 46 return true; 47 48 if ( !arrayA || !arrayB || arrayA.length != arrayB.length ) 49 return false; 50 51 for ( var i = 0 ; i < arrayA.length ; i++ ) 52 { 53 if ( arrayA[ i ] != arrayB[ i ] ) 54 return false; 55 } 56 57 return true; 58 }, 59 60 /** 61 * Creates a deep copy of an object. 62 * Attention: there is no support for recursive references. 63 * @param {Object} object The object to be cloned. 64 * @returns {Object} The object clone. 65 * @example 66 * var obj = 67 * { 68 * name : 'John', 69 * cars : 70 * { 71 * Mercedes : { color : 'blue' }, 72 * Porsche : { color : 'red' } 73 * } 74 * }; 75 * var clone = CKEDITOR.tools.clone( obj ); 76 * clone.name = 'Paul'; 77 * clone.cars.Porsche.color = 'silver'; 78 * alert( obj.name ); // John 79 * alert( clone.name ); // Paul 80 * alert( obj.cars.Porsche.color ); // red 81 * alert( clone.cars.Porsche.color ); // silver 82 */ 83 clone : function( obj ) 84 { 85 var clone; 86 87 // Array. 88 if ( obj && ( obj instanceof Array ) ) 89 { 90 clone = []; 91 92 for ( var i = 0 ; i < obj.length ; i++ ) 93 clone[ i ] = this.clone( obj[ i ] ); 94 95 return clone; 96 } 97 98 // "Static" types. 99 if ( obj === null 100 || ( typeof( obj ) != 'object' ) 101 || ( obj instanceof String ) 102 || ( obj instanceof Number ) 103 || ( obj instanceof Boolean ) 104 || ( obj instanceof Date ) 105 || ( obj instanceof RegExp) ) 106 { 107 return obj; 108 } 109 110 // Objects. 111 clone = new obj.constructor(); 112 113 for ( var propertyName in obj ) 114 { 115 var property = obj[ propertyName ]; 116 clone[ propertyName ] = this.clone( property ); 117 } 118 119 return clone; 120 }, 121 122 /** 123 * Turn the first letter of string to upper-case. 124 * @param {String} str 125 */ 126 capitalize: function( str ) 127 { 128 return str.charAt( 0 ).toUpperCase() + str.substring( 1 ).toLowerCase(); 129 }, 130 131 /** 132 * Copy the properties from one object to another. By default, properties 133 * already present in the target object <strong>are not</strong> overwritten. 134 * @param {Object} target The object to be extended. 135 * @param {Object} source[,souce(n)] The objects from which copy 136 * properties. Any number of objects can be passed to this function. 137 * @param {Boolean} [overwrite] If 'true' is specified it indicates that 138 * properties already present in the target object could be 139 * overwritten by subsequent objects. 140 * @param {Object} [properties] Only properties within the specified names 141 * list will be received from the source object. 142 * @returns {Object} the extended object (target). 143 * @example 144 * // Create the sample object. 145 * var myObject = 146 * { 147 * prop1 : true 148 * }; 149 * 150 * // Extend the above object with two properties. 151 * CKEDITOR.tools.extend( myObject, 152 * { 153 * prop2 : true, 154 * prop3 : true 155 * } ); 156 * 157 * // Alert "prop1", "prop2" and "prop3". 158 * for ( var p in myObject ) 159 * alert( p ); 160 */ 161 extend : function( target ) 162 { 163 var argsLength = arguments.length, 164 overwrite, propertiesList; 165 166 if ( typeof ( overwrite = arguments[ argsLength - 1 ] ) == 'boolean') 167 argsLength--; 168 else if ( typeof ( overwrite = arguments[ argsLength - 2 ] ) == 'boolean' ) 169 { 170 propertiesList = arguments [ argsLength -1 ]; 171 argsLength-=2; 172 } 173 for ( var i = 1 ; i < argsLength ; i++ ) 174 { 175 var source = arguments[ i ]; 176 for ( var propertyName in source ) 177 { 178 // Only copy existed fields if in overwrite mode. 179 if ( overwrite === true || target[ propertyName ] == undefined ) 180 { 181 // Only copy specified fields if list is provided. 182 if ( !propertiesList || ( propertyName in propertiesList ) ) 183 target[ propertyName ] = source[ propertyName ]; 184 185 } 186 } 187 } 188 189 return target; 190 }, 191 192 /** 193 * Creates an object which is an instance of a class which prototype is a 194 * predefined object. All properties defined in the source object are 195 * automatically inherited by the resulting object, including future 196 * changes to it. 197 * @param {Object} source The source object to be used as the prototype for 198 * the final object. 199 * @returns {Object} The resulting copy. 200 */ 201 prototypedCopy : function( source ) 202 { 203 var copy = function() 204 {}; 205 copy.prototype = source; 206 return new copy(); 207 }, 208 209 /** 210 * Checks if an object is an Array. 211 * @param {Object} object The object to be checked. 212 * @type Boolean 213 * @returns <i>true</i> if the object is an Array, otherwise <i>false</i>. 214 * @example 215 * alert( CKEDITOR.tools.isArray( [] ) ); // "true" 216 * alert( CKEDITOR.tools.isArray( 'Test' ) ); // "false" 217 */ 218 isArray : function( object ) 219 { 220 return ( !!object && object instanceof Array ); 221 }, 222 223 /** 224 * Whether the object contains no properties of it's own. 225 * @param object 226 */ 227 isEmpty : function ( object ) 228 { 229 for ( var i in object ) 230 { 231 if ( object.hasOwnProperty( i ) ) 232 return false; 233 } 234 return true; 235 }, 236 237 /** 238 * Transforms a CSS property name to its relative DOM style name. 239 * @param {String} cssName The CSS property name. 240 * @returns {String} The transformed name. 241 * @example 242 * alert( CKEDITOR.tools.cssStyleToDomStyle( 'background-color' ) ); // "backgroundColor" 243 * alert( CKEDITOR.tools.cssStyleToDomStyle( 'float' ) ); // "cssFloat" 244 */ 245 cssStyleToDomStyle : ( function() 246 { 247 var test = document.createElement( 'div' ).style; 248 249 var cssFloat = ( typeof test.cssFloat != 'undefined' ) ? 'cssFloat' 250 : ( typeof test.styleFloat != 'undefined' ) ? 'styleFloat' 251 : 'float'; 252 253 return function( cssName ) 254 { 255 if ( cssName == 'float' ) 256 return cssFloat; 257 else 258 { 259 return cssName.replace( /-./g, function( match ) 260 { 261 return match.substr( 1 ).toUpperCase(); 262 }); 263 } 264 }; 265 } )(), 266 267 /** 268 * Build the HTML snippet of a set of <style>/<link>. 269 * @param css {String|Array} Each of which are url (absolute) of a CSS file or 270 * a trunk of style text. 271 */ 272 buildStyleHtml : function ( css ) 273 { 274 css = [].concat( css ); 275 var item, retval = []; 276 for ( var i = 0; i < css.length; i++ ) 277 { 278 item = css[ i ]; 279 // Is CSS style text ? 280 if ( /@import|[{}]/.test(item) ) 281 retval.push('<style>' + item + '</style>'); 282 else 283 retval.push('<link type="text/css" rel=stylesheet href="' + item + '">'); 284 } 285 return retval.join( '' ); 286 }, 287 288 /** 289 * Replace special HTML characters in a string with their relative HTML 290 * entity values. 291 * @param {String} text The string to be encoded. 292 * @returns {String} The encode string. 293 * @example 294 * alert( CKEDITOR.tools.htmlEncode( 'A > B & C < D' ) ); // "A &gt; B &amp; C &lt; D" 295 */ 296 htmlEncode : function( text ) 297 { 298 var standard = function( text ) 299 { 300 var span = new CKEDITOR.dom.element( 'span' ); 301 span.setText( text ); 302 return span.getHtml(); 303 }; 304 305 var fix1 = ( standard( '\n' ).toLowerCase() == '<br>' ) ? 306 function( text ) 307 { 308 // #3874 IE and Safari encode line-break into <br> 309 return standard( text ).replace( /<br>/gi, '\n' ); 310 } : 311 standard; 312 313 var fix2 = ( standard( '>' ) == '>' ) ? 314 function( text ) 315 { 316 // WebKit does't encode the ">" character, which makes sense, but 317 // it's different than other browsers. 318 return fix1( text ).replace( />/g, '>' ); 319 } : 320 fix1; 321 322 var fix3 = ( standard( ' ' ) == ' ' ) ? 323 function( text ) 324 { 325 // #3785 IE8 changes spaces (>= 2) to 326 return fix2( text ).replace( / /g, ' ' ); 327 } : 328 fix2; 329 330 this.htmlEncode = fix3; 331 332 return this.htmlEncode( text ); 333 }, 334 335 /** 336 * Replace special HTML characters in HTMLElement's attribute with their relative HTML entity values. 337 * @param {String} The attribute's value to be encoded. 338 * @returns {String} The encode value. 339 * @example 340 * element.setAttribute( 'title', '<a " b >' ); 341 * alert( CKEDITOR.tools.htmlEncodeAttr( element.getAttribute( 'title' ) ); // ">a " b <" 342 */ 343 htmlEncodeAttr : function( text ) 344 { 345 return text.replace( /"/g, '"' ).replace( /</g, '<' ).replace( />/g, '>' ); 346 }, 347 348 /** 349 * Replace characters can't be represented through CSS Selectors string 350 * by CSS Escape Notation where the character escape sequence consists 351 * of a backslash character (\) followed by the orginal characters. 352 * Ref: http://www.w3.org/TR/css3-selectors/#grammar 353 * @param cssSelectText 354 * @return the escaped selector text. 355 */ 356 escapeCssSelector : function( cssSelectText ) 357 { 358 return cssSelectText.replace( /[\s#:.,$*^\[\]()~=+>]/g, '\\$&' ); 359 }, 360 361 /** 362 * Gets a unique number for this CKEDITOR execution session. It returns 363 * progressive numbers starting at 1. 364 * @function 365 * @returns {Number} A unique number. 366 * @example 367 * alert( CKEDITOR.tools.<b>getNextNumber()</b> ); // "1" (e.g.) 368 * alert( CKEDITOR.tools.<b>getNextNumber()</b> ); // "2" 369 */ 370 getNextNumber : (function() 371 { 372 var last = 0; 373 return function() 374 { 375 return ++last; 376 }; 377 })(), 378 379 /** 380 * Gets a unique ID for CKEditor's interface elements. It returns a 381 * string with the "cke_" prefix and a progressive number. 382 * @function 383 * @returns {String} A unique ID. 384 * @example 385 * alert( CKEDITOR.tools.<b>getNextId()</b> ); // "cke_1" (e.g.) 386 * alert( CKEDITOR.tools.<b>getNextId()</b> ); // "cke_2" 387 */ 388 getNextId : function() 389 { 390 return 'cke_' + this.getNextNumber(); 391 }, 392 393 /** 394 * Creates a function override. 395 * @param {Function} originalFunction The function to be overridden. 396 * @param {Function} functionBuilder A function that returns the new 397 * function. The original function reference will be passed to this 398 * function. 399 * @returns {Function} The new function. 400 * @example 401 * var example = 402 * { 403 * myFunction : function( name ) 404 * { 405 * alert( 'Name: ' + name ); 406 * } 407 * }; 408 * 409 * example.myFunction = CKEDITOR.tools.override( example.myFunction, function( myFunctionOriginal ) 410 * { 411 * return function( name ) 412 * { 413 * alert( 'Override Name: ' + name ); 414 * myFunctionOriginal.call( this, name ); 415 * }; 416 * }); 417 */ 418 override : function( originalFunction, functionBuilder ) 419 { 420 return functionBuilder( originalFunction ); 421 }, 422 423 /** 424 * Executes a function after specified delay. 425 * @param {Function} func The function to be executed. 426 * @param {Number} [milliseconds] The amount of time (millisecods) to wait 427 * to fire the function execution. Defaults to zero. 428 * @param {Object} [scope] The object to hold the function execution scope 429 * (the "this" object). By default the "window" object. 430 * @param {Object|Array} [args] A single object, or an array of objects, to 431 * pass as arguments to the function. 432 * @param {Object} [ownerWindow] The window that will be used to set the 433 * timeout. By default the current "window". 434 * @returns {Object} A value that can be used to cancel the function execution. 435 * @example 436 * CKEDITOR.tools.<b>setTimeout( 437 * function() 438 * { 439 * alert( 'Executed after 2 seconds' ); 440 * }, 441 * 2000 )</b>; 442 */ 443 setTimeout : function( func, milliseconds, scope, args, ownerWindow ) 444 { 445 if ( !ownerWindow ) 446 ownerWindow = window; 447 448 if ( !scope ) 449 scope = ownerWindow; 450 451 return ownerWindow.setTimeout( 452 function() 453 { 454 if ( args ) 455 func.apply( scope, [].concat( args ) ) ; 456 else 457 func.apply( scope ) ; 458 }, 459 milliseconds || 0 ); 460 }, 461 462 /** 463 * Remove spaces from the start and the end of a string. The following 464 * characters are removed: space, tab, line break, line feed. 465 * @function 466 * @param {String} str The text from which remove the spaces. 467 * @returns {String} The modified string without the boundary spaces. 468 * @example 469 * alert( CKEDITOR.tools.trim( ' example ' ); // "example" 470 */ 471 trim : (function() 472 { 473 // We are not using \s because we don't want "non-breaking spaces" to be caught. 474 var trimRegex = /(?:^[ \t\n\r]+)|(?:[ \t\n\r]+$)/g; 475 return function( str ) 476 { 477 return str.replace( trimRegex, '' ) ; 478 }; 479 })(), 480 481 /** 482 * Remove spaces from the start (left) of a string. The following 483 * characters are removed: space, tab, line break, line feed. 484 * @function 485 * @param {String} str The text from which remove the spaces. 486 * @returns {String} The modified string excluding the removed spaces. 487 * @example 488 * alert( CKEDITOR.tools.ltrim( ' example ' ); // "example " 489 */ 490 ltrim : (function() 491 { 492 // We are not using \s because we don't want "non-breaking spaces" to be caught. 493 var trimRegex = /^[ \t\n\r]+/g; 494 return function( str ) 495 { 496 return str.replace( trimRegex, '' ) ; 497 }; 498 })(), 499 500 /** 501 * Remove spaces from the end (right) of a string. The following 502 * characters are removed: space, tab, line break, line feed. 503 * @function 504 * @param {String} str The text from which remove the spaces. 505 * @returns {String} The modified string excluding the removed spaces. 506 * @example 507 * alert( CKEDITOR.tools.ltrim( ' example ' ); // " example" 508 */ 509 rtrim : (function() 510 { 511 // We are not using \s because we don't want "non-breaking spaces" to be caught. 512 var trimRegex = /[ \t\n\r]+$/g; 513 return function( str ) 514 { 515 return str.replace( trimRegex, '' ) ; 516 }; 517 })(), 518 519 /** 520 * Returns the index of an element in an array. 521 * @param {Array} array The array to be searched. 522 * @param {Object} entry The element to be found. 523 * @returns {Number} The (zero based) index of the first entry that matches 524 * the entry, or -1 if not found. 525 * @example 526 * var letters = [ 'a', 'b', 0, 'c', false ]; 527 * alert( CKEDITOR.tools.indexOf( letters, '0' ) ); "-1" because 0 !== '0' 528 * alert( CKEDITOR.tools.indexOf( letters, false ) ); "4" because 0 !== false 529 */ 530 indexOf : 531 // #2514: We should try to use Array.indexOf if it does exist. 532 ( Array.prototype.indexOf ) ? 533 function( array, entry ) 534 { 535 return array.indexOf( entry ); 536 } 537 : 538 function( array, entry ) 539 { 540 for ( var i = 0, len = array.length ; i < len ; i++ ) 541 { 542 if ( array[ i ] === entry ) 543 return i; 544 } 545 return -1; 546 }, 547 548 /** 549 * Creates a function that will always execute in the context of a 550 * specified object. 551 * @param {Function} func The function to be executed. 552 * @param {Object} obj The object to which bind the execution context. 553 * @returns {Function} The function that can be used to execute the 554 * "func" function in the context of "obj". 555 * @example 556 * var obj = { text : 'My Object' }; 557 * 558 * function alertText() 559 * { 560 * alert( this.text ); 561 * } 562 * 563 * var newFunc = <b>CKEDITOR.tools.bind( alertText, obj )</b>; 564 * newFunc(); // Alerts "My Object". 565 */ 566 bind : function( func, obj ) 567 { 568 return function() { return func.apply( obj, arguments ); }; 569 }, 570 571 /** 572 * Class creation based on prototype inheritance, with supports of the 573 * following features: 574 * <ul> 575 * <li> Static fields </li> 576 * <li> Private fields </li> 577 * <li> Public (prototype) fields </li> 578 * <li> Chainable base class constructor </li> 579 * </ul> 580 * @param {Object} definition The class definition object. 581 * @returns {Function} A class-like JavaScript function. 582 */ 583 createClass : function( definition ) 584 { 585 var $ = definition.$, 586 baseClass = definition.base, 587 privates = definition.privates || definition._, 588 proto = definition.proto, 589 statics = definition.statics; 590 591 if ( privates ) 592 { 593 var originalConstructor = $; 594 $ = function() 595 { 596 // Create (and get) the private namespace. 597 var _ = this._ || ( this._ = {} ); 598 599 // Make some magic so "this" will refer to the main 600 // instance when coding private functions. 601 for ( var privateName in privates ) 602 { 603 var priv = privates[ privateName ]; 604 605 _[ privateName ] = 606 ( typeof priv == 'function' ) ? CKEDITOR.tools.bind( priv, this ) : priv; 607 } 608 609 originalConstructor.apply( this, arguments ); 610 }; 611 } 612 613 if ( baseClass ) 614 { 615 $.prototype = this.prototypedCopy( baseClass.prototype ); 616 $.prototype.constructor = $; 617 $.prototype.base = function() 618 { 619 this.base = baseClass.prototype.base; 620 baseClass.apply( this, arguments ); 621 this.base = arguments.callee; 622 }; 623 } 624 625 if ( proto ) 626 this.extend( $.prototype, proto, true ); 627 628 if ( statics ) 629 this.extend( $, statics, true ); 630 631 return $; 632 }, 633 634 /** 635 * Creates a function reference that can be called later using 636 * CKEDITOR.tools.callFunction. This approach is specially useful to 637 * make DOM attribute function calls to JavaScript defined functions. 638 * @param {Function} fn The function to be executed on call. 639 * @param {Object} [scope] The object to have the context on "fn" execution. 640 * @returns {Number} A unique reference to be used in conjuction with 641 * CKEDITOR.tools.callFunction. 642 * @example 643 * var ref = <b>CKEDITOR.tools.addFunction</b>( 644 * function() 645 * { 646 * alert( 'Hello!'); 647 * }); 648 * CKEDITOR.tools.callFunction( ref ); // Hello! 649 */ 650 addFunction : function( fn, scope ) 651 { 652 return functions.push( function() 653 { 654 fn.apply( scope || this, arguments ); 655 }) - 1; 656 }, 657 658 /** 659 * Removes the function reference created with {@see CKEDITOR.tools.addFunction}. 660 * @param {Number} ref The function reference created with 661 * CKEDITOR.tools.addFunction. 662 */ 663 removeFunction : function( ref ) 664 { 665 functions[ ref ] = null; 666 }, 667 668 /** 669 * Executes a function based on the reference created with 670 * CKEDITOR.tools.addFunction. 671 * @param {Number} ref The function reference created with 672 * CKEDITOR.tools.addFunction. 673 * @param {[Any,[Any,...]} params Any number of parameters to be passed 674 * to the executed function. 675 * @returns {Any} The return value of the function. 676 * @example 677 * var ref = CKEDITOR.tools.addFunction( 678 * function() 679 * { 680 * alert( 'Hello!'); 681 * }); 682 * <b>CKEDITOR.tools.callFunction( ref )</b>; // Hello! 683 */ 684 callFunction : function( ref ) 685 { 686 var fn = functions[ ref ]; 687 return fn && fn.apply( window, Array.prototype.slice.call( arguments, 1 ) ); 688 }, 689 690 /** 691 * Append the 'px' length unit to the size if it's missing. 692 * @param length 693 */ 694 cssLength : (function() 695 { 696 var decimalRegex = /^\d+(?:\.\d+)?$/; 697 return function( length ) 698 { 699 return length + ( decimalRegex.test( length ) ? 'px' : '' ); 700 }; 701 })(), 702 703 /** 704 * String specified by {@param str} repeats {@param times} times. 705 * @param str 706 * @param times 707 */ 708 repeat : function( str, times ) 709 { 710 return new Array( times + 1 ).join( str ); 711 }, 712 713 /** 714 * Return the first successfully executed function's return value that 715 * doesn't throw any exception. 716 */ 717 tryThese : function() 718 { 719 var returnValue; 720 for ( var i = 0, length = arguments.length; i < length; i++ ) 721 { 722 var lambda = arguments[i]; 723 try 724 { 725 returnValue = lambda(); 726 break; 727 } 728 catch (e) {} 729 } 730 return returnValue; 731 }, 732 733 /** 734 * Generate a combined key from a series of params. 735 * @param {String} subKey One or more string used as sub keys. 736 * @example 737 * var key = CKEDITOR.tools.genKey( 'key1', 'key2', 'key3' ); 738 * alert( key ); // "key1-key2-key3". 739 */ 740 genKey : function() 741 { 742 return Array.prototype.slice.call( arguments ).join( '-' ); 743 } 744 }; 745 })(); 746 747 // PACKAGER_RENAME( CKEDITOR.tools )
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Thu Mar 24 11:18:33 2011 | Cross-referenced by PHPXref 0.7 |