The easiest method I could find was to use something similar to the following which first detects whether or not an XHTTP request has taken place, then outputs the response in plain text format.

if ($this->_request->isXmlHttpRequest()) {
	$content = array(
		'author' => 'Steve',
		'categories' => array(
			'PHP', 'Zend', 'JavaScript'
		)
	);
	$jsonData = Zend_Json::encode($content);
	$this->getResponse()
	->setHeader('Content-Type', 'text/html')
	->setBody($jsonData)
	->sendResponse();
	exit;
}

This will output only the encoded array (similar to that below) without including the page template.

{"author":"Steve","categories":["PHP","Zend","JavaScript"]}

It is essential that you exit the script after outputting the JSON, otherwise your page template will be rendered as well as outputting the encoded array and therefore removing the ability for it to be parsed correctly.

You should be aware that the isXmlHttpRequest method checks for an HTTP request header named X-Requested-With with the value ‘XMLHttpRequest’ and therefore may not work with all JavaScript libraries.

It does however work as expected with Prototype, Scriptaculous, Yahoo! UI Library, jQuery and MochiKit.

There are many alternative methods that could be used instead of this one, it’s just that I found this one to be the quickest and most simplistic method.

Instead of having to re-create the whole query, you can append a comma separated list of category ID’s  that you want to exclude to the end of the original query and fetch the new data set to be used.

To achieve this, insert a variation of the following into your index or template file specified as the posts page:

<?php if (is_home()) query_posts($query_string.'&cat=-2,-3'); ?>

This should be placed before the loop, therefore ideally just before:

<?php if (have_posts()) : ?>

Adding this line of code will check if the current page is the posts page (is_home) and if so exclude the categories with ID’s 2 and 3. Note here the negation used (-2 and -3), without this the query will include rather than exclude the categories.

If you don’t want to hard code ID values, you could use the get_category_by_slug or get_category_by_path functions to fetch the category ID.

We all know that WordPress is a powerful and pretty impressive blogging platform, and contains many useful features. The problem is finding the features you need / want. Most of the time they are available – somewhere.

In this case, after a numbers of hours research, I’ve done all the hard work for you when it comes to adding custom rewrite rules. We shall assume we have a page called “directory‘” with the page ID “123” and the parent page of name “business“.

This page (ID: 123) looks for the parameter “business” and if is defined, displays the details for the corresponding company. We also want to add the location of the business in the url, but for simplicity we will not pass them through in this example.

The end goal is to have a list of businesses displayed on “/business/directory/” with links to the business details in the format “/business/directory/york-yo31/mybusinessltd/“.

To achieve this, we will need to make use of three hooks. The first is the “init” hook, which we will use to regenerate the rewrite rules and save them to the database using flush_rules().

function directory_flush_rewrite()
{
  global $wp_rewrite;
  $wp_rewrite->flush_rules();
}
add_action('init', 'directory_flush_rewrite');

The second hook is “query_vars“. This is required to add the string “business” to the list of query variables WordPress understands in order for it to be retrieved on our directory page.

function directory_vars($public_query_vars)
{
    $public_query_vars[] = 'business';
    return $public_query_vars;
}
add_filter('query_vars', 'directory_vars');

The last hook is called “generate_rewrite_rules” and allows us to add the custom rewrite rule/s the list of WordPress rewrite rules. Putting the three code snippets together will result in the following block of code, which should be added to your “functions.php” file.

function directory_flush_rewrite()
{
  global $wp_rewrite;
  $wp_rewrite->flush_rules();
}
add_action('init', 'directory_flush_rewrite');
function directory_vars($public_query_vars)
{
    $public_query_vars[] = 'business';
    return $public_query_vars;
}
add_filter('query_vars', 'directory_vars');
function directory_rewrite_rules($wp_rewrite)
{
	$wp_rewrite->rules = array(
		'business/directory/(?:\w+)-(?:\w+)/(.*)/?' => 'index.php?page_id=123&business='.$wp_rewrite->preg_index(1)
	) + $wp_rewrite->rules;
}
add_action('generate_rewrite_rules', 'directory_rewrite_rules');

The final piece of information you need is how to access the variable passed through form the rewrite rule (“business=mybusinessltd”). This can be done using using the following:

$wp_query->get('business'); // returns 'mybusinessltd' in this example.

The example Reg Exp used could be modified and improved nad the page name could be matched and used instead of using the page id, but should put you on the right track. As mentioned earlier, you could also pass through the the other parameters (town & postcode) and use them alongside business in your lookup query.

