Source for file menuitem.php

Documentation is available at menuitem.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('groupedlist');
  13.  
  14. // Import the com_menus helper.
  15. require_once realpath(JPATH_ADMINISTRATOR . '/components/com_menus/helpers/menus.php');
  16.  
  17. /**
  18.  * Supports an HTML grouped select list of menu item grouped by menu
  19.  *
  20.  * @package     Joomla.Libraries
  21.  * @subpackage  Form
  22.  * @since       1.6
  23.  */
  24. class JFormFieldMenuitem extends JFormFieldGroupedList
  25. {
  26.     /**
  27.      * The form field type.
  28.      *
  29.      * @var    string 
  30.      * @since  1.6
  31.      */
  32.     public $type = 'MenuItem';
  33.  
  34.     /**
  35.      * The menu type.
  36.      *
  37.      * @var    string 
  38.      * @since  3.2
  39.      */
  40.     protected $menuType;
  41.  
  42.     /**
  43.      * The language.
  44.      *
  45.      * @var    array 
  46.      * @since  3.2
  47.      */
  48.     protected $language;
  49.  
  50.     /**
  51.      * The published status.
  52.      *
  53.      * @var    array 
  54.      * @since  3.2
  55.      */
  56.     protected $published;
  57.  
  58.     /**
  59.      * The disabled status.
  60.      *
  61.      * @var    array 
  62.      * @since  3.2
  63.      */
  64.     protected $disable;
  65.  
  66.     /**
  67.      * Method to get certain otherwise inaccessible properties from the form field object.
  68.      *
  69.      * @param   string  $name  The property name for which to the the value.
  70.      *
  71.      * @return  mixed  The property value or null.
  72.      *
  73.      * @since   3.2
  74.      */
  75.     public function __get($name)
  76.     {
  77.         switch ($name)
  78.         {
  79.             case 'menuType':
  80.             case 'language':
  81.             case 'published':
  82.             case 'disable':
  83.                 return $this->$name;
  84.         }
  85.  
  86.         return parent::__get($name);
  87.     }
  88.  
  89.     /**
  90.      * Method to set certain otherwise inaccessible properties of the form field object.
  91.      *
  92.      * @param   string  $name   The property name for which to the the value.
  93.      * @param   mixed   $value  The value of the property.
  94.      *
  95.      * @return  void 
  96.      *
  97.      * @since   3.2
  98.      */
  99.     public function __set($name, $value)
  100.     {
  101.         switch ($name)
  102.         {
  103.             case 'menuType':
  104.                 $this->menuType = (string) $value;
  105.                 break;
  106.  
  107.             case 'language':
  108.             case 'published':
  109.             case 'disable':
  110.                 $value = (string) $value;
  111.                 $this->$name = $value ? explode(',', $value) : array();
  112.                 break;
  113.  
  114.             default:
  115.                 parent::__set($name, $value);
  116.         }
  117.     }
  118.  
  119.     /**
  120.      * Method to attach a JForm object to the field.
  121.      *
  122.      * @param   SimpleXMLElement  $element  The SimpleXMLElement object representing the <field /> tag for the form field object.
  123.      * @param   mixed             $value    The form field value to validate.
  124.      * @param   string            $group    The field name group control value. This acts as as an array container for the field.
  125.      *                                       For example if the field has name="foo" and the group value is set to "bar" then the
  126.      *                                       full field name would end up being "bar[foo]".
  127.      *
  128.      * @return  boolean  True on success.
  129.      *
  130.      * @see     JFormField::setup()
  131.      * @since   3.2
  132.      */
  133.     public function setup(SimpleXMLElement $element, $value, $group = null)
  134.     {
  135.         $result = parent::setup($element, $value, $group);
  136.  
  137.         if ($result == true)
  138.         {
  139.             $this->menuType  = (string) $this->element['menu_type'];
  140.             $this->published = $this->element['published'] ? explode(',', (string) $this->element['published']) : array();
  141.             $this->disable   = $this->element['disable'] ? explode(',', (string) $this->element['disable']) : array();
  142.             $this->language  = $this->element['language'] ? explode(',', (string) $this->element['language']) : array();
  143.         }
  144.  
  145.         return $result;
  146.     }
  147.  
  148.     /**
  149.      * Method to get the field option groups.
  150.      *
  151.      * @return  array  The field option objects as a nested array in groups.
  152.      *
  153.      * @since   1.6
  154.      */
  155.     protected function getGroups()
  156.     {
  157.         $groups = array();
  158.  
  159.         $menuType = $this->menuType;
  160.  
  161.         // Get the menu items.
  162.         $items = MenusHelper::getMenuLinks($menuType, 0, 0, $this->published, $this->language);
  163.  
  164.         // Build group for a specific menu type.
  165.         if ($menuType)
  166.         {
  167.             // Initialize the group.
  168.             $groups[$menuType] = array();
  169.  
  170.             // Build the options array.
  171.             foreach ($items as $link)
  172.             {
  173.                 $groups[$menuType][] = JHtml::_('select.option', $link->value, $link->text, 'value', 'text', in_array($link->type, $this->disable));
  174.             }
  175.         }
  176.         // Build groups for all menu types.
  177.         else
  178.         {
  179.             // Build the groups arrays.
  180.             foreach ($items as $menu)
  181.             {
  182.                 // Initialize the group.
  183.                 $groups[$menu->menutype] = array();
  184.  
  185.                 // Build the options array.
  186.                 foreach ($menu->links as $link)
  187.                 {
  188.                     $groups[$menu->menutype][] = JHtml::_(
  189.                         'select.option', $link->value, $link->text, 'value', 'text',
  190.                         in_array($link->type, $this->disable)
  191.                     );
  192.                 }
  193.             }
  194.         }
  195.  
  196.         // Merge any additional groups in the XML definition.
  197.         $groups = array_merge(parent::getGroups(), $groups);
  198.  
  199.         return $groups;
  200.     }
  201. }

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