[Summary view]

Differences Between: [Versions 310 and 311] [Versions 310 and 400] [Versions 310 and 401] [Versions 310 and 402] [Versions 310 and 403] [Versions 39 and 310]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  
  18  /**
  19   * Editor input element
  20   *
  21   * Contains class to create preffered editor form element
  22   *
  23   * @package   core_form
  24   * @copyright 2009 Petr Skoda {@link http://skodak.org}
  25   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26   */
  27  
  28  global $CFG;
  29  
  30  require_once('HTML/QuickForm/element.php');
  31  require_once($CFG->dirroot.'/lib/filelib.php');
  32  require_once($CFG->dirroot.'/repository/lib.php');
  33  require_once ('templatable_form_element.php');
  34  
  35  /**
  36   * Editor element
  37   *
  38   * It creates preffered editor (textbox/TinyMce) form element for the format (Text/HTML) selected.
  39   *
  40   * @package   core_form
  41   * @category  form
  42   * @copyright 2009 Petr Skoda {@link http://skodak.org}
  43   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  44   * @todo      MDL-29421 element Freezing
  45   * @todo      MDL-29426 ajax format conversion
  46   */
  47  class MoodleQuickForm_editor extends HTML_QuickForm_element implements templatable {
  48      use templatable_form_element {
  49          export_for_template as export_for_template_base;
  50      }
  51  
  52      /** @var string html for help button, if empty then no help will icon will be dispalyed. */
  53      public $_helpbutton = '';
  54  
  55      /** @var string defines the type of editor */
  56      public $_type       = 'editor';
  57  
  58      /** @var array options provided to initalize filepicker */
  59      protected $_options = array('subdirs' => 0, 'maxbytes' => 0, 'maxfiles' => 0, 'changeformat' => 0,
  60              'areamaxbytes' => FILE_AREA_MAX_BYTES_UNLIMITED, 'context' => null, 'noclean' => 0, 'trusttext' => 0,
  61              'return_types' => 15, 'enable_filemanagement' => true, 'removeorphaneddrafts' => false, 'autosave' => true);
  62      // 15 is $_options['return_types'] = FILE_INTERNAL | FILE_EXTERNAL | FILE_REFERENCE | FILE_CONTROLLED_LINK.
  63  
  64      /** @var array values for editor */
  65      protected $_values     = array('text'=>null, 'format'=>null, 'itemid'=>null);
  66  
  67      /**
  68       * Constructor
  69       *
  70       * @param string $elementName (optional) name of the editor
  71       * @param string $elementLabel (optional) editor label
  72       * @param array $attributes (optional) Either a typical HTML attribute string
  73       *              or an associative array
  74       * @param array $options set of options to initalize filepicker
  75       */
  76      public function __construct($elementName=null, $elementLabel=null, $attributes=null, $options=null) {
  77          global $CFG, $PAGE;
  78  
  79          $options = (array)$options;
  80          foreach ($options as $name=>$value) {
  81              if (array_key_exists($name, $this->_options)) {
  82                  $this->_options[$name] = $value;
  83              }
  84          }
  85          if (!empty($options['maxbytes'])) {
  86              $this->_options['maxbytes'] = get_max_upload_file_size($CFG->maxbytes, $options['maxbytes']);
  87          }
  88          if (!$this->_options['context']) {
  89              // trying to set context to the current page context to make legacy files show in filepicker (e.g. forum post)
  90              if (!empty($PAGE->context->id)) {
  91                  $this->_options['context'] = $PAGE->context;
  92              } else {
  93                  $this->_options['context'] = context_system::instance();
  94              }
  95          }
  96          $this->_options['trusted'] = trusttext_trusted($this->_options['context']);
  97          parent::__construct($elementName, $elementLabel, $attributes);
  98  
  99          // Note: for some reason the code using this setting does not like bools.
 100          $this->_options['subdirs'] = (int)($this->_options['subdirs'] == 1);
 101  
 102          editors_head_setup();
 103      }
 104  
 105      /**
 106       * Old syntax of class constructor. Deprecated in PHP7.
 107       *
 108       * @deprecated since Moodle 3.1
 109       */
 110      public function MoodleQuickForm_editor($elementName=null, $elementLabel=null, $attributes=null, $options=null) {
 111          debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
 112          self::__construct($elementName, $elementLabel, $attributes, $options);
 113      }
 114  
 115      /**
 116       * Called by HTML_QuickForm whenever form event is made on this element
 117       *
 118       * @param string $event Name of event
 119       * @param mixed $arg event arguments
 120       * @param object $caller calling object
 121       * @return bool
 122       */
 123      function onQuickFormEvent($event, $arg, &$caller)
 124      {
 125          switch ($event) {
 126              case 'createElement':
 127                  $caller->setType($arg[0] . '[format]', PARAM_ALPHANUM);
 128                  $caller->setType($arg[0] . '[itemid]', PARAM_INT);
 129                  break;
 130          }
 131          return parent::onQuickFormEvent($event, $arg, $caller);
 132      }
 133  
 134      /**
 135       * Sets name of editor
 136       *
 137       * @param string $name name of the editor
 138       */
 139      function setName($name) {
 140          $this->updateAttributes(array('name'=>$name));
 141      }
 142  
 143      /**
 144       * Returns name of element
 145       *
 146       * @return string
 147       */
 148      function getName() {
 149          return $this->getAttribute('name');
 150      }
 151  
 152      /**
 153       * Updates editor values, if part of $_values
 154       *
 155       * @param array $values associative array of values to set
 156       */
 157      function setValue($values) {
 158          $values = (array)$values;
 159          foreach ($values as $name=>$value) {
 160              if (array_key_exists($name, $this->_values)) {
 161                  $this->_values[$name] = $value;
 162              }
 163          }
 164      }
 165  
 166      /**
 167       * Returns editor values
 168       *
 169       * @return array
 170       */
 171      function getValue() {
 172          return $this->_values;
 173      }
 174  
 175      /**
 176       * Returns maximum file size which can be uploaded
 177       *
 178       * @return int
 179       */
 180      function getMaxbytes() {
 181          return $this->_options['maxbytes'];
 182      }
 183  
 184      /**
 185       * Sets maximum file size which can be uploaded
 186       *
 187       * @param int $maxbytes file size
 188       */
 189      function setMaxbytes($maxbytes) {
 190          global $CFG;
 191          $this->_options['maxbytes'] = get_max_upload_file_size($CFG->maxbytes, $maxbytes);
 192      }
 193  
 194       /**
 195       * Returns the maximum size of the area.
 196       *
 197       * @return int
 198       */
 199      function getAreamaxbytes() {
 200          return $this->_options['areamaxbytes'];
 201      }
 202  
 203      /**
 204       * Sets the maximum size of the area.
 205       *
 206       * @param int $areamaxbytes size limit
 207       */
 208      function setAreamaxbytes($areamaxbytes) {
 209          $this->_options['areamaxbytes'] = $areamaxbytes;
 210      }
 211  
 212      /**
 213       * Returns maximum number of files which can be uploaded
 214       *
 215       * @return int
 216       */
 217      function getMaxfiles() {
 218          return $this->_options['maxfiles'];
 219      }
 220  
 221      /**
 222       * Sets maximum number of files which can be uploaded.
 223       *
 224       * @param int $num number of files
 225       */
 226      function setMaxfiles($num) {
 227          $this->_options['maxfiles'] = $num;
 228      }
 229  
 230      /**
 231       * Returns true if subdirectoy can be created, else false
 232       *
 233       * @return bool
 234       */
 235      function getSubdirs() {
 236          return $this->_options['subdirs'];
 237      }
 238  
 239      /**
 240       * Set option to create sub directory, while uploading  file
 241       *
 242       * @param bool $allow true if sub directory can be created.
 243       */
 244      function setSubdirs($allow) {
 245          $this->_options['subdirs'] = (int)($allow == 1);
 246      }
 247  
 248      /**
 249       * Returns editor format
 250       *
 251       * @return int.
 252       */
 253      function getFormat() {
 254          return $this->_values['format'];
 255      }
 256  
 257      /**
 258       * Checks if editor used is a required field
 259       *
 260       * @return bool true if required field.
 261       */
 262      function isRequired() {
 263          return (isset($this->_options['required']) && $this->_options['required']);
 264      }
 265  
 266      /**
 267       * @deprecated since Moodle 2.0
 268       */
 269      function setHelpButton($_helpbuttonargs, $function='_helpbutton') {
 270          throw new coding_exception('setHelpButton() can not be used any more, please see MoodleQuickForm::addHelpButton().');
 271      }
 272  
 273      /**
 274       * Returns html for help button.
 275       *
 276       * @return string html for help button
 277       */
 278      function getHelpButton() {
 279          return $this->_helpbutton;
 280      }
 281  
 282      /**
 283       * Returns type of editor element
 284       *
 285       * @return string
 286       */
 287      function getElementTemplateType() {
 288          if ($this->_flagFrozen){
 289              return 'nodisplay';
 290          } else {
 291              return 'default';
 292          }
 293      }
 294  
 295      /**
 296       * Returns HTML for editor form element.
 297       *
 298       * @return string
 299       */
 300      function toHtml() {
 301          global $CFG, $PAGE, $OUTPUT;
 302          require_once($CFG->dirroot.'/repository/lib.php');
 303  
 304          if ($this->_flagFrozen) {
 305              return $this->getFrozenHtml();
 306          }
 307  
 308          $ctx = $this->_options['context'];
 309  
 310          $id           = $this->_attributes['id'];
 311          $elname       = $this->_attributes['name'];
 312  
 313          $subdirs      = $this->_options['subdirs'];
 314          $maxbytes     = $this->_options['maxbytes'];
 315          $areamaxbytes = $this->_options['areamaxbytes'];
 316          $maxfiles     = $this->_options['maxfiles'];
 317          $changeformat = $this->_options['changeformat']; // TO DO: implement as ajax calls
 318  
 319          $text         = $this->_values['text'];
 320          $format       = $this->_values['format'];
 321          $draftitemid  = $this->_values['itemid'];
 322  
 323          // security - never ever allow guest/not logged in user to upload anything
 324          if (isguestuser() or !isloggedin()) {
 325              $maxfiles = 0;
 326          }
 327  
 328          $str = $this->_getTabs();
 329          $str .= '<div>';
 330  
 331          $editor = editors_get_preferred_editor($format);
 332          $strformats = format_text_menu();
 333          $formats =  $editor->get_supported_formats();
 334          foreach ($formats as $fid) {
 335              $formats[$fid] = $strformats[$fid];
 336          }
 337  
 338          // get filepicker info
 339          //
 340          $fpoptions = array();
 341          if ($maxfiles != 0 ) {
 342              if (empty($draftitemid)) {
 343                  // no existing area info provided - let's use fresh new draft area
 344                  require_once("$CFG->libdir/filelib.php");
 345                  $this->setValue(array('itemid'=>file_get_unused_draft_itemid()));
 346                  $draftitemid = $this->_values['itemid'];
 347              }
 348  
 349              $args = new stdClass();
 350              // need these three to filter repositories list
 351              $args->accepted_types = array('web_image');
 352              $args->return_types = $this->_options['return_types'];
 353              $args->context = $ctx;
 354              $args->env = 'filepicker';
 355              // advimage plugin
 356              $image_options = initialise_filepicker($args);
 357              $image_options->context = $ctx;
 358              $image_options->client_id = uniqid();
 359              $image_options->maxbytes = $this->_options['maxbytes'];
 360              $image_options->areamaxbytes = $this->_options['areamaxbytes'];
 361              $image_options->env = 'editor';
 362              $image_options->itemid = $draftitemid;
 363  
 364              // moodlemedia plugin
 365              $args->accepted_types = array('video', 'audio');
 366              $media_options = initialise_filepicker($args);
 367              $media_options->context = $ctx;
 368              $media_options->client_id = uniqid();
 369              $media_options->maxbytes  = $this->_options['maxbytes'];
 370              $media_options->areamaxbytes  = $this->_options['areamaxbytes'];
 371              $media_options->env = 'editor';
 372              $media_options->itemid = $draftitemid;
 373  
 374              // advlink plugin
 375              $args->accepted_types = '*';
 376              $link_options = initialise_filepicker($args);
 377              $link_options->context = $ctx;
 378              $link_options->client_id = uniqid();
 379              $link_options->maxbytes  = $this->_options['maxbytes'];
 380              $link_options->areamaxbytes  = $this->_options['areamaxbytes'];
 381              $link_options->env = 'editor';
 382              $link_options->itemid = $draftitemid;
 383  
 384              $args->accepted_types = array('.vtt');
 385              $subtitle_options = initialise_filepicker($args);
 386              $subtitle_options->context = $ctx;
 387              $subtitle_options->client_id = uniqid();
 388              $subtitle_options->maxbytes  = $this->_options['maxbytes'];
 389              $subtitle_options->areamaxbytes  = $this->_options['areamaxbytes'];
 390              $subtitle_options->env = 'editor';
 391              $subtitle_options->itemid = $draftitemid;
 392  
 393              if (has_capability('moodle/h5p:deploy', $ctx)) {
 394                  // Only set H5P Plugin settings if the user can deploy new H5P content.
 395                  // H5P plugin.
 396                  $args->accepted_types = array('.h5p');
 397                  $h5poptions = initialise_filepicker($args);
 398                  $h5poptions->context = $ctx;
 399                  $h5poptions->client_id = uniqid();
 400                  $h5poptions->maxbytes  = $this->_options['maxbytes'];
 401                  $h5poptions->areamaxbytes  = $this->_options['areamaxbytes'];
 402                  $h5poptions->env = 'editor';
 403                  $h5poptions->itemid = $draftitemid;
 404                  $fpoptions['h5p'] = $h5poptions;
 405              }
 406  
 407              $fpoptions['image'] = $image_options;
 408              $fpoptions['media'] = $media_options;
 409              $fpoptions['link'] = $link_options;
 410              $fpoptions['subtitle'] = $subtitle_options;
 411          }
 412  
 413          //If editor is required and tinymce, then set required_tinymce option to initalize tinymce validation.
 414          if (($editor instanceof tinymce_texteditor)  && !is_null($this->getAttribute('onchange'))) {
 415              $this->_options['required'] = true;
 416          }
 417  
 418          // print text area - TODO: add on-the-fly switching, size configuration, etc.
 419          $editor->set_text($text);
 420          $editor->use_editor($id, $this->_options, $fpoptions);
 421  
 422          $rows = empty($this->_attributes['rows']) ? 15 : $this->_attributes['rows'];
 423          $cols = empty($this->_attributes['cols']) ? 80 : $this->_attributes['cols'];
 424  
 425          //Apply editor validation if required field
 426          $context = [];
 427          $context['rows'] = $rows;
 428          $context['cols'] = $cols;
 429          $context['frozen'] = $this->_flagFrozen;
 430          foreach ($this->getAttributes() as $name => $value) {
 431              $context[$name] = $value;
 432          }
 433          $context['hasformats'] = count($formats) > 1;
 434          $context['formats'] = [];
 435          if (($format === '' || $format === null) && count($formats)) {
 436              $format = key($formats);
 437          }
 438          foreach ($formats as $formatvalue => $formattext) {
 439              $context['formats'][] = ['value' => $formatvalue, 'text' => $formattext, 'selected' => ($formatvalue == $format)];
 440          }
 441          $context['id'] = $id;
 442          $context['value'] = $text;
 443          $context['format'] = $format;
 444  
 445          if (!is_null($this->getAttribute('onblur')) && !is_null($this->getAttribute('onchange'))) {
 446              $context['changelistener'] = true;
 447          }
 448  
 449          $str .= $OUTPUT->render_from_template('core_form/editor_textarea', $context);
 450  
 451          // during moodle installation, user area doesn't exist
 452          // so we need to disable filepicker here.
 453          if (!during_initial_install() && empty($CFG->adminsetuppending)) {
 454              // 0 means no files, -1 unlimited
 455              if ($maxfiles != 0 ) {
 456                  $str .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $elname.'[itemid]',
 457                          'value' => $draftitemid));
 458  
 459                  // used by non js editor only
 460                  $editorurl = new moodle_url("$CFG->wwwroot/repository/draftfiles_manager.php", array(
 461                      'action'=>'browse',
 462                      'env'=>'editor',
 463                      'itemid'=>$draftitemid,
 464                      'subdirs'=>$subdirs,
 465                      'maxbytes'=>$maxbytes,
 466                      'areamaxbytes' => $areamaxbytes,
 467                      'maxfiles'=>$maxfiles,
 468                      'ctx_id'=>$ctx->id,
 469                      'course'=>$PAGE->course->id,
 470                      'sesskey'=>sesskey(),
 471                      ));
 472                  $str .= '<noscript>';
 473                  $str .= "<div><object type='text/html' data='$editorurl' height='160' width='600' style='border:1px solid #000'></object></div>";
 474                  $str .= '</noscript>';
 475              }
 476          }
 477  
 478  
 479          $str .= '</div>';
 480  
 481          return $str;
 482      }
 483  
 484      public function export_for_template(renderer_base $output) {
 485          $context = $this->export_for_template_base($output);
 486          $context['html'] = $this->toHtml();
 487          return $context;
 488      }
 489  
 490      /**
 491       * What to display when element is frozen.
 492       *
 493       * @return empty string
 494       */
 495      function getFrozenHtml() {
 496  
 497          return '';
 498      }
 499  }