You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
476 lines
16 KiB
476 lines
16 KiB
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* TinyMCE text editor plugin base class.
|
|
*
|
|
* This is a base class for TinyMCE plugins implemented within Moodle. These
|
|
* plugins can optionally provide new buttons/plugins within TinyMCE itself,
|
|
* or configure the TinyMCE options.
|
|
*
|
|
* As well as overridable functions, other utility functions in this class
|
|
* can be used when writing the plugins.
|
|
*
|
|
* Finally, a static function in this class is used to call into all the
|
|
* plugins when required.
|
|
*
|
|
* @package editor_tinymce
|
|
* @copyright 2012 The Open University
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
abstract class editor_tinymce_plugin {
|
|
/** @var string Plugin folder */
|
|
protected $plugin;
|
|
|
|
/** @var array Plugin settings */
|
|
protected $config = null;
|
|
|
|
/** @var array list of buttons defined by this plugin */
|
|
protected $buttons = array();
|
|
|
|
/**
|
|
* @param string $plugin Name of folder
|
|
*/
|
|
public function __construct($plugin) {
|
|
$this->plugin = $plugin;
|
|
}
|
|
|
|
/**
|
|
* Returns list of buttons defined by this plugin.
|
|
* useful mostly as information when setting custom toolbar.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_buttons() {
|
|
return $this->buttons;
|
|
}
|
|
/**
|
|
* Makes sure config is loaded and cached.
|
|
* @return void
|
|
*/
|
|
protected function load_config() {
|
|
if (!isset($this->config)) {
|
|
$name = $this->get_name();
|
|
$this->config = get_config("tinymce_$name");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns plugin config value.
|
|
* @param string $name
|
|
* @param string $default value if config does not exist yet
|
|
* @return string value or default
|
|
*/
|
|
public function get_config($name, $default = null) {
|
|
$this->load_config();
|
|
return isset($this->config->$name) ? $this->config->$name : $default;
|
|
}
|
|
|
|
/**
|
|
* Sets plugin config value.
|
|
* @param string $name name of config
|
|
* @param string $value string config value, null means delete
|
|
* @return string value
|
|
*/
|
|
public function set_config($name, $value) {
|
|
$pluginname = $this->get_name();
|
|
$this->load_config();
|
|
if ($value === null) {
|
|
unset($this->config->$name);
|
|
} else {
|
|
$this->config->$name = $value;
|
|
}
|
|
set_config($name, $value, "tinymce_$pluginname");
|
|
}
|
|
|
|
/**
|
|
* Returns name of this tinymce plugin.
|
|
* @return string
|
|
*/
|
|
public function get_name() {
|
|
// All class names start with "tinymce_".
|
|
$words = explode('_', get_class($this), 2);
|
|
return $words[1];
|
|
}
|
|
|
|
/**
|
|
* Adjusts TinyMCE init parameters for this plugin.
|
|
*
|
|
* Subclasses must implement this function in order to carry out changes
|
|
* to the TinyMCE settings.
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @param context $context Context where editor is being shown
|
|
* @param array $options Options for this editor
|
|
*/
|
|
protected abstract function update_init_params(array &$params, context $context,
|
|
array $options = null);
|
|
|
|
/**
|
|
* Gets the order in which to run this plugin. Order usually only matters if
|
|
* (a) the place you add your button might depend on another plugin, or
|
|
* (b) you want to make some changes to layout etc. that should happen last.
|
|
* The default order is 100; within that, plugins are sorted alphabetically.
|
|
* Return a lower number if you want this plugin to run earlier, or a higher
|
|
* number if you want it to run later.
|
|
*/
|
|
protected function get_sort_order() {
|
|
return 100;
|
|
}
|
|
|
|
/**
|
|
* Adds a button to the editor, after another button (or at the end).
|
|
*
|
|
* Specify the location of this button using the $after variable. If you
|
|
* leave this blank, the button will be added at the end.
|
|
*
|
|
* If you want to try different possible locations depending on existing
|
|
* plugins you can set $alwaysadd to false and check the return value
|
|
* to see if it succeeded.
|
|
*
|
|
* Note: button will not be added if it is already present in any row
|
|
* (separator is an exception).
|
|
*
|
|
* The following example will add the button 'newbutton' after the
|
|
* 'existingbutton' if it exists or in the end of the last row otherwise:
|
|
* <pre>
|
|
* if ($row = $this->find_button($params, 'existingbutton')) {
|
|
* $this->add_button_after($params, $row, 'newbutton', 'existingbutton');
|
|
* } else {
|
|
* $this->add_button_after($params, $this->count_button_rows($params), 'newbutton');
|
|
* }
|
|
* </pre>
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @param int $row Row to add button to (1 to 3)
|
|
* @param string $button Identifier of button/plugin
|
|
* @param string $after Adds button directly after the named plugin
|
|
* @param bool $alwaysadd If specified $after string not found, add at end
|
|
* @return bool True if added or button already exists (in any row)
|
|
*/
|
|
protected function add_button_after(array &$params, $row, $button,
|
|
$after = '', $alwaysadd = true) {
|
|
|
|
if ($button !== '|' && $this->find_button($params, $button)) {
|
|
return true;
|
|
}
|
|
|
|
$row = $this->fix_row($params, $row);
|
|
|
|
$field = 'theme_advanced_buttons' . $row;
|
|
$old = $params[$field];
|
|
|
|
// Empty = add at end.
|
|
if ($after === '') {
|
|
$params[$field] = $old . ',' . $button;
|
|
return true;
|
|
}
|
|
|
|
// Try to add after given plugin.
|
|
$params[$field] = preg_replace('~(,|^)(' . preg_quote($after) . ')(,|$)~',
|
|
'$1$2,' . $button . '$3', $old);
|
|
if ($params[$field] !== $old) {
|
|
return true;
|
|
}
|
|
|
|
// If always adding, recurse to add it empty.
|
|
if ($alwaysadd) {
|
|
return $this->add_button_after($params, $row, $button);
|
|
}
|
|
|
|
// Otherwise return false (failed to add).
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Adds a button to the editor.
|
|
*
|
|
* Specify the location of this button using the $before variable. If you
|
|
* leave this blank, the button will be added at the start.
|
|
*
|
|
* If you want to try different possible locations depending on existing
|
|
* plugins you can set $alwaysadd to false and check the return value
|
|
* to see if it succeeded.
|
|
*
|
|
* Note: button will not be added if it is already present in any row
|
|
* (separator is an exception).
|
|
*
|
|
* The following example will add the button 'newbutton' before the
|
|
* 'existingbutton' if it exists or in the end of the last row otherwise:
|
|
* <pre>
|
|
* if ($row = $this->find_button($params, 'existingbutton')) {
|
|
* $this->add_button_before($params, $row, 'newbutton', 'existingbutton');
|
|
* } else {
|
|
* $this->add_button_after($params, $this->count_button_rows($params), 'newbutton');
|
|
* }
|
|
* </pre>
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @param int $row Row to add button to (1 to 10)
|
|
* @param string $button Identifier of button/plugin
|
|
* @param string $before Adds button directly before the named plugin
|
|
* @param bool $alwaysadd If specified $before string not found, add at start
|
|
* @return bool True if added or button already exists (in any row)
|
|
*/
|
|
protected function add_button_before(array &$params, $row, $button,
|
|
$before = '', $alwaysadd = true) {
|
|
|
|
if ($button !== '|' && $this->find_button($params, $button)) {
|
|
return true;
|
|
}
|
|
$row = $this->fix_row($params, $row);
|
|
|
|
$field = 'theme_advanced_buttons' . $row;
|
|
$old = $params[$field];
|
|
|
|
// Empty = add at start.
|
|
if ($before === '') {
|
|
$params[$field] = $button . ',' . $old;
|
|
return true;
|
|
}
|
|
|
|
// Try to add before given plugin.
|
|
$params[$field] = preg_replace('~(,|^)(' . preg_quote($before) . ')(,|$)~',
|
|
'$1' . $button . ',$2$3', $old);
|
|
if ($params[$field] !== $old) {
|
|
return true;
|
|
}
|
|
|
|
// If always adding, recurse to add it empty.
|
|
if ($alwaysadd) {
|
|
return $this->add_button_before($params, $row, $button);
|
|
}
|
|
|
|
// Otherwise return false (failed to add).
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Tests if button is already present.
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @param string $button button name
|
|
* @return false|int false if button is not found, row number otherwise (row numbers start from 1)
|
|
*/
|
|
protected function find_button(array &$params, $button) {
|
|
foreach ($params as $key => $value) {
|
|
if (preg_match('/^theme_advanced_buttons(\d+)$/', $key, $matches) &&
|
|
strpos(','. $value. ',', ','. $button. ',') !== false) {
|
|
return (int)$matches[1];
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks the row value is valid, fix if necessary.
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @param int $row Row to add button if exists
|
|
* @return int requested row if exists, lower number if does not exist.
|
|
*/
|
|
private function fix_row(array &$params, $row) {
|
|
if ($row <= 1) {
|
|
// Row 1 is always present.
|
|
return 1;
|
|
} else if (isset($params['theme_advanced_buttons' . $row])) {
|
|
return $row;
|
|
} else {
|
|
return $this->count_button_rows($params);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Counts the number of rows in TinyMCE editor (row numbering starts with 1)
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @return int the maximum existing row number
|
|
*/
|
|
protected function count_button_rows(array &$params) {
|
|
$maxrow = 1;
|
|
foreach ($params as $key => $value) {
|
|
if (preg_match('/^theme_advanced_buttons(\d+)$/', $key, $matches) &&
|
|
(int)$matches[1] > $maxrow) {
|
|
$maxrow = (int)$matches[1];
|
|
}
|
|
}
|
|
return $maxrow;
|
|
}
|
|
|
|
/**
|
|
* Adds a JavaScript plugin into TinyMCE. Note that adding a plugin does
|
|
* not by itself add a button; you must do both.
|
|
*
|
|
* If you leave $pluginname blank (default) it uses the folder name.
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @param string $pluginname Identifier for plugin within TinyMCE
|
|
* @param string $jsfile Name of JS file (within plugin 'tinymce' directory)
|
|
*/
|
|
protected function add_js_plugin(&$params, $pluginname='', $jsfile='editor_plugin.js') {
|
|
global $CFG;
|
|
|
|
// Set default plugin name.
|
|
if ($pluginname === '') {
|
|
$pluginname = $this->plugin;
|
|
}
|
|
|
|
// Add plugin to list in params, so it doesn't try to load it again.
|
|
$params['plugins'] .= ',-' . $pluginname;
|
|
|
|
// Add special param that causes Moodle TinyMCE init to load the plugin.
|
|
if (!isset($params['moodle_init_plugins'])) {
|
|
$params['moodle_init_plugins'] = '';
|
|
} else {
|
|
$params['moodle_init_plugins'] .= ',';
|
|
}
|
|
|
|
// Get URL of main JS file and store in params.
|
|
$jsurl = $this->get_tinymce_file_url($jsfile, false);
|
|
$params['moodle_init_plugins'] .= $pluginname . ':' . $jsurl;
|
|
}
|
|
|
|
/**
|
|
* Returns URL to files in the TinyMCE folder within this plugin, suitable
|
|
* for client-side use such as loading JavaScript files. (This URL normally
|
|
* goes through loader.php and contains the plugin version to ensure
|
|
* correct and long-term cacheing.)
|
|
*
|
|
* @param string $file Filename or path within the folder
|
|
* @param bool $absolute Set false to get relative URL from plugins folder
|
|
*/
|
|
public function get_tinymce_file_url($file='', $absolute=true) {
|
|
global $CFG;
|
|
|
|
// Version number comes from plugin version.php, except in developer
|
|
// mode where the special string 'dev' is used (prevents cacheing and
|
|
// serves unminified JS).
|
|
if ($CFG->debugdeveloper) {
|
|
$version = '-1';
|
|
} else {
|
|
$version = $this->get_version();
|
|
}
|
|
|
|
// Calculate the JS url (relative to the TinyMCE plugins folder - using
|
|
// relative URL saves a few bytes in each HTML page).
|
|
if ($CFG->slasharguments) {
|
|
// URL is usually from loader.php...
|
|
$jsurl = 'loader.php/' . $this->plugin . '/' . $version . '/' . $file;
|
|
} else {
|
|
// ...except when slash arguments are turned off it serves direct.
|
|
// In this situation there is no version details and it is up to
|
|
// the browser and server to negotiate cacheing, which will mean
|
|
// requesting the JS files frequently (reduced performance).
|
|
$jsurl = $this->plugin . '/tinymce/' . $file;
|
|
}
|
|
|
|
if ($absolute) {
|
|
$jsurl = $CFG->wwwroot . '/lib/editor/tinymce/plugins/' . $jsurl;
|
|
}
|
|
|
|
return $jsurl;
|
|
}
|
|
|
|
/**
|
|
* Obtains version number from version.php for this plugin.
|
|
*
|
|
* @return string Version number
|
|
*/
|
|
protected function get_version() {
|
|
global $CFG;
|
|
|
|
$plugin = new stdClass;
|
|
require($CFG->dirroot . '/lib/editor/tinymce/plugins/' . $this->plugin . '/version.php');
|
|
return $plugin->version;
|
|
}
|
|
|
|
/**
|
|
* Calls all available plugins to adjust the TinyMCE init parameters.
|
|
*
|
|
* @param array $params TinyMCE init parameters array
|
|
* @param context $context Context where editor is being shown
|
|
* @param array $options Options for this editor
|
|
*/
|
|
public static function all_update_init_params(array &$params,
|
|
context $context, array $options = null) {
|
|
global $CFG;
|
|
|
|
// Get list of plugin directories.
|
|
$plugins = core_component::get_plugin_list('tinymce');
|
|
|
|
// Get list of disabled subplugins.
|
|
$disabled = array();
|
|
if ($params['moodle_config']->disabledsubplugins) {
|
|
foreach (explode(',', $params['moodle_config']->disabledsubplugins) as $sp) {
|
|
$sp = trim($sp);
|
|
if ($sp !== '') {
|
|
$disabled[$sp] = $sp;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Construct all the plugins.
|
|
$pluginobjects = array();
|
|
foreach ($plugins as $plugin => $dir) {
|
|
if (isset($disabled[$plugin])) {
|
|
continue;
|
|
}
|
|
require_once($dir . '/lib.php');
|
|
$classname = 'tinymce_' . $plugin;
|
|
$pluginobjects[] = new $classname($plugin);
|
|
}
|
|
|
|
// Sort plugins by sort order and name.
|
|
usort($pluginobjects, array('editor_tinymce_plugin', 'compare_plugins'));
|
|
|
|
// Run the function for each plugin.
|
|
foreach ($pluginobjects as $obj) {
|
|
$obj->update_init_params($params, $context, $options);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets a named plugin object. Will cause fatal error if plugin doesn't exist.
|
|
*
|
|
* @param string $plugin Name of plugin e.g. 'moodleemoticon'
|
|
* @return editor_tinymce_plugin Plugin object
|
|
*/
|
|
public static function get($plugin) {
|
|
$dir = core_component::get_component_directory('tinymce_' . $plugin);
|
|
require_once($dir . '/lib.php');
|
|
$classname = 'tinymce_' . $plugin;
|
|
return new $classname($plugin);
|
|
}
|
|
|
|
/**
|
|
* Compares two plugins.
|
|
* @param editor_tinymce_plugin $a
|
|
* @param editor_tinymce_plugin $b
|
|
* @return Negative number if $a is before $b
|
|
*/
|
|
public static function compare_plugins(editor_tinymce_plugin $a, editor_tinymce_plugin $b) {
|
|
// Use sort order first.
|
|
$order = $a->get_sort_order() - $b->get_sort_order();
|
|
if ($order != 0) {
|
|
return $order;
|
|
}
|
|
|
|
// Then sort alphabetically.
|
|
return strcmp($a->plugin, $b->plugin);
|
|
}
|
|
}
|
|
|