Mastering Joomla! 1.5 Extension and Framework Development Second Edition

The Framework layer provides core functionality through an extensive set of libraries, plugins, and the Joomla! framework.

The Application layer extends the core JApplication class with applications designed for managing and performing specific tasks.

The JInstallation application runs when you install Joomla!. After successfully installing Joomla!, you are required to remove the installation folder, which contains the JInstallation application, before proceeding. The installation of extensions (components, modules, plugins, templates, and languages) is accomplished using the install functionality of the JAdministrator application.

The application for the Joomla! Administrator is JAdministrator. This application directs all of the backend administrative functions.

The application that is responsible for composing and delivering the frontend pages is JSite.

A Joomla! website can be administered remotely by using the XML-RPC application.

The Extension layer extends the Joomla! framework and applications, specifically with components, modules, templates, and languages. Plugins are also extensions but are placed in the Framework layer because they extend the framework, not applications. Joomla! is installed with a set of extensions including components for both the frontend and backend applications, templates, and modules.

Components are undoubtedly the most fundamental Joomla! extensions. Whenever Joomla! is invoked, a component is always called upon. Unlike in other extensions, output created by a component is displayed in the main content area. Since components are the most fundamental extension, they are also generally the most complex.

One component of which all Joomla! administrators will be aware, is the content component. This component is used to display articles, content categories, and content sections.

In addition to outputting component data as part of an XHTML page, we can output component data as Feeds, PDF, and RAW documents.

Many components tend to include, and sometimes require, additional extensions in order for them to behave as expected. When we create our own components, it is generally good practice to add 'hooks' in our code, which will enable other extensions to easily enhance our component beyond its base functionality.

Modules are used to display small pieces of content, usually to the left, right, top, or bottom of a rendered page. There are a number of core modules with which we will be instantly familiar, for example the menu modules.

There are various types of plugins, each of which can be used differently; however, most plugins are event driven. Plugins can attach listener functions and classes to specific events that Joomla! can throw using the global event dispatcher, for example, content filtering based on an event.

Joomla! has multilingual support, which enables us to present Joomla! in many different languages. Language extensions include files that define translated strings for different parts of Joomla!.

We will discuss how to create language files and how to use translations in Chapter 2, Getting Started and later in Chapter 9, Customizing the Page.

We use templates to modify the general appearance of Joomla!. There are two types of template extension: frontend site templates and backend administrator templates.

Most Joomla! sites use custom site templates to modify the appearance of the frontend (what the end-user sees). Admin templates modify the appearance of the backend (what the administrators see); these templates are less common.

There are many websites that offer free and commercial Joomla! templates, all of which are easy to locate using a search engine.

Tools, although referred to as extensions, are very different from components, modules, and plugins. The term 'tools' is used to describe any other type of extension that can be used in conjunction with Joomla!.

Tools are not installed within Joomla!; they are generally standalone scripts or applications, which may or may not require their own form of installation.

A good example of a Joomla! tool is JSAS (Joomla! Stand Alone Server). JSAS provides an easy way to set up Joomla! installations on a Windows-based system. To learn more about JSAS please refer to http://www.jsasonline.com..

An invaluable resource for developers is the developers' forge: http://www.joomlacode.org. This official site is used to host open source Joomla! projects. It provides third-party open-source Joomla! developers with free access to useful project development tools. This list details some of the tools JoomlaCode.org provides us:

If we intend to create an open source Joomla! project, we should consider using JoomlaCode.org to host the project, even if we do not intend to use all of the features it provides.

While you may not consider coding standards a tool, using a standardized format makes code easier to read and allows other developers to edit code more easily. Joomla! uses the PEAR coding standards. A complete guide to the PEAR coding standards is available at http://pear.php.net/manual/en/standards.php.

Here is a breakdown of the more common rules:

phpDocumentor is a documentation tool that allows us to easily create documentation from PHP source code. The documentation is extracted from the source and from special comments within the source; these comments are very similar to those used by JavaDoc.

This example demonstrates how we might document a simple function:

/**
 * Adds two integers together
 *
 * @param int $value1 Base value
 * @param int $value2 Value to add
 * @return int Resultant value
 */
function addition($value1, $value2)
{
    return ((int)$value1 + (int)$value2)
}

The multiline comment denotes a DocBlock. Note that it uses a double asterisk at the start. The first line is a general description of the function; this description can span more than one line. @param and @return are tags.

The @param tag is used to define a parameter in the format (the name is optional):

@param type [$name] description

The @return tag is used to define the return value in the format:

@return type description

Our initial example is telling us that the addition() function has two named integer parameters that it will add together. It will then return the resultant integer value.

When we document complex functions, we might want to provide two descriptions: a long description and a short description. This example demonstrates how we do this:

/**
 * Does some complex processing
 *
 * A verbose description of the function that spans more than
 * one line
 *
 * @param int $value1 Base value
 * @param int $value2 Value to add
 * @return int Resultant vaue
 */
function someComplexFunction($value1, $value2)
{
    // does some complex processing
}

Functions are not the only elements that can be documented. Elements that we can document include:

This list defines some common tags we are likely to encounter:

The DocBlocks are easy to read when they are displayed in code, but, more importantly, we can automatically create documentation from the source code. For more information about using phpDocumentor, please refer to http://www.phpdoc.org/.

J!Dump allows us to output variables during development. The output is displayed in a configurable pop-up window and describes data types and object properties and methods.

J!Dump comes as two separate extensions: a component, which we use to configure the functionality of J!Dump, and a system plugin, which defines functions that we use to 'dump' data to the J!Dump pop-up. Both extensions are required in order for J!Dump to function correctly.

The most important function in J!Dump is the dump() function. We can pass a variable to this function, and it will be displayed in the pop-up. This example demonstrates how we use the dump() function:

// create example object
$object = new JObject();
$object->set('name', 'example');

// dump object to popup
dump($object, 'Example Object');

Using this will create a pop up, which looks like this:

Other functions we can use include dumpMessage(), dumpSysinfo(), dumpTemplate(), and dumpTrace().