|
|
@@ -24,15 +24,15 @@ export default class Plugin {
|
|
|
/**
|
|
|
* The editor instance.
|
|
|
*
|
|
|
- * Note that most editors implements {@link module:core/editor/editorwithui~EditorWithUI} interface in addition
|
|
|
- * to the base {@link module:core/editor/editor~Editor} interface. However, editors with external UI
|
|
|
- * (i.e. Bootstrap based) or headless editor may not implement {@link module:core/editor/editorwithui~EditorWithUI}
|
|
|
+ * Note that most editors implement the {@link module:core/editor/editorwithui~EditorWithUI} interface in addition
|
|
|
+ * to the base {@link module:core/editor/editor~Editor} interface. However, editors with an external UI
|
|
|
+ * (i.e. Bootstrap-based) or a headless editor may not implement the {@link module:core/editor/editorwithui~EditorWithUI}
|
|
|
* interface.
|
|
|
*
|
|
|
* Because of above, to make plugins more universal, it is recommended to split features into:
|
|
|
- * - "Editing" part which use only {@link module:core/editor/editor~Editor} interface,
|
|
|
- * - "UI" part which use both {@link module:core/editor/editor~Editor} interface and
|
|
|
- * {@link module:core/editor/editorwithui~EditorWithUI} interface.
|
|
|
+ * - The "editing" part that only uses the {@link module:core/editor/editor~Editor} interface.
|
|
|
+ * - The "UI" part that uses both the {@link module:core/editor/editor~Editor} interface and
|
|
|
+ * the {@link module:core/editor/editorwithui~EditorWithUI} interface.
|
|
|
*
|
|
|
* @readonly
|
|
|
* @member {module:core/editor/editor~Editor} #editor
|
|
|
@@ -53,25 +53,25 @@ mix( Plugin, ObservableMixin );
|
|
|
/**
|
|
|
* The base interface for CKEditor plugins.
|
|
|
*
|
|
|
- * In its minimal form it can be a simple function (it will be used as a constructor) which accepts
|
|
|
- * {@link module:core/editor/editor~Editor the editor} as a parm.
|
|
|
+ * In its minimal form it can be a simple function (it will be used as a constructor) that accepts
|
|
|
+ * {@link module:core/editor/editor~Editor the editor} as a parameter.
|
|
|
* It can also implement a few methods which, when present, will be used to properly initialize and destroy the plugin.
|
|
|
*
|
|
|
- * // A simple plugin which enables a data processor.
|
|
|
+ * // A simple plugin that enables a data processor.
|
|
|
* function MyPlugin( editor ) {
|
|
|
* editor.data.processor = new MyDataProcessor();
|
|
|
* }
|
|
|
*
|
|
|
- * In most cases, however, you'll want to inherit from the {@link module:core/plugin~Plugin} class which implements the
|
|
|
+ * In most cases, however, you will want to inherit from the {@link module:core/plugin~Plugin} class which implements the
|
|
|
* {@link module:utils/observablemixin~ObservableMixin} and is, therefore, more convenient:
|
|
|
*
|
|
|
* class MyPlugin extends Plugin {
|
|
|
* init() {
|
|
|
* // `listenTo()` and `editor` are available thanks to `Plugin`.
|
|
|
- * // By using `listenTo()` you'll ensure that the listener will be removed when
|
|
|
+ * // By using `listenTo()` you will ensure that the listener is removed when
|
|
|
* // the plugin is destroyed.
|
|
|
* this.listenTo( this.editor, 'dataReady', () => {
|
|
|
- * // Do something when data is ready.
|
|
|
+ * // Do something when the data is ready.
|
|
|
* } );
|
|
|
* }
|
|
|
* }
|
|
|
@@ -80,16 +80,16 @@ mix( Plugin, ObservableMixin );
|
|
|
*/
|
|
|
|
|
|
/**
|
|
|
- * Creates a new plugin instance. This is the first step of a plugin initialization.
|
|
|
+ * Creates a new plugin instance. This is the first step of the plugin initialization.
|
|
|
* See also {@link #init} and {@link #afterInit}.
|
|
|
*
|
|
|
* A plugin is always instantiated after its {@link module:core/plugin~PluginInterface.requires dependencies} and the
|
|
|
* {@link #init} and {@link #afterInit} methods are called in the same order.
|
|
|
*
|
|
|
- * Usually, you'll want to put your plugin's initialization code in the {@link #init} method.
|
|
|
+ * Usually, you will want to put your plugin's initialization code in the {@link #init} method.
|
|
|
* The constructor can be understood as "before init" and used in special cases, just like
|
|
|
- * {@link #afterInit} servers for the special "after init" scenarios (e.g. code which depends on other
|
|
|
- * plugins, but which doesn't {@link module:core/plugin~PluginInterface.requires explicitly require} them).
|
|
|
+ * {@link #afterInit} serves the special "after init" scenarios (e.g.the code which depends on other
|
|
|
+ * plugins, but which does not {@link module:core/plugin~PluginInterface.requires explicitly require} them).
|
|
|
*
|
|
|
* @method #constructor
|
|
|
* @param {module:core/editor/editor~Editor} editor
|
|
|
@@ -98,7 +98,7 @@ mix( Plugin, ObservableMixin );
|
|
|
/**
|
|
|
* An array of plugins required by this plugin.
|
|
|
*
|
|
|
- * To keep a plugin class definition tight it's recommended to define this property as a static getter:
|
|
|
+ * To keep the plugin class definition tight it is recommended to define this property as a static getter:
|
|
|
*
|
|
|
* import Image from './image.js';
|
|
|
*
|
|
|
@@ -114,13 +114,13 @@ mix( Plugin, ObservableMixin );
|
|
|
*/
|
|
|
|
|
|
/**
|
|
|
- * Optional name of the plugin. If set, the plugin will be available in
|
|
|
+ * An optional name of the plugin. If set, the plugin will be available in
|
|
|
* {@link module:core/plugincollection~PluginCollection#get} by its
|
|
|
* name and its constructor. If not, then only by its constructor.
|
|
|
*
|
|
|
* The name should reflect the constructor name.
|
|
|
*
|
|
|
- * To keep a plugin class definition tight it's recommended to define this property as a static getter:
|
|
|
+ * To keep the plugin class definition tight it is recommended to define this property as a static getter:
|
|
|
*
|
|
|
* export default class ImageCaption {
|
|
|
* static get pluginName() {
|
|
|
@@ -146,7 +146,7 @@ mix( Plugin, ObservableMixin );
|
|
|
* A plugin's `init()` method is called after its {@link module:core/plugin~PluginInterface.requires dependencies} are initialized,
|
|
|
* so in the same order as constructors of these plugins.
|
|
|
*
|
|
|
- * **Note:** This method is optional. A plugin instance does not need to have to have it defined.
|
|
|
+ * **Note:** This method is optional. A plugin instance does not need to have it defined.
|
|
|
*
|
|
|
* @method #init
|
|
|
* @returns {null|Promise}
|
|
|
@@ -155,7 +155,7 @@ mix( Plugin, ObservableMixin );
|
|
|
/**
|
|
|
* The third (and last) stage of plugin initialization. See also {@link #constructor} and {@link #init}.
|
|
|
*
|
|
|
- * **Note:** This method is optional. A plugin instance does not need to have to have it defined.
|
|
|
+ * **Note:** This method is optional. A plugin instance does not need to have it defined.
|
|
|
*
|
|
|
* @method #afterInit
|
|
|
* @returns {null|Promise}
|
|
|
@@ -164,7 +164,7 @@ mix( Plugin, ObservableMixin );
|
|
|
/**
|
|
|
* Destroys the plugin.
|
|
|
*
|
|
|
- * **Note:** This method is optional. A plugin instance does not need to have to have it defined.
|
|
|
+ * **Note:** This method is optional. A plugin instance does not need to have it defined.
|
|
|
*
|
|
|
* @method #destroy
|
|
|
* @returns {null|Promise}
|