Source for file editor.php

Documentation is available at editor.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Libraries
  4.  * @subpackage  Form
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. JFormHelper::loadFieldClass('textarea');
  13.  
  14. /**
  15.  * Form Field class for the Joomla CMS.
  16.  * A textarea field for content creation
  17.  *
  18.  * @package     Joomla.Libraries
  19.  * @subpackage  Form
  20.  * @see         JEditor
  21.  * @since       1.6
  22.  */
  23. class JFormFieldEditor extends JFormFieldTextarea
  24. {
  25.     /**
  26.      * The form field type.
  27.      *
  28.      * @var    string 
  29.      * @since  1.6
  30.      */
  31.     public $type = 'Editor';
  32.  
  33.     /**
  34.      * The JEditor object.
  35.      *
  36.      * @var    JEditor 
  37.      * @since  1.6
  38.      */
  39.     protected $editor;
  40.  
  41.     /**
  42.      * The height of the editor.
  43.      *
  44.      * @var    string 
  45.      * @since  3.2
  46.      */
  47.     protected $height;
  48.  
  49.     /**
  50.      * The width of the editor.
  51.      *
  52.      * @var    string 
  53.      * @since  3.2
  54.      */
  55.     protected $width;
  56.  
  57.     /**
  58.      * The assetField of the editor.
  59.      *
  60.      * @var    string 
  61.      * @since  3.2
  62.      */
  63.     protected $assetField;
  64.  
  65.     /**
  66.      * The authorField of the editor.
  67.      *
  68.      * @var    string 
  69.      * @since  3.2
  70.      */
  71.     protected $authorField;
  72.  
  73.     /**
  74.      * The asset of the editor.
  75.      *
  76.      * @var    string 
  77.      * @since  3.2
  78.      */
  79.     protected $asset;
  80.  
  81.     /**
  82.      * The buttons of the editor.
  83.      *
  84.      * @var    mixed 
  85.      * @since  3.2
  86.      */
  87.     protected $buttons;
  88.  
  89.     /**
  90.      * The hide of the editor.
  91.      *
  92.      * @var    array 
  93.      * @since  3.2
  94.      */
  95.     protected $hide;
  96.  
  97.     /**
  98.      * The editorType of the editor.
  99.      *
  100.      * @var    array 
  101.      * @since  3.2
  102.      */
  103.     protected $editorType;
  104.  
  105.     /**
  106.      * Method to get certain otherwise inaccessible properties from the form field object.
  107.      *
  108.      * @param   string  $name  The property name for which to the the value.
  109.      *
  110.      * @return  mixed  The property value or null.
  111.      *
  112.      * @since   3.2
  113.      */
  114.     public function __get($name)
  115.     {
  116.         switch ($name)
  117.         {
  118.             case 'height':
  119.             case 'width':
  120.             case 'assetField':
  121.             case 'authorField':
  122.             case 'asset':
  123.             case 'buttons':
  124.             case 'hide':
  125.             case 'editorType':
  126.                 return $this->$name;
  127.         }
  128.  
  129.         return parent::__get($name);
  130.     }
  131.  
  132.     /**
  133.      * Method to set certain otherwise inaccessible properties of the form field object.
  134.      *
  135.      * @param   string  $name   The property name for which to the the value.
  136.      * @param   mixed   $value  The value of the property.
  137.      *
  138.      * @return  void 
  139.      *
  140.      * @since   3.2
  141.      */
  142.     public function __set($name, $value)
  143.     {
  144.         switch ($name)
  145.         {
  146.             case 'height':
  147.             case 'width':
  148.             case 'assetField':
  149.             case 'authorField':
  150.             case 'asset':
  151.                 $this->$name = (string) $value;
  152.                 break;
  153.  
  154.             case 'buttons':
  155.                 $value = (string) $value;
  156.  
  157.                 if ($value == 'true' || $value == 'yes' || $value == '1')
  158.                 {
  159.                     $this->buttons = true;
  160.                 }
  161.                 elseif ($value == 'false' || $value == 'no' || $value == '0')
  162.                 {
  163.                     $this->buttons = false;
  164.                 }
  165.                 else
  166.                 {
  167.                     $this->buttons = explode(',', $value);
  168.                 }
  169.                 break;
  170.  
  171.             case 'hide':
  172.                 $value = (string) $value;
  173.                 $this->hide = $value ? explode(',', $value) : array();
  174.                 break;
  175.  
  176.             case 'editorType':
  177.                 // Can be in the form of: editor="desired|alternative".
  178.                 $this->editorType  = explode('|', trim((string) $value));
  179.                 break;
  180.  
  181.             default:
  182.                 parent::__set($name, $value);
  183.         }
  184.     }
  185.  
  186.     /**
  187.      * Method to attach a JForm object to the field.
  188.      *
  189.      * @param   SimpleXMLElement  $element  The SimpleXMLElement object representing the <field /> tag for the form field object.
  190.      * @param   mixed             $value    The form field value to validate.
  191.      * @param   string            $group    The field name group control value. This acts as as an array container for the field.
  192.      *                                       For example if the field has name="foo" and the group value is set to "bar" then the
  193.      *                                       full field name would end up being "bar[foo]".
  194.      *
  195.      * @return  boolean  True on success.
  196.      *
  197.      * @see     JFormField::setup()
  198.      * @since   3.2
  199.      */
  200.     public function setup(SimpleXMLElement $element, $value, $group = null)
  201.     {
  202.         $result = parent::setup($element, $value, $group);
  203.  
  204.         if ($result == true)
  205.         {
  206.             $this->height      = $this->element['height'] ? (string) $this->element['height'] : '500';
  207.             $this->width       = $this->element['width'] ? (string) $this->element['width'] : '100%';
  208.             $this->assetField  = $this->element['asset_field'] ? (string) $this->element['asset_field'] : 'asset_id';
  209.             $this->authorField = $this->element['created_by_field'] ? (string) $this->element['created_by_field'] : 'created_by';
  210.             $this->asset       = $this->form->getValue($this->assetField) ? $this->form->getValue($this->assetField) : (string) $this->element['asset_id'];
  211.  
  212.             $buttons    = (string) $this->element['buttons'];
  213.             $hide       = (string) $this->element['hide'];
  214.             $editorType = (string) $this->element['editor'];
  215.  
  216.             if ($buttons == 'true' || $buttons == 'yes' || $buttons == '1')
  217.             {
  218.                 $this->buttons = true;
  219.             }
  220.             elseif ($buttons == 'false' || $buttons == 'no' || $buttons == '0')
  221.             {
  222.                 $this->buttons = false;
  223.             }
  224.             else
  225.             {
  226.                 $this->buttons = !empty($hide) ? explode(',', $buttons) : array();
  227.             }
  228.  
  229.             $this->hide        = !empty($hide) ? explode(',', (string) $this->element['hide']) : array();
  230.             $this->editorType  = !empty($editorType) ? explode('|', trim($editorType)) : array();
  231.         }
  232.  
  233.         return $result;
  234.     }
  235.  
  236.     /**
  237.      * Method to get the field input markup for the editor area
  238.      *
  239.      * @return  string  The field input markup.
  240.      *
  241.      * @since   1.6
  242.      */
  243.     protected function getInput()
  244.     {
  245.         // Get an editor object.
  246.         $editor = $this->getEditor();
  247.  
  248.         return $editor->display(
  249.             $this->name, htmlspecialchars($this->value, ENT_COMPAT, 'UTF-8'), $this->width, $this->height, $this->cols, $this->rows,
  250.             $this->buttons ? (is_array($this->buttons) ? array_merge($this->buttons, $this->hide) : $this->hide) : false, $this->id, $this->asset,
  251.             $this->form->getValue($this->authorField), array('syntax' => (string) $this->element['syntax'])
  252.         );
  253.     }
  254.  
  255.     /**
  256.      * Method to get a JEditor object based on the form field.
  257.      *
  258.      * @return  JEditor  The JEditor object.
  259.      *
  260.      * @since   1.6
  261.      */
  262.     protected function getEditor()
  263.     {
  264.         // Only create the editor if it is not already created.
  265.         if (empty($this->editor))
  266.         {
  267.             $editor = null;
  268.  
  269.             if ($this->editorType)
  270.             {
  271.                 // Get the list of editor types.
  272.                 $types = $this->editorType;
  273.  
  274.                 // Get the database object.
  275.                 $db = JFactory::getDbo();
  276.  
  277.                 // Iterate over teh types looking for an existing editor.
  278.                 foreach ($types as $element)
  279.                 {
  280.                     // Build the query.
  281.                     $query = $db->getQuery(true)
  282.                         ->select('element')
  283.                         ->from('#__extensions')
  284.                         ->where('element = ' . $db->quote($element))
  285.                         ->where('folder = ' . $db->quote('editors'))
  286.                         ->where('enabled = 1');
  287.  
  288.                     // Check of the editor exists.
  289.                     $db->setQuery($query, 0, 1);
  290.                     $editor = $db->loadResult();
  291.  
  292.                     // If an editor was found stop looking.
  293.                     if ($editor)
  294.                     {
  295.                         break;
  296.                     }
  297.                 }
  298.             }
  299.  
  300.             // Create the JEditor instance based on the given editor.
  301.             if (is_null($editor))
  302.             {
  303.                 $conf = JFactory::getConfig();
  304.                 $editor = $conf->get('editor');
  305.             }
  306.  
  307.             $this->editor = JEditor::getInstance($editor);
  308.         }
  309.  
  310.         return $this->editor;
  311.     }
  312.  
  313.     /**
  314.      * Method to get the JEditor output for an onSave event.
  315.      *
  316.      * @return  string  The JEditor object output.
  317.      *
  318.      * @since   1.6
  319.      */
  320.     public function save()
  321.     {
  322.         return $this->getEditor()->save($this->id);
  323.     }
  324. }

Documentation generated on Tue, 19 Nov 2013 15:02:15 +0100 by phpDocumentor 1.4.3