Commit 83193f1c authored by webchick's avatar webchick

Issue #1833716 by quicksketch, Wim Leers, sun, TwoD: Added WYSIWYG: Introduce...

Issue #1833716 by quicksketch, Wim Leers, sun, TwoD: Added WYSIWYG: Introduce 'Text editors' as part of filter format configuration.
parent b6ac1b81
<?php
/**
* @file
* Documentation for Text Editor API.
*/
/**
* @addtogroup hooks
* @{
*/
/**
* Performs alterations on text editor definitions.
*
* @param array $editors
* An array of metadata of text editors, as collected by the plugin annotation
* discovery mechanism.
*
* @see \Drupal\editor\Plugin\EditorBase
*/
function hook_editor_info_alter(array &$editors) {
$editors['some_other_editor']['label'] = t('A different name');
$editors['some_other_editor']['library']['module'] = 'myeditoroverride';
}
/**
* Provides defaults for editor instances.
*
* Modules that extend the list of settings for a particular text editor library
* should specify defaults for those settings using this hook. These settings
* will be used for any new editors, as well as merged into any existing editor
* configuration that has not yet been provided with a specific value for a
* setting (as may happen when a module providing a new setting is enabled after
* the text editor has been configured).
*
* Note that only the top-level of this array is merged into the defaults. If
* multiple modules provide nested settings with the same top-level key, only
* the first will be used. Modules should avoid deep nesting of settings to
* avoid defaults being undefined.
*
* The return value of this hook is not cached. If retrieving defaults in a
* complex manner, the implementing module should provide its own caching inside
* the hook.
*
* @param $editor
* A string indicating the name of the editor library whose default settings
* are being provided.
*
* @return array
* An array of default settings that will be merged into the editor defaults.
*/
function hook_editor_default_settings($editor) {
return array(
'mymodule_new_setting1' => TRUE,
'mymodule_new_setting2' => array(
'foo' => 'baz',
'bar' => 'qux',
),
);
}
/**
* Modifies default settings for editor instances.
*
* Modules that extend the behavior of other modules may use this hook to change
* the default settings provided to new and existing editors. This hook should
* be used when changing an existing setting to a new value. To add a new
* default setting, hook_editor_default_settings() should be used.
*
* The return value of this hook is not cached. If retrieving defaults in a
* complex manner, the implementing module should provide its own caching inside
* the hook.
*
* @param $default_settings
* The array of default settings which may be modified, passed by reference.
* @param $editor
* A string indicating the name of the editor library whose default settings
* are being provided.
*
* @return array
* An array of default settings that will be merged into the editor defaults.
*
* @see hook_editor_default_settings()
*/
function hook_editor_default_settings_alter(&$default_settings, $editor) {
$default_settings['toolbar'] = array('Bold', 'Italics', 'Underline');
}
/**
* Modifies JavaScript settings that are added for text editors.
*
* @param array $settings
* All the settings that will be added to the page via drupal_add_js() for
* the text formats to which a user has access.
* @param array $formats
* The list of format objects for which settings are being added.
*/
function hook_editor_js_settings_alter(array &$settings, array $formats) {
if (isset($formats['filtered_html'])) {
$settings['filtered_html']['editor'][] = 'MyDifferentEditor';
$settings['filtered_html']['editorSettings']['buttons'] = array('strong', 'italic', 'underline');
}
}
/**
* @} End of "addtogroup hooks".
*/
name = Text Editor
description = "Allows to associate text formats with text editor libraries such as WYSIWYGs or toolbars."
package = Core
version = VERSION
core = 8.x
dependencies[] = filter
configure = admin/config/content/formats
<?php
/**
* @file
* Adds bindings for client-side "text editors" to text formats.
*/
use Drupal\file\Plugin\Core\Entity\File;
use Drupal\editor\Plugin\Core\Entity\Editor;
use Drupal\Component\Utility\NestedArray;
/**
* Implements hook_help().
*/
function editor_help($path, $arg) {
switch ($path) {
case 'admin/help#editor':
$output = '';
$output .= '<h3>' . t('About') . '</h3>';
$output .= '<p>' . t('The Text Editor module provides a framework to extend the user interface on text fields that allow HTML input. Without Text Editor module, fields accept only text where formatting must be typed manually, such as entering a <code>&lt;strong&gt;</code> tag to make text bold or an <code>&lt;em&gt;</code> tag to italicize text. The Text Editor module allows these fields to be enhanced with rich text editors (WYSIWYGs) or toolbars, which make entering and formatting content easier. For more information, see the online handbook entry for <a href="@editor">Editor module</a>.', array('@editor' => 'http://drupal.org/documentation/modules/editor/')) . '</p>';
$output .= '<h3>' . t('Uses') . '</h3>';
$output .= '<dl>';
$output .= '<dt>' . t('Enabling or configuring a text editor') . '</dt>';
$output .= '<dd>' . t('The Text Editor module does not have its own configuration page. Instead it enhances existing configuration pages with additional options. Text editors are attached to individual text formats, which can be configured on the <a href="@formats">Text formats page</a>. Each text format may be associated with a single text editor. When entering content with that text format, the associated text editor will automatically be enabled.', array('@formats' => url('admin/config/content/formats'))) . '</dd>';
$output .= '<dt>' . t('Allowing a user to choose a text editor') . '</dt>';
$output .= '<dd>' . t('Because text editor configurations are bound to a text format, users with access to more than one text format may switch between available text editors by changing the text format for a field. For more information about text formats, see the <a href="@filter">Filter module help page</a>, which describes text formats in more detail.', array('@filter' => url('admin/help/filter'))) . '</dd>';
// @todo: Mention the availability of the built-in core WYSIWYG (CKEditor)
// when it becomes available. See http://drupal.org/node/1878344.
$output .= '<dt>' . t('Installing additional text editor libraries') . '</dt>';
$output .= '<dd>' . t('The Text Editor module does not provide any text editor libraries itself. Most installations of Drupal include a module that provides a text editor library which may be enabled on the <a href="@modules">Modules page</a>. Additional modules that provide text editor libraries may be <a href="@download">downloaded from Drupal.org</a>.', array('@modules' => url('admin/modules'), '@download' => 'http://drupal.org/search/site/wysiwyg%20module')) . '</dd>';
$output .= '</dl>';
return $output;
}
}
/**
* Implements hook_menu_alter().
*
* Rewrites the menu entries for filter module that relate to the configuration
* of text editors.
*/
function editor_menu_alter(&$items) {
$items['admin/config/content/formats']['title'] = 'Text formats and editors';
$items['admin/config/content/formats']['description'] = 'Configure how user-contributed content is filtered and formatted, as well as the text editor user interface (WYSIWYGs or toolbars).';
}
/**
* Implements hook_element_info().
*
* Extends the functionality of text_format elements (provided by Filter
* module), so that selecting a text format notifies a client-side text editor
* when it should be enabled or disabled.
*
* @see filter_element_info()
*/
function editor_element_info() {
$type['text_format'] = array(
'#pre_render' => array('editor_pre_render_format'),
);
return $type;
}
/**
* Implements hook_library_info().
*/
function editor_library_info() {
$path = drupal_get_path('module', 'editor');
$libraries['drupal.editor'] = array(
'title' => 'Text Editor',
'version' => VERSION,
'js' => array(
$path . '/js/editor.js' => array(),
),
'dependencies' => array(
array('system', 'jquery'),
array('system', 'drupal'),
array('system', 'drupalSettings'),
array('system', 'jquery.once'),
),
);
return $libraries;
}
/**
* Implements hook_form_FORM_ID_alter().
*/
function editor_form_filter_admin_overview_alter(&$form, $form_state) {
// @todo Cleanup column injection: http://drupal.org/node/1876718
// Splice in the column for "Text editor" into the header.
$position = array_search('name', $form['formats']['#header']) + 1;
$start = array_splice($form['formats']['#header'], 0, $position, array('editor' => t('Text editor')));
$form['formats']['#header'] = array_merge($start, $form['formats']['#header']);
// Then splice in the name of each text editor for each text format.
$editors = drupal_container()->get('plugin.manager.editor')->getDefinitions();
foreach (element_children($form['formats']) as $format_id) {
$editor = editor_load($format_id);
$editor_name = ($editor && isset($editors[$editor->editor])) ? $editors[$editor->editor]['label'] : drupal_placeholder('—');
$editor_column['editor'] = array('#markup' => $editor_name);
$position = array_search('name', array_keys($form['formats'][$format_id])) + 1;
$start = array_splice($form['formats'][$format_id], 0, $position, $editor_column);
$form['formats'][$format_id] = array_merge($start, $form['formats'][$format_id]);
}
}
/**
* Implements hook_form_FORM_ID_alter().
*/
function editor_form_filter_admin_format_form_alter(&$form, &$form_state) {
if (!isset($form_state['editor'])) {
$format_id = $form['#format']->format;
$form_state['editor'] = editor_load($format_id);
$form_state['editor_manager'] = drupal_container()->get('plugin.manager.editor');
}
$editor = $form_state['editor'];
$manager = $form_state['editor_manager'];
// Associate a text editor with this text format.
$editor_options = $manager->listOptions();
$form['editor'] = array(
'#type' => 'select',
'#title' => t('Text editor'),
'#options' => $editor_options,
'#empty_option' => t('None'),
'#default_value' => $editor ? $editor->editor : '',
// Position the editor selection before the filter settings (weight of 0),
// but after the filter label and name (weight of -20).
'#weight' => -9,
'#ajax' => array(
'trigger_as' => array('name' => 'editor_configure'),
'callback' => 'editor_form_filter_admin_form_ajax',
'wrapper' => 'editor-settings-wrapper',
),
);
$form['editor_configure'] = array(
'#type' => 'submit',
'#name' => 'editor_configure',
'#value' => t('Configure'),
'#limit_validation_errors' => array(array('editor')),
'#submit' => array('editor_form_filter_admin_format_editor_configure'),
'#ajax' => array(
'callback' => 'editor_form_filter_admin_form_ajax',
'wrapper' => 'editor-settings-wrapper',
),
'#weight' => -9,
'#attributes' => array('class' => array('js-hide')),
);
// If there aren't any options (other than "None"), disable the select list.
if (empty($editor_options)) {
$form['editor']['#disabled'] = TRUE;
$form['editor']['#description'] = t('This option is disabled because no modules that provide a text editor are currently enabled.');
}
$form['editor_settings'] = array(
'#tree' => TRUE,
'#weight' => -8,
'#type' => 'container',
'#id' => 'editor-settings-wrapper',
);
// Add editor-specific validation and submit handlers.
if ($editor) {
$plugin = $manager->createInstance($editor->editor);
$settings_form = array();
$settings_form['#element_validate'][] = array($plugin, 'settingsFormValidate');
$form['editor_settings']['settings'] = $plugin->settingsForm($settings_form, $form_state, $editor);
$form['editor_settings']['settings']['#parents'] = array('editor_settings');
$form['#submit'][] = array($plugin, 'settingsFormSubmit');
}
$form['#submit'][] = 'editor_form_filter_admin_format_submit';
}
/**
* Button submit handler for filter_admin_format_form()'s 'editor_configure' button.
*/
function editor_form_filter_admin_format_editor_configure($form, &$form_state) {
$editor = $form_state['editor'];
if (isset($form_state['values']['editor'])) {
if ($form_state['values']['editor'] === '') {
$form_state['editor'] = FALSE;
}
elseif (empty($editor) || $form_state['values']['editor'] !== $editor->editor) {
$editor = entity_create('editor', array(
'format' => $form['#format']->format,
'editor' => $form_state['values']['editor'],
));
$form_state['editor'] = $editor;
}
}
$form_state['rebuild'] = TRUE;
}
/**
* AJAX callback handler for filter_admin_format_form().
*/
function editor_form_filter_admin_form_ajax($form, &$form_state) {
return $form['editor_settings'];
}
/**
* Additional submit handler for filter_admin_format_form().
*/
function editor_form_filter_admin_format_submit($form, &$form_state) {
// Delete the existing editor if disabling or switching between editors.
$format_id = $form['#format']->format;
$original_editor = editor_load($format_id);
if ($original_editor && $original_editor->editor != $form_state['values']['editor']) {
$original_editor->delete();
}
// Create a new editor or update the existing editor.
if ($form_state['values']['editor'] !== '') {
$form_state['editor']->settings = $form_state['values']['editor_settings'];
$form_state['editor']->save();
}
}
/**
* Loads an individual configured text editor based on text format ID.
*
* @return \Drupal\editor\Plugin\Core\Entity\Editor|FALSE
* A text editor object, or FALSE.
*/
function editor_load($format_id) {
// Load all the editors at once here, assuming that either no editors or more
// than one editor will be needed on a page (such as having multiple text
// formats for administrators). Loading a small number of editors all at once
// is more efficient than loading multiple editors individually.
$editors = entity_load_multiple('editor');
return isset($editors[$format_id]) ? $editors[$format_id] : FALSE;
}
/**
* Additional #pre_render callback for 'text_format' elements.
*/
function editor_pre_render_format($element) {
// Allow modules to programmatically enforce no client-side editor by setting
// the #editor property to FALSE.
if (isset($element['#editor']) && !$element['#editor']) {
return $element;
}
// filter_process_format() copies properties to the expanded 'value' child
// element. Skip this text format widget, if it contains no 'format' or when
// the current user does not have access to edit the value.
if (!isset($element['format']) || !empty($element['value']['#disabled'])) {
return $element;
}
$format_ids = array_keys($element['format']['format']['#options']);
// Early-return if no text editor is associated with any of the text formats.
if (count(entity_load_multiple('editor', $format_ids)) === 0) {
return $element;
}
// Use a hidden element for a single text format.
$field_id = $element['value']['#id'];
if (!$element['format']['format']['#access']) {
// Use the first (and only) available text format.
$format_id = $format_ids[0];
$element['format']['editor'] = array(
'#type' => 'hidden',
'#name' => $element['format']['format']['#name'],
'#value' => $format_id,
'#attributes' => array(
'class' => array('editor'),
'data-editor-for' => $field_id,
),
);
}
// Otherwise, attach to text format selector.
else {
$element['format']['format']['#attributes']['class'][] = 'editor';
$element['format']['format']['#attributes']['data-editor-for'] = $field_id;
}
// Attach Text Editor module's (this module) library.
$element['#attached']['library'][] = array('editor', 'drupal.editor');
// Attach attachments for all available editors.
$manager = drupal_container()->get('plugin.manager.editor');
$element['#attached'] = NestedArray::mergeDeep($element['#attached'], $manager->getAttachments($format_ids));
return $element;
}
/**
* @file
* Attaches behavior for the Editor module.
*/
(function ($, Drupal) {
"use strict";
/**
* Initialize an empty object for editors to place their attachment code.
*/
Drupal.editors = {};
/**
* Enables editors on text_format elements.
*/
Drupal.behaviors.editor = {
attach: function (context, settings) {
// If there are no editor settings, there are no editors to enable.
if (!settings.editor) {
return;
}
var $context = $(context);
var behavior = this;
$context.find('.editor').once('editor', function () {
var $this = $(this);
var activeFormatID = $this.val();
var field = behavior.findFieldForFormatSelector($this);
// Directly attach this editor, if the text format is enabled.
if (settings.editor.formats[activeFormatID]) {
Drupal.editorAttach(field, settings.editor.formats[activeFormatID]);
}
// Attach onChange handler to text format selector element.
if ($this.is('select')) {
$this.on('change.editorAttach', function () {
var newFormatID = $this.val();
// Prevent double-attaching if the change event is triggered manually.
if (newFormatID === activeFormatID) {
return;
}
// Detach the current editor (if any) and attach a new editor.
if (settings.editor.formats[activeFormatID]) {
Drupal.editorDetach(field, settings.editor.formats[activeFormatID]);
}
activeFormatID = newFormatID;
if (settings.editor.formats[activeFormatID]) {
Drupal.editorAttach(field, settings.editor.formats[activeFormatID]);
}
});
}
// Detach any editor when the containing form is submitted.
$this.parents('form').submit(function (event) {
// Do not detach if the event was canceled.
if (event.isDefaultPrevented()) {
return;
}
Drupal.editorDetach(field, settings.editor.formats[activeFormatID]);
});
});
},
detach: function (context, settings, trigger) {
var editors;
// The 'serialize' trigger indicates that we should simply update the
// underlying element with the new text, without destroying the editor.
if (trigger == 'serialize') {
// Removing the editor-processed class guarantees that the editor will
// be reattached. Only do this if we're planning to destroy the editor.
editors = $(context).find('.editor-processed');
}
else {
editors = $(context).find('.editor').removeOnce('editor');
}
var behavior = this;
editors.each(function () {
var $this = $(this);
var activeFormatID = $this.val();
var field = behavior.findFieldForFormatSelector($this);
Drupal.editorDetach(field, settings.editor.formats[activeFormatID], trigger);
});
},
findFieldForFormatSelector: function ($formatSelector) {
var field_id = $formatSelector.attr('data-editor-for');
return $('#' + field_id).get(0);
}
};
Drupal.editorAttach = function (field, format) {
if (format.editor) {
Drupal.editors[format.editor].attach(field, format);
}
};
Drupal.editorDetach = function (field, format, trigger) {
if (format.editor) {
Drupal.editors[format.editor].detach(field, format, trigger);
}
};
})(jQuery, Drupal);
<?php
/**
* @file
* Contains \Drupal\editor\EditorBundle.
*/
namespace Drupal\editor;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\HttpKernel\Bundle\Bundle;
/**
* Editor dependency injection container.
*/
class EditorBundle extends Bundle {
/**
* Overrides Symfony\Component\HttpKernel\Bundle\Bundle::build().
*/
public function build(ContainerBuilder $container) {
// Register the plugin manager for our plugin type with the dependency
// injection container.
$container->register('plugin.manager.editor', 'Drupal\editor\Plugin\EditorManager');
}
}
<?php
/**
* @file
* Contains \Drupal\editor\Plugin\Core\Entity\Editor.
*/
namespace Drupal\editor\Plugin\Core\Entity;
use Drupal\Core\Config\Entity\ConfigEntityBase;
use Drupal\Core\Annotation\Plugin;
use Drupal\Core\Annotation\Translation;
/**
* Defines the configured text editor entity.
*
* @Plugin(
* id = "editor",
* label = @Translation("Editor"),
* module = "editor",
* controller_class = "Drupal\Core\Config\Entity\ConfigStorageController",
* config_prefix = "editor.editor",
* entity_keys = {
* "id" = "format",
* "uuid" = "uuid"
* }
* )
*/
class Editor extends ConfigEntityBase {
/**
* The machine name of the text format with which this configured text editor
* is associated.
*
* @var string
*/
public $format;
/**
* The name (plugin ID) of the text editor.
*
* @var string
*/
public $editor;
/**
* The array of settings for the text editor.
*
* @var array
*/
public $settings = array();
/**
* Overrides Drupal\Core\Entity\Entity::id().
*/
public function id() {
return $this->format;
}
/**
* Overrides Drupal\Core\Entity\Entity::label().