How to make Component In Joomla 1.5 ?

Creating a Component
For our basic component, we only require five files:
• site/hello.php - this is the entry point to our component
• site/controller.php - this file contains our base controller
• site/views/hello/view.html.php - this file retrieves the necessary data and pushes it into the template
• site/views/hello/tmpl/default.php - this is the template for our output
• hello.xml - this is an XML (manifest) file that tells Joomla! how to install our component.
Remember that the filename for the entry point must have the same name of the component. For example, if you call your component "Very Intricate Name Component", at install time (see below in the hello.xml section) Joomla! will create the folder com_veryintricatenamecomponent and the entry point php file must be named veryintricatenamecomponent.php otherwise it will not work. Be aware that use of some special characters, notibly the underscore '_', may have special meaning in Joomla and should be avoided in component names or files.
The site directory here is for the parts of the component which are installed in the front end site.
Naming conventions
Main article: Naming conventions
At this point it is important to say that some words are reserved for using in component or its class names, and violating some of that will produce a hard for debugging error. One of them is "view" (in any character case) for view class (subclass of JView) and controller class (subclass of JController), because view class need to have first part of name the same as controller class name, and component name (although violating of last one won't produce an error, it's just a useful convention).
All filenames and foldernames for models, views and controllers must be lower-case in order to operate well on Unix/Linux-systems.

Creating the Entry Point

This recently added article requires a review
Joomla! is always accessed through a single point of entry: index.php for the Site Application or administrator/index.php for the Administrator Application. The application will then load the required component, based on the value of 'option' in the URL or in the POST data. For our component, the URL would be:
index.php?option=com_hello&view=hello
This will load our main file, which can be seen as the single point of entry for our component: components/com_hello/hello.php.
The code for this file is fairly typical across components.
site/hello.php:
execute( JRequest::getWord( 'task' ) );

// Redirect if set by the controller
$controller->redirect();
The first statement is a security check.
JPATH_COMPONENT is the absolute path to the current component, in our case components/com_hello. If you specifically need either the Site component or the Administrator component, you can use JPATH_COMPONENT_SITE or JPATH_COMPONENT_ADMINISTRATOR.
DS is the directory separator of your system: either '/' or '\'. This is automatically set by the framework so the developer doesn't have to worry about developing different versions for different server OSs. The 'DS' constant should always be used when referring to files on the local server.
After loading the base controller, we check if a specific controller is needed. In this component, the base controller is the only controller, but we will leave this conditional check "in place" for future use.
JRequest:getWord() finds a word variable in the URL or the POST data. So if our URL is index.php?option=com_hello&controller=controller_name, then we can retrieve our controller name in our component using: echo JRequest::getWord('controller');
Now we have our base controller 'HelloController' in com_hello/controller.php, and, if needed, additional controllers like 'HelloControllerController1' in com_hello/controllers/controller1.php. Using this standard naming scheme will make things easy later on: '{Componentname}{Controller}{Controllername}'
After the controller is created, we instruct the controller to execute the task, as defined in the URL: index.php?option=com_hello&task=sometask. If no task is set, the default task 'display' will be assumed. When display is used, the 'view' variable will decide what will be displayed. Other common tasks are save, edit, new...
The controller might decide to redirect the page, usually after a task like 'save' has been completed. This last statement takes care of the actual redirection.
The main entry point (hello.php) essentially passes control to the controller, which handles performing the task that was specified in the request.
Note that we don't use a closing php tag in this file: ?>. The reason for this is that we will not have any unwanted whitespace in the output code. This is default practice since Joomla! 1.5, and will be used for all php-only files.


Creating the Controller
Our component only has one task - greet the world. Therefore, the controller will be very simple. No data manipulation is required. All that needs to be done is the appropriate view loaded. We will have only one method in our controller: display(). Most of the required functionality is built into the JController class, so all that we need to do is invoke the JController::display() method.
The code for the base controller site/controller.php is:
Creating the View

The task of the view is very simple: It retrieves the data to be displayed and pushes it into the template. Data is pushed into the template using the JView::assignRef method. (Note: The key (the first argument) passed to the assignRef method cannot be preceded by an underscore i.e. $this->assignRef('_greeting',$greeting). Doing so will cause the assignRef method to return false and your variable will not be pushed into the template.)
The code for the view at site/views/hello/view.html.php:
assignRef( 'greeting', $greeting );

parent::display($tpl);
}
}

Creating the Template

Joomla! templates/layouts are regular PHP files that are used to layout the data from the view in a particular manner. The variables assigned by the JView::assignRef method can be accessed from the template using $this->{propertyname} (see the template code below for an example).
Our template is very simple: we only want to display the greeting that was passed in from the view - this file is:
site/views/hello/tmpl/default.php:

// No direct access

defined('_JEXEC') or die('Restricted access'); ?>

echo $this->greeting; ?>

Wrapping It All Up - Creating the hello.xml File
It is possible to install a component manually by copying the files using an FTP client and modifying the database tables. It is more efficient to create a package file that will allow the Joomla! Installer to do this for you. This package file contains a variety of information:
• basic descriptive details about your component (i.e. name), and optionally, a description, copyright and license information.
• a list of files that need to be copied.
• optionally, a PHP file that performs additional install and uninstall operations.
• optionally, an SQL file which contains database queries that should be executed upon install/uninstall

 version="1.0" encoding="utf-8"?>

 type="component" version="1.5.0">

>Hello>

>2007-02-22>

>John Doe>

>john.doe@example.org>

>http://www.example.org>

>Copyright Info>

>License Info>

>1.01>

>Description of the component ...>

 folder="site">

  >controller.php>

  >hello.php>

 >index.html>

  >views/index.html>

  >views/hello/index.html>

  >views/hello/view.html.php>

  >views/hello/tmpl/default.php>

  >views/hello/tmpl/index.html>

>

 >

  >Hello World!>

   folder="admin">

   >hello.php>

   >index.html>

  >

 >

>

Put this xml file, also called manifest, in the root of your package (because the installer will take its path as the root path for all other files).
Don't include itself under ...
You may have noticed the manifest source above mentioned files we have not discussed. These are the index.html files and the admin files. An index.html file is placed in each directory to prevent prying users from getting a directory listing. If there is no index.html file, some web servers will list the directory contents. This is often undesirable. These files have the simple line:

It will simply display a blank page.
The hello.php file in the admin folder is the entry point for the our component's admin section. Since our component has no administrator needs (yet), this file will have the same content as the index.html files for now.
If you've followed along, you can visit URL index.php?option=com_hello to see your work.