The problem with using this plug-in is that the WordPress WYSIWYG Editor (TinyMCE), will remove any tags and attributes that it believes to be invalid according to it’s configuration. As two of the attributes used by this plug-in are custom attributes (escaped/line) they are removed, causing some unexpected output.

One solution to this problem is to add the custom attributes to the list of valid elements by using the ‘tiny_mce_before_init‘ filter and appending them to the ‘extended_valid_elements’ string.

The function below can be added to the functions.php file within your theme directory:

function tinymce_wp_syntax($init) {
	$values = 'pre[lang|escaped=true|line]';
	if (empty($init['extended_valid_elements'])) {
		$init['extended_valid_elements'] = $values;
	} else {
		$init['extended_valid_elements'] .= ','.$values;
	}
	return $init;
}
add_filter('tiny_mce_before_init', 'tinymce_wp_syntax');

Adding this to my blog enables me to continue using the visual editor instead of disabling it and at the same time will allow the other HTML filters to continue as normal .

Note: You may have to force refresh (ctrl + f5) the post / page editing page for the changes to take effect.

EDIT: This solution does not fully solve the problem in WordPress MU installations, as you need to adjust the allowed post tags used by the content filter.

if (!CUSTOM_TAGS) {
	$allowedposttags['pre'] =  array(
		'lang' => array(),
		'escaped' => array('true' => array()),
		'line' => array()
	);
}

As WAMP itself does not have an SMTP server, the easiest option is to replace the SMTP address with the name of the SMTP server or IP Address with one that you can use.

This can be achieved by either editing the php.ini directly, replacing:

;SMTP = localhost
;smtp_port = 25
;sendmail_from =

with:

SMTP = smtp.yourisp.com
smtp_port = 25
sendmail_from = me@example.com

Or by setting the values in PHP:

ini_set("SMTP","smtp.yourisp.com" );
ini_set('smtp_port', 25);
ini_set('sendmail_from', 'me@example.com');

Replace smtp.yourisp.com with that of your ISP’s SMTP server, for example smtp.ntlworld.com.

Depending on your current settings, it’s likely that you may only need to modify the SMTP value as the others – smtp_port and sendmail_from – may already be defined.

Now restart the Apache server in order for your changes take effect, then test the changes by calling the PHP mail function.

Although it wasn’t immediately obvious to me, read more links can be enabled by over-riding the global $more variable and setting it to false, before looping through the result set, for example:

global $more; $more = FALSE;
query_posts('post_type=page');
if ( have_posts() ) : while ( have_posts() ) : the_post();
	the_content('Read More...');
endwhile; endif;

I couldn’t actually discover why this is not the default behaviour when querying pages. There may be a good reason behind it, but in my experience I found it mildly irritating.

Instead I decided to write a very simple function to add a class name to the first paragraph by filtering the content, then setting the styles accordingly in my theme CSS file.

function first_paragraph($content){
	return preg_replace('/<p([^>]+)?>/', '<p$1 class="first">', $content, 1);
}
add_filter('the_content', 'first_paragraph');

By default this will append class=”first” to the first p tag in your post.

If you want to use this function on your own blog, just add it to your (or create a)  functions.php file within your themes folder.

The main page should act as overview of everything that is going on, therefore I wanted to avoid overcrowding it with lots of large graphs and instead simply show the basic trends.

A few months back I came across an implementation of Sparklines – data-intense, design-simple, word-sized graphics – which are often used to demonstrate stock market activity in a simple visual graphic.

I was just going to use a pre-made script from the many already available, but instead decided to knock one up myself and created a small PHP Class to generate and output a sparkline image using the GD Library.

To create a sparkline I can now simply include the class and then initiate it in a variation of the following:

$sparkline = new Sparkline();
$sparkline->data = Array(3,38,2,8, ... ,38,13,4,23);
$sparkline->output(); // Display image

This PNG image is generated and output to the browser:

A number of other setup options are available to customise the output further:

$sparkline->bg = '#000000'; // Background colour
$sparkline->width = 150;
$sparkline->height = 50;
$sparkline->line = '#336699'; // Line colour
$sparkline->points = '#333333'; // Start & end points
$sparkline->thickness = 2; // Line thickness
$sparkline->scale = 5; // Anti-aliasing scale size
$sparkline->output('saved/test.png', true); // Save to location and display

All colours must be provided in hexadecimal format and if you are attempting to save the image the destination location must be writeable by Apache.

The Sparkline PHP Class source code is available for anyone to use as they may like, although I must confess it hasn’t been fully tested as yet!