Source for file componentlayout.php

Documentation is available at componentlayout.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Legacy
  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. jimport('joomla.filesystem.folder');
  13.  
  14. /**
  15.  * Form Field to display a list of the layouts for a component view from
  16.  * the extension or template overrides.
  17.  *
  18.  * @package     Joomla.Legacy
  19.  * @subpackage  Form
  20.  * @since       11.1
  21.  */
  22. class JFormFieldComponentlayout extends JFormField
  23. {
  24.     /**
  25.      * The form field type.
  26.      *
  27.      * @var    string 
  28.      * @since  11.1
  29.      */
  30.     protected $type = 'ComponentLayout';
  31.  
  32.     /**
  33.      * Method to get the field input for a component layout field.
  34.      *
  35.      * @return  string   The field input.
  36.      *
  37.      * @since   11.1
  38.      */
  39.     protected function getInput()
  40.     {
  41.         // Get the client id.
  42.         $clientId = $this->element['client_id'];
  43.  
  44.         if (is_null($clientId) && $this->form instanceof JForm)
  45.         {
  46.             $clientId = $this->form->getValue('client_id');
  47.         }
  48.         $clientId = (int) $clientId;
  49.  
  50.         $client = JApplicationHelper::getClientInfo($clientId);
  51.  
  52.         // Get the extension.
  53.         $extn = (string) $this->element['extension'];
  54.  
  55.         if (empty($extn) && ($this->form instanceof JForm))
  56.         {
  57.             $extn = $this->form->getValue('extension');
  58.         }
  59.  
  60.         $extn = preg_replace('#\W#', '', $extn);
  61.  
  62.         // Get the template.
  63.         $template = (string) $this->element['template'];
  64.         $template = preg_replace('#\W#', '', $template);
  65.  
  66.         // Get the style.
  67.         if ($this->form instanceof JForm)
  68.         {
  69.             $template_style_id = $this->form->getValue('template_style_id');
  70.         }
  71.  
  72.         $template_style_id = preg_replace('#\W#', '', $template_style_id);
  73.  
  74.         // Get the view.
  75.         $view = (string) $this->element['view'];
  76.         $view = preg_replace('#\W#', '', $view);
  77.  
  78.         // If a template, extension and view are present build the options.
  79.         if ($extn && $view && $client)
  80.         {
  81.  
  82.             // Load language file
  83.             $lang = JFactory::getLanguage();
  84.             $lang->load($extn . '.sys', JPATH_ADMINISTRATOR, null, false, true)
  85.                 || $lang->load($extn . '.sys', JPATH_ADMINISTRATOR . '/components/' . $extn, null, false, true);
  86.  
  87.             // Get the database object and a new query object.
  88.             $db = JFactory::getDbo();
  89.             $query = $db->getQuery(true);
  90.  
  91.             // Build the query.
  92.             $query->select('e.element, e.name')
  93.                 ->from('#__extensions as e')
  94.                 ->where('e.client_id = ' . (int) $clientId)
  95.                 ->where('e.type = ' . $db->quote('template'))
  96.                 ->where('e.enabled = 1');
  97.  
  98.             if ($template)
  99.             {
  100.                 $query->where('e.element = ' . $db->quote($template));
  101.             }
  102.  
  103.             if ($template_style_id)
  104.             {
  105.                 $query->join('LEFT', '#__template_styles as s on s.template=e.element')
  106.                     ->where('s.id=' . (int) $template_style_id);
  107.             }
  108.  
  109.             // Set the query and load the templates.
  110.             $db->setQuery($query);
  111.             $templates = $db->loadObjectList('element');
  112.  
  113.             // Build the search paths for component layouts.
  114.             $component_path = JPath::clean($client->path . '/components/' . $extn . '/views/' . $view . '/tmpl');
  115.  
  116.             // Prepare array of component layouts
  117.             $component_layouts = array();
  118.  
  119.             // Prepare the grouped list
  120.             $groups = array();
  121.  
  122.             // Add a Use Global option if useglobal="true" in XML file
  123.             if ($this->element['useglobal'] == 'true')
  124.             {
  125.                 $groups[JText::_('JOPTION_FROM_STANDARD')]['items'][] = JHtml::_('select.option', '', JText::_('JGLOBAL_USE_GLOBAL'));
  126.             }
  127.  
  128.             // Add the layout options from the component path.
  129.             if (is_dir($component_path) && ($component_layouts = JFolder::files($component_path, '^[^_]*\.xml$', false, true)))
  130.             {
  131.                 // Create the group for the component
  132.                 $groups['_'] = array();
  133.                 $groups['_']['id'] = $this->id . '__';
  134.                 $groups['_']['text'] = JText::sprintf('JOPTION_FROM_COMPONENT');
  135.                 $groups['_']['items'] = array();
  136.  
  137.                 foreach ($component_layouts as $i => $file)
  138.                 {
  139.                     // Attempt to load the XML file.
  140.                     if (!$xml = simplexml_load_file($file))
  141.                     {
  142.                         unset($component_layouts[$i]);
  143.  
  144.                         continue;
  145.                     }
  146.  
  147.                     // Get the help data from the XML file if present.
  148.                     if (!$menu = $xml->xpath('layout[1]'))
  149.                     {
  150.                         unset($component_layouts[$i]);
  151.  
  152.                         continue;
  153.                     }
  154.  
  155.                     $menu = $menu[0];
  156.  
  157.                     // Add an option to the component group
  158.                     $value = basename($file, '.xml');
  159.                     $component_layouts[$i] = $value;
  160.                     $text = isset($menu['option']) ? JText::_($menu['option']) : (isset($menu['title']) ? JText::_($menu['title']) : $value);
  161.                     $groups['_']['items'][] = JHtml::_('select.option', '_:' . $value, $text);
  162.                 }
  163.             }
  164.  
  165.             // Loop on all templates
  166.             if ($templates)
  167.             {
  168.                 foreach ($templates as $template)
  169.                 {
  170.                     // Load language file
  171.                     $lang->load('tpl_' . $template->element . '.sys', $client->path, null, false, true)
  172.                         || $lang->load('tpl_' . $template->element . '.sys', $client->path . '/templates/' . $template->element, null, false, true);
  173.  
  174.                     $template_path = JPath::clean($client->path . '/templates/' . $template->element . '/html/' . $extn . '/' . $view);
  175.  
  176.                     // Add the layout options from the template path.
  177.                     if (is_dir($template_path) && ($files = JFolder::files($template_path, '^[^_]*\.php$', false, true)))
  178.                     {
  179.                         // Files with corresponding XML files are alternate menu items, not alternate layout files
  180.                         // so we need to exclude these files from the list.
  181.                         $xml_files = JFolder::files($template_path, '^[^_]*\.xml$', false, true);
  182.                         for ($j = 0, $count = count($xml_files); $j < $count; $j++)
  183.                         {
  184.                             $xml_files[$j] = basename($xml_files[$j], '.xml');
  185.                         }
  186.                         foreach ($files as $i => $file)
  187.                         {
  188.                             // Remove layout files that exist in the component folder or that have XML files
  189.                             if ((in_array(basename($file, '.php'), $component_layouts))
  190.                                 || (in_array(basename($file, '.php'), $xml_files)))
  191.                             {
  192.                                 unset($files[$i]);
  193.                             }
  194.                         }
  195.                         if (count($files))
  196.                         {
  197.                             // Create the group for the template
  198.                             $groups[$template->name] = array();
  199.                             $groups[$template->name]['id'] = $this->id . '_' . $template->element;
  200.                             $groups[$template->name]['text'] = JText::sprintf('JOPTION_FROM_TEMPLATE', $template->name);
  201.                             $groups[$template->name]['items'] = array();
  202.  
  203.                             foreach ($files as $file)
  204.                             {
  205.                                 // Add an option to the template group
  206.                                 $value = basename($file, '.php');
  207.                                 $text = $lang
  208.                                     ->hasKey($key = strtoupper('TPL_' . $template->name . '_' . $extn . '_' . $view . '_LAYOUT_' . $value))
  209.                                     ? JText::_($key) : $value;
  210.                                 $groups[$template->name]['items'][] = JHtml::_('select.option', $template->element . ':' . $value, $text);
  211.                             }
  212.                         }
  213.                     }
  214.                 }
  215.             }
  216.  
  217.             // Compute attributes for the grouped list
  218.             $attr = $this->element['size'] ? ' size="' . (int) $this->element['size'] . '"' : '';
  219.  
  220.             // Prepare HTML code
  221.             $html = array();
  222.  
  223.             // Compute the current selected values
  224.             $selected = array($this->value);
  225.  
  226.             // Add a grouped list
  227.             $html[] = JHtml::_(
  228.                 'select.groupedlist', $groups, $this->name,
  229.                 array('id' => $this->id, 'group.id' => 'id', 'list.attr' => $attr, 'list.select' => $selected)
  230.             );
  231.  
  232.             return implode($html);
  233.         }
  234.         else
  235.         {
  236.             return '';
  237.         }
  238.     }
  239. }

Documentation generated on Tue, 19 Nov 2013 14:56:25 +0100 by phpDocumentor 1.4.3