_source/core/editor_basic.js

   1 /*
   2 Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
   3 For licensing, see LICENSE.html or http://ckeditor.com/license
   4 */
   5
   6 if ( !CKEDITOR.editor )
   7 {
   8         /**
   9          * No element is linked to the editor instance.
  10          * @constant
  11          * @example
  12          */
  13         CKEDITOR.ELEMENT_MODE_NONE = 0;
  14
  15         /**
  16          * The element is to be replaced by the editor instance.
  17          * @constant
  18          * @example
  19          */
  20         CKEDITOR.ELEMENT_MODE_REPLACE = 1;
  21
  22         /**
  23          * The editor is to be created inside the element.
  24          * @constant
  25          * @example
  26          */
  27         CKEDITOR.ELEMENT_MODE_APPENDTO = 2;
  28
  29         /**
  30          * Creates an editor class instance. This constructor should be rarely
  31          * used, in favor of the {@link CKEDITOR} editor creation functions.
  32          * @ class Represents an editor instance.
  33          * @param {Object} instanceConfig Configuration values for this specific
  34          *              instance.
  35          * @param {CKEDITOR.dom.element} [element] The element linked to this
  36          *              instance.
  37          * @param {Number} [mode] The mode in which the element is linked to this
  38          *              instance. See {@link #elementMode}.
  39          * @param {String} [data] Since 3.3. Initial value for the instance.
  40          * @augments CKEDITOR.event
  41          * @example
  42          */
  43         CKEDITOR.editor = function( instanceConfig, element, mode, data )
  44         {
  45                 this._ =
  46                 {
  47                         // Save the config to be processed later by the full core code.
  48                         instanceConfig : instanceConfig,
  49                         element : element,
  50                         data : data
  51                 };
  52
  53                 /**
  54                  * The mode in which the {@link #element} is linked to this editor
  55                  * instance. It can be any of the following values:
  56                  * <ul>
  57                  * <li>{@link CKEDITOR.ELEMENT_MODE_NONE}: No element is linked to the
  58                  *              editor instance.</li>
  59                  * <li>{@link CKEDITOR.ELEMENT_MODE_REPLACE}: The element is to be
  60                  *              replaced by the editor instance.</li>
  61                  * <li>{@link CKEDITOR.ELEMENT_MODE_APPENDTO}: The editor is to be
  62                  *              created inside the element.</li>
  63                  * </ul>
  64                  * @name CKEDITOR.editor.prototype.elementMode
  65                  * @type Number
  66                  * @example
  67                  * var editor = CKEDITOR.replace( 'editor1' );
  68                  * alert( <b>editor.elementMode</b> );  "1"
  69                  */
  70                 this.elementMode = mode || CKEDITOR.ELEMENT_MODE_NONE;
  71
  72                 // Call the CKEDITOR.event constructor to initialize this instance.
  73                 CKEDITOR.event.call( this );
  74
  75                 this._init();
  76         };
  77
  78         /**
  79          * Replaces a &lt;textarea&gt; or a DOM element (DIV) with a CKEditor
  80          * instance. For textareas, the initial value in the editor will be the
  81          * textarea value. For DOM elements, their innerHTML will be used
  82          * instead. We recommend using TEXTAREA and DIV elements only. Do not use
  83          * this function directly. Use {@link CKEDITOR.replace} instead.
  84          * @param {Object|String} elementOrIdOrName The DOM element (textarea), its
  85          *              ID or name.
  86          * @param {Object} [config] The specific configurations to apply to this
  87          *              editor instance. Configurations set here will override global CKEditor
  88          *              settings.
  89          * @returns {CKEDITOR.editor} The editor instance created.
  90          * @example
  91          */
  92         CKEDITOR.editor.replace = function( elementOrIdOrName, config )
  93         {
  94                 var element = elementOrIdOrName;
  95
  96                 if ( typeof element != 'object' )
  97                 {
  98                         // Look for the element by id. We accept any kind of element here.
  99                         element = document.getElementById( elementOrIdOrName );
 100
 101                         // Elements that should go into head are unacceptable (#6791).
 102                         if ( element && element.tagName.toLowerCase() in {style:1,script:1,base:1,link:1,meta:1,title:1} )
 103                                 element = null;
 104
 105                         // If not found, look for elements by name. In this case we accept only
 106                         // textareas.
 107                         if ( !element )
 108                         {
 109                                 var i = 0,
 110                                         textareasByName = document.getElementsByName( elementOrIdOrName );
 111
 112                                 while ( ( element = textareasByName[ i++ ] ) && element.tagName.toLowerCase() != 'textarea' )
 113                                 { /*jsl:pass*/ }
 114                         }
 115
 116                         if ( !element )
 117                                 throw '[CKEDITOR.editor.replace] The element with id or name "' + elementOrIdOrName + '" was not found.';
 118                 }
 119
 120                 // Do not replace the textarea right now, just hide it. The effective
 121                 // replacement will be done by the _init function.
 122                 element.style.visibility = 'hidden';
 123
 124                 // Create the editor instance.
 125                 return new CKEDITOR.editor( config, element, CKEDITOR.ELEMENT_MODE_REPLACE );
 126         };
 127
 128         /**
 129          * Creates a new editor instance inside a specific DOM element. Do not use
 130          * this function directly. Use {@link CKEDITOR.appendTo} instead.
 131          * @param {Object|String} elementOrId The DOM element or its ID.
 132          * @param {Object} [config] The specific configurations to apply to this
 133          *              editor instance. Configurations set here will override global CKEditor
 134          *              settings.
 135          * @param {String} [data] Since 3.3. Initial value for the instance.
 136          * @returns {CKEDITOR.editor} The editor instance created.
 137          * @example
 138          */
 139         CKEDITOR.editor.appendTo = function( elementOrId, config, data )
 140         {
 141                 var element = elementOrId;
 142                 if ( typeof element != 'object' )
 143                 {
 144                         element = document.getElementById( elementOrId );
 145
 146                         if ( !element )
 147                                 throw '[CKEDITOR.editor.appendTo] The element with id "' + elementOrId + '" was not found.';
 148                 }
 149
 150                 // Create the editor instance.
 151                 return new CKEDITOR.editor( config, element, CKEDITOR.ELEMENT_MODE_APPENDTO, data );
 152         };
 153
 154         CKEDITOR.editor.prototype =
 155         {
 156                 /**
 157                  * Initializes the editor instance. This function will be overriden by the
 158                  * full CKEDITOR.editor implementation (editor.js).
 159                  * @private
 160                  */
 161                 _init : function()
 162                 {
 163                         var pending = CKEDITOR.editor._pending || ( CKEDITOR.editor._pending = [] );
 164                         pending.push( this );
 165                 },
 166
 167                 // Both fire and fireOnce will always pass this editor instance as the
 168                 // "editor" param in CKEDITOR.event.fire. So, we override it to do that
 169                 // automaticaly.
 170
 171                 /** @ignore */
 172                 fire : function( eventName, data )
 173                 {
 174                         return CKEDITOR.event.prototype.fire.call( this, eventName, data, this );
 175                 },
 176
 177                 /** @ignore */
 178                 fireOnce : function( eventName, data )
 179                 {
 180                         return CKEDITOR.event.prototype.fireOnce.call( this, eventName, data, this );
 181                 }
 182         };
 183
 184         // "Inherit" (copy actually) from CKEDITOR.event.
 185         CKEDITOR.event.implementOn( CKEDITOR.editor.prototype, true );
 186 }