Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Joomla-Framework

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /joomla/application/component/helper.php

Documentation is available at helper.php

  1. <?php
  2. /**
  3. * @version        $Id: helper.php 6688 2007-02-21 08:36:39Z louis $
  4. * @package        Joomla.Framework
  5. * @subpackage    Application
  6. * @copyright    Copyright (C) 2005 - 2007 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. /**
  16. * Component helper class
  17. *
  18. * @static
  19. * @author        Johan Janssens <[email protected]>
  20. * @package        Joomla.Framework
  21. * @subpackage    Application
  22. * @since        1.5
  23. */
  24. class JComponentHelper
  25. {
  26.     /**
  27.      * Get the component info
  28.      *
  29.      * @access public
  30.      * @param string $name     The component name
  31.      * @return object A JComponent object
  32.      */
  33.     function &getInfo( $name )
  34.     {
  35.         static $instances;
  36.  
  37.         if (!isset( $instances[$name] ))
  38.         {
  39.             $db = &JFactory::getDBO();
  40.  
  41.             $query = 'SELECT *' .
  42.                     ' FROM #__components' .
  43.                     ' WHERE parent = 0';
  44.             $db->setQuery( $query );
  45.             $instances = $db->loadObjectList( 'option' );
  46.         }
  47.  
  48.         if (isset( $instances[$name] ))
  49.         {
  50.             $result = &$instances[$name];
  51.         }
  52.         else
  53.         {
  54.             $result                = new stdClass();
  55.             $result->enabled    = true;
  56.             $result->params        = null;
  57.         }
  58.  
  59.         return $result;
  60.     }
  61.  
  62.     /**
  63.      * Checks if the component is enabled
  64.      *
  65.      * @access public
  66.      * @param string $name The component name
  67.      * @return boolean 
  68.      */
  69.     function isEnabled( $name )
  70.     {
  71.         global $mainframe;
  72.  
  73.         $component = &JComponentHelper::getInfo( $name );
  74.         return ($component->enabled | $mainframe->isAdmin());
  75.     }
  76.  
  77.     /**
  78.      * Gets the parameter object for the component
  79.      *
  80.      * @access public
  81.      * @param string $name The component name
  82.      * @return object A JParameter object
  83.      */
  84.     function &getParams( $name )
  85.     {
  86.         static $instances;
  87.         if (!isset( $instances[$name] ))
  88.         {
  89.             $component = &JComponentHelper::getInfo( $name );
  90.             $instances[$name] = new JParameter($component->params);
  91.         }
  92.         return $instances[$name];
  93.     }
  94.  
  95.     function renderComponent($name = null, $params = array())
  96.     {
  97.         global $mainframe, $option;
  98.  
  99.         if(empty($name)) {
  100.             return;
  101.         }
  102.  
  103.         $task        = JRequest::getVar( 'task' );
  104.  
  105.         // Build the component path
  106.         $file = substr( $name, 4 );
  107.  
  108.         // Define component path
  109.         define( 'JPATH_COMPONENT',                    JPATH_BASE.DS.'components'.DS.$name);
  110.         define( 'JPATH_COMPONENT_SITE',                JPATH_SITE.DS.'components'.DS.$name);
  111.         define( 'JPATH_COMPONENT_ADMINISTRATOR',    JPATH_ADMINISTRATOR.DS.'components'.DS.$name);
  112.  
  113.         // get component path
  114.         if ( $mainframe->isAdmin() && file_exists(JPATH_COMPONENT.DS.'admin.'.$file.'.php') ) {
  115.             $path = JPATH_COMPONENT.DS.'admin.'.$file.'.php';
  116.         } else {
  117.             $path = JPATH_COMPONENT.DS.$file.'.php';
  118.         }
  119.  
  120.         // If component disabled throw error
  121.         if (!JComponentHelper::isEnabled( $name ) || !file_exists($path)) {
  122.             JError::raiseError( 404, JText::_('Component Not Found') );
  123.         }
  124.  
  125.         // Handle legacy globals if enabled
  126.         if ($mainframe->getCfg('legacy'))
  127.         {
  128.             // Include legacy globals
  129.             global $my, $database, $id, $acl, $task;
  130.  
  131.             // For backwards compatibility extract the config vars as globals
  132.             $registry =& JFactory::getConfig();
  133.             foreach (get_object_vars($registry->toObject()) as $k => $v)
  134.             {
  135.                 $varname = 'mosConfig_'.$k;
  136.                 $$varname = $v;
  137.             }
  138.             $contentConfig = &JComponentHelper::getParams( 'com_content' );
  139.             foreach (get_object_vars($contentConfig->toObject()) as $k => $v)
  140.             {
  141.                 $varname = 'mosConfig_'.$k;
  142.                 $$varname = $v;
  143.             }
  144.             $usersConfig = &JComponentHelper::getParams( 'com_users' );
  145.             foreach (get_object_vars($usersConfig->toObject()) as $k => $v)
  146.             {
  147.                 $varname = 'mosConfig_'.$k;
  148.                 $$varname = $v;
  149.             }
  150.         }
  151.  
  152.         // Load common language files
  153.         $lang =& JFactory::getLanguage();
  154.         $lang->load($name);
  155.  
  156.         // Handle template preview outlining
  157.         $contents = null;
  158.  
  159.         // Execute the component
  160.         ob_start();
  161.         require_once $path;
  162.         $contents = ob_get_contents();
  163.         ob_end_clean();
  164.  
  165.         // Build the component toolbar
  166.         jimport( 'joomla.application.helper' );
  167.         if (($path = JApplicationHelper::getPath( 'toolbar' )) && $mainframe->isAdmin()) {
  168.  
  169.             // Get the task again, in case it has changed
  170.             $task        = JRequest::getVar( 'task' );
  171.  
  172.             // Make the toolbar
  173.             require_once( JPATH_ADMINISTRATOR .'/includes/menubar.html.php' );
  174.             include_once( $path );
  175.         }
  176.  
  177.         return $contents;
  178.     }
  179. }
  180. ?>
Documentation generated on Mon, 05 Mar 2007 21:05:37 +0000 by phpDocumentor 1.3.1