Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Joomla-Framework

License

Content on this site is copyright © 2005 - 2008 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5. Some parts of this website may be subject to other licenses.
Source code for file /joomla/application/component/helper.php

Documentation is available at helper.php

  1. <?php
  2. /**
  3. * @version        $Id: helper.php 9918 2008-01-10 01:41:37Z pasamio $
  4. * @package        Joomla.Framework
  5. * @subpackage    Application
  6. * @copyright    Copyright (C) 2005 - 2008 Open Source Matters. All rights reserved.
  7. * @license        GNU/GPL, see LICENSE.php
  8. *  Joomla! is free software. This version may have been modified pursuant
  9. *  to the GNU General Public License, and as distributed it includes or
  10. *  is derivative of works licensed under the GNU General Public License or
  11. *  other free or open source software licenses.
  12. *  See COPYRIGHT.php for copyright notices and details.
  13. */
  14.  
  15. // Check to ensure this file is within the rest of the framework
  16. defined('JPATH_BASE') or die();
  17.  
  18. /**
  19. * Component helper class
  20. *
  21. * @static
  22. * @author        Johan Janssens <johan.janssens@joomla.org>
  23. * @package        Joomla.Framework
  24. * @subpackage    Application
  25. * @since        1.5
  26. */
  27. class JComponentHelper
  28. {
  29.     /**
  30.      * Get the component info
  31.      *
  32.      * @access    public
  33.      * @param    string $name     The component name
  34.      * @param     boolean    $string    If set and a component does not exist, the enabled attribue will be set to false
  35.      * @return    object A JComponent object
  36.      */
  37.     function &getComponent( $name, $strict = false )
  38.     {
  39.         $result = null;
  40.         $components = JComponentHelper::_load();
  41.  
  42.         if (isset( $components[$name] ))
  43.         {
  44.             $result = &$components[$name];
  45.         }
  46.         else
  47.         {
  48.             $result                = new stdClass();
  49.             $result->enabled    = $strict ? false : true;
  50.             $result->params        = null;
  51.         }
  52.  
  53.         return $result;
  54.     }
  55.  
  56.     /**
  57.      * Checks if the component is enabled
  58.      *
  59.      * @access    public
  60.      * @param    string    $component The component name
  61.      * @param     boolean    $string    If set and a component does not exist, false will be returned
  62.      * @return    boolean 
  63.      */
  64.     function isEnabled( $component, $strict = false )
  65.     {
  66.         global $mainframe;
  67.  
  68.         $result = &JComponentHelper::getComponent( $component, $strict );
  69.         return ($result->enabled | $mainframe->isAdmin());
  70.     }
  71.  
  72.     /**
  73.      * Gets the parameter object for the component
  74.      *
  75.      * @access public
  76.      * @param string $name The component name
  77.      * @return object A JParameter object
  78.      */
  79.     function &getParams( $name )
  80.     {
  81.         static $instances;
  82.         if (!isset( $instances[$name] ))
  83.         {
  84.             $component = &JComponentHelper::getComponent( $name );
  85.             $instances[$name] = new JParameter($component->params);
  86.         }
  87.         return $instances[$name];
  88.     }
  89.  
  90.     function renderComponent($name = null, $params = array())
  91.     {
  92.         global $mainframe, $option;
  93.  
  94.         if(empty($name)) {
  95.             // Throw 404 if no component
  96.             JError::raiseError(404, JText::_("Component Not Found"));
  97.             return;
  98.         }
  99.         
  100.         $scope = $mainframe->scope; //record the scope
  101.         $mainframe->scope = $name;  //set scope to component name
  102.  
  103.         $task = JRequest::getString( 'task' );
  104.  
  105.         // Build the component path
  106.         $name = preg_replace('/[^A-Z0-9_\.-]/i', '', $name);
  107.         $file = substr( $name, 4 );
  108.  
  109.         // Define component path
  110.         define( 'JPATH_COMPONENT',                    JPATH_BASE.DS.'components'.DS.$name);
  111.         define( 'JPATH_COMPONENT_SITE',                JPATH_SITE.DS.'components'.DS.$name);
  112.         define( 'JPATH_COMPONENT_ADMINISTRATOR',    JPATH_ADMINISTRATOR.DS.'components'.DS.$name);
  113.  
  114.         // get component path
  115.         if ( $mainframe->isAdmin() && file_exists(JPATH_COMPONENT.DS.'admin.'.$file.'.php') ) {
  116.             $path = JPATH_COMPONENT.DS.'admin.'.$file.'.php';
  117.         } else {
  118.             $path = JPATH_COMPONENT.DS.$file.'.php';
  119.         }
  120.  
  121.         // If component disabled throw error
  122.         if (!JComponentHelper::isEnabled( $name ) || !file_exists($path)) {
  123.             JError::raiseError( 404, JText::_( 'Component Not Found' ) );
  124.         }
  125.  
  126.         // Handle legacy globals if enabled
  127.         if ($mainframe->getCfg('legacy'))
  128.         {
  129.             // Include legacy globals
  130.             global $my, $database, $id, $acl, $task;
  131.  
  132.             // For backwards compatibility extract the config vars as globals
  133.             $registry =& JFactory::getConfig();
  134.             foreach (get_object_vars($registry->toObject()) as $k => $v)
  135.             {
  136.                 $varname = 'mosConfig_'.$k;
  137.                 $$varname = $v;
  138.             }
  139.             $contentConfig = &JComponentHelper::getParams( 'com_content' );
  140.             foreach (get_object_vars($contentConfig->toObject()) as $k => $v)
  141.             {
  142.                 $varname = 'mosConfig_'.$k;
  143.                 $$varname = $v;
  144.             }
  145.             $usersConfig = &JComponentHelper::getParams( 'com_users' );
  146.             foreach (get_object_vars($usersConfig->toObject()) as $k => $v)
  147.             {
  148.                 $varname = 'mosConfig_'.$k;
  149.                 $$varname = $v;
  150.             }
  151.         }
  152.  
  153.         // Load common language files
  154.         $lang =& JFactory::getLanguage();
  155.         $lang->load($name);
  156.  
  157.         // Handle template preview outlining
  158.         $contents = null;
  159.  
  160.         // Execute the component
  161.         ob_start();
  162.         require_once $path;
  163.         $contents = ob_get_contents();
  164.         ob_end_clean();
  165.  
  166.         // Build the component toolbar
  167.         jimport( 'joomla.application.helper' );
  168.         if (($path = JApplicationHelper::getPath( 'toolbar' )) && $mainframe->isAdmin()) {
  169.  
  170.             // Get the task again, in case it has changed
  171.             $task = JRequest::getString( 'task' );
  172.  
  173.             // Make the toolbar
  174.             include_once( $path );
  175.         }
  176.         
  177.         $mainframe->scope = $scope; //revert the scope
  178.  
  179.         return $contents;
  180.     }
  181.  
  182.     /**
  183.      * Load components
  184.      *
  185.      * @access    private
  186.      * @return    array 
  187.      */
  188.     function _load()
  189.     {
  190.         static $components;
  191.  
  192.         if (isset($components)) {
  193.             return $components;
  194.         }
  195.  
  196.         $db = &JFactory::getDBO();
  197.  
  198.         $query = 'SELECT *' .
  199.                 ' FROM #__components' .
  200.                 ' WHERE parent = 0';
  201.         $db->setQuery( $query );
  202.  
  203.         if (!($components = $db->loadObjectList( 'option' ))) {
  204.             JError::raiseWarning( 'SOME_ERROR_CODE', "Error loading Components: " . $db->getErrorMsg());
  205.             return false;
  206.         }
  207.  
  208.         return $components;
  209.  
  210.     }
  211. }
Documentation generated on Tue, 29 Jan 2008 18:47:30 +0000 by phpDocumentor 1.3.1