Register the Custom Post

The first thing you see here is the register_post_type function which starts everything. You can read about this on the codex page or Justin Tadlock’s post. These two pages should get you up to speed fast.

Actions and Filters

The next bit of code are all the callbacks. The first two deal with adding the meta box and saving it. The next two change the columns in the WordPress admin when viewing a list of the custom posts. The last is for using custom template names.

The Meta Box

The first two functions link_url_meta_box() and save_post_data() deal with the added meta box. I’ve kept things simple here so it should be easy to follow what’s happening.

Custom Columns

When looking through the list of your custom post you’ll probably want to display custom columns so it’s easier to find what you want. The nav_columns and custom_nav_columns control this: nav_columns sets everything up, and custom_nav_columns determines what will be listed there.

Custom Template Names

WordPress by default will use “single-link.php” for our template name since we named the custom post type “link“. But if you wanted to use a different template name for instance “foorbarlink.php” you can change it using this part of the code. If you’re happy with WordPress’ default naming you can exclude this completely.

Below is the function for a link type post, one that you might use in a tumble log. It’s a basic example of how to use the Custom Post Type feature in WordPress 3.0+

If you want to use a flash or javascript chart, scroll to the bottom for a different function.

The Chart

After looking for a lightweight flash or javascript charting solution, I decided for an archives page just plain CSS charts would be the way to go at first. So the output we are going for is something like this:

<dl class="barGraph 2008">
	<dt style="" class="label"><a href="">Jun</a></dt>
	<dd title="Jun" style="height: 200px;" class="bar Jun">6</dd>

	<dt style="left: 55px;" class="label"><a href="">Jul</a></dt>
	<dd title="Jul" style="height: 66.6667px; left: 55px;" class="bar Jul">2</dd>

	<dt style="left: 110px;" class="label"><a href="">Aug</a></dt>
	<dd title="Aug" style="height: 100px; left: 110px;" class="bar Aug">3</dd>

	<dt style="left: 165px;" class="label"><a href="">Sep</a></dt>
	<dd title="Sep" style="height: 133.333px; left: 165px;" class="bar Sep">4</dd>

	<dt style="left: 220px;" class="label"><a href="">Oct</a></dt>
	<dd title="Oct" style="height: 166.667px; left: 220px;" class="bar Oct">5</dd>

	<dt style="left: 275px;" class="label"><a href="">Nov</a></dt>
	<dd title="Nov" style="height: 100px; left: 275px;" class="bar Nov">3</dd>

	<dt style="left: 330px;" class="label"><a href="">Dec</a></dt>
	<dd title="Dec" style="height: 66.6667px; left: 330px;" class="bar Dec">2</dd>
</dl>

The Code

The code in the function is essentially a Frankenstein of the wp_get_archives function from the WordPress core, and this tutorial on creating vertical bar graphs. It pulls the year, month and number of posts out of the database, then formats them into a list suitable for styling into a CSS chart.

<?php
function ch_archive_graph($args = ''){
	global $wpdb, $wp_locale;

	//template tag defaults
	$defaults = array(
		'graphYear' => '2007',
		'limit' => '13',
		'graphHeight' => '200',
		'xIncrement' => '55'
	);

	$maxHeight = 1;
	$scale = 1;

	$r = wp_parse_args( $args, $defaults );
	extract( $r, EXTR_SKIP );

	if ( '' != $limit ) {
		$limit = absint($limit + 1);
		$limit = ' LIMIT '.$limit;
	}

	$where = apply_filters('getarchives_where', "WHERE post_type = 'post' AND post_status = 'publish'", $r );

	$query = "SELECT YEAR(post_date) AS `year`, MONTH(post_date) AS `month`, count(ID) as posts FROM $wpdb->posts $where GROUP BY YEAR(post_date), MONTH(post_date) ORDER BY post_date DESC $limit";
	$key = md5($query);
	$cache = wp_cache_get( 'ch_archive_graph' , 'general');

	$output = '<dl class="barGraph '.$graphYear.'">';

	if ( !isset( $cache[ $key ] ) ) {
		$arcresults = $wpdb->get_results($query);
		$cache[ $key ] = $arcresults;
		wp_cache_add( 'ch_archive_graph', $cache, 'general' );
	} else {
		$arcresults = $cache[ $key ];
	}
	if ( $arcresults ) {

		//Loop through to find the highest number of posts
		foreach ( (array) $arcresults as $arcresult ) {
			//number of posts in a month
			$total = $arcresult->posts;
			if($maxHeight < $total) $maxHeight = $total;
		}

		//Reverse the months
		$arcresults = array_reverse($arcresults);
		foreach ( (array) $arcresults as $arcresult ) {
			//Limit to one year
			if($arcresult->year == $graphYear){
				//Get month name, then appreviate, delete the second line if you want full month names
				$month = sprintf(__('%1$s'), $wp_locale->get_month($arcresult->month));
				$month = sprintf(__('%1$s'), $wp_locale->get_month_abbrev($month));
				//Get archive link
				$url = get_month_link( $arcresult->year, $arcresult->month );
				//Number of posts in the month
				$num_posts = $arcresult->posts;

				//Determine the scale and the height of the bar
				$scale = $graphHeight / $maxHeight;
				$height = ($arcresult->posts * $scale);

				//Put it all together
				$output .= "<dt class='label' style='left: ".$xOffset."px;'><a href=".$url.">".$month."</a></dt>";
				$output .= "<dd class='bar ".$month."' style='height: ".$height."px; left: ".$xOffset."px;' title=".$month.">".$num_posts."</dd>";

				//Increase the offset for the next bar
				$xOffset = $xOffset + $xIncrement;
			}
		}
	}	

	$output .= "</dl>";
	echo $output;

}

Styling the Chart with CSS

Styling the chart is made easier by the definition list.

.barGraph {
	height: 200px;
	margin: 0;
	padding: 0;
	position: relative;
	}

.barGraph dt {
	bottom: 0;
	list-style:none;
	margin: 0;
	padding: 0;
	position: absolute;
	text-align: center;
	width: 54px;
	}

.barGraph dd {
	border: 1px solid #005559;
	bottom: 0;
	list-style:none;
	margin: 0 0 1.5em 0;
	padding: 0;
	position: absolute;
	text-align: center;
	width: 50px;
	background-color: #00868B;
	border-right: 5px solid #005559;
	color: #fff;
	font-weight: bold;
	}

	.barGraph dd:hover {
		border: 1px solid #FA8000;
		background-color: #F5BA52;
		border-right: 5px solid #FA8000;
		color: #000;
		}

How to use the Graph

The function works just like any other template tag. Add the above function to your functions.php file and the CSS to style.css. Then call the chart in your template like so: <?php ch_archive_graph(); ?>

The template tag also includes a few options to make customizing it easier:

• ‘graphYear‘ this is the year of the archive you want to display
• ‘xIncrement‘ this is the width of the bars in the chart
• ‘graphHeight‘ this is the height in pixels of the chart
• ‘limit‘ this is number of posts you want to display

Example:
<?php ch_archive_graph('graphYear=2007&xIncrement=40&graphHeight=400&limit=6'); ?>

Bonus: For Javascript Charts

If you need the output for a javascript based chart, you only need to alter things a bit to get a javascript array or months and number of posts, then plug them into whatever charting you want to use.

function ch_count_months_js_output($args = ''){
	global $wpdb, $wp_locale;

	$defaults = array(
		'limit' => '',
		'before' => ''
	);

	$r = wp_parse_args( $args, $defaults );
	extract( $r, EXTR_SKIP );


	$where = apply_filters('getarchives_where', "WHERE post_type = 'post' AND post_status = 'publish'", $r );
	$join = apply_filters('getarchives_join', "", $r);

	$query = "SELECT YEAR(post_date) AS `year`, MONTH(post_date) AS `month`, count(ID) as posts FROM $wpdb->posts $join $where GROUP BY YEAR(post_date), MONTH(post_date) ORDER BY post_date DESC $limit";
	$key = md5($query);
	$cache = wp_cache_get( 'ch_count_months_js_output' , 'general');

	if ( !isset( $cache[ $key ] ) ) {
		$arcresults = $wpdb->get_results($query);
		$cache[ $key ] = $arcresults;
		wp_cache_add( 'ch_count_months_js_output', $cache, 'general' );
	} else {
		$arcresults = $cache[ $key ];
	}
	if ( $arcresults ) {
		$arcresults = array_reverse($arcresults);
		$posts = array();
		$months = array();
		foreach ( (array) $arcresults as $arcresult ) {
			$month = sprintf(__('%1$s'), $wp_locale->get_month($arcresult->month));
			array_push($months, $month);
			array_push($posts, $arcresult->posts);
		}
	}	
	print_r($months);
	print_r($posts); 

	echo '<p type="text/javascript">'; 
	echo 'var months = ["', join($months,'","'), '"];'; 
	echo 'var posts = [', join($posts,','), ']';
	echo '</p>';
}

Let me know if you use it or improve it!

This uses the delay, and easing plugins for jquery. The below example includes the animation just as an example.

$('#link').click(function(){
        // Get the url of the link
		var toLoad = $(this).attr('href');

			// Do some stuff
			$(this).animate({
				marginRight: '50px',
				marginLeft: '-175px'
			}, 300, 'easeOutSine').animate({
				marginRight: '-38px',
				marginLeft: '-120px'
			}, 500, 'easeOutBounce');
			// Stop doing stuff

        // Wait 700ms before loading the url
		$(this).delay(700, function(){
			window.location = toLoad;
		});

        // Don't let the link do its natural thing
		return false;
});

What it actually does

The purpose of this article is to give you a function you can pop into a theme just like a regular template tag (wp_list_pages) but with some changed functionality. What you’ll get is a top level menu, nothing fancy, basic use of wp_list_pages really, but this top level is always there. You also get child menus, as many as you need. The child menus only display if the page actually has children, and it only displays one level of children instead of all of them.

The beginning of a beast

I’m not gonna lie, this is gonna get thick and fast, in fact the code barely makes sense to me and I wrote it. Here’s the short: we display a top level menu(easy), we check if a page is a child(easy), we check if the page has children itself(weird hack), we count the page’s parents and display the menu accordingly(huh?).

The top level

We’ll start with the top level menu, this is just a call to the wp_list_pages function, nothing fancy here. Output is generated with an unordered list with a few class names for styling.

//Multi-level pages menu
function wptt_multilevel_menu() {
	global $post;
	// Top level menu is always displayed
	$top_level = wp_list_pages('title_li=&depth=1&sort_column=menu_order&echo=0');

	// Put it all together
	$menu = '<ul class="menu top_level">';
	$menu .= $top_level;
	$menu .= '</ul>';

	print $menu;
}

Displaying the children

The meat of this example is this next part, displaying the children is in thought a very simple process, in practice it takes a bit of pounding a square peg into a round hole. We are still using the wp_list_pages function, and most of this code has one purpose, to determine the right depth to pass to wp_list_pages.

Initially we’ll check if a page has any parent pages using $post->ancestors and count the ancestors. I count the ancestors to determine the depth used later. Then check if a page has any more children. We’ll then separate those pages with children and those without.

<?php
// Check if a page has any parent pages
	if ($post->ancestors) {

		// How many ancestors does this page have? Then subtract by 1 to adjust for top level
		$n = count($post->ancestors);
		$n = $n - 1;

		// Get the page's children, if it has any
		$pages = get_pages();
		$page_children = get_page_children($post->ID, $pages);

		// Checks if a page has children
		if (!empty($page_children)) {
			$children = wp_list_pages("title_li=&child_of=". $post->ancestors[$n] ."&echo=0&sort_column=menu_order&depth=" . ($n + 2));
		} else { // If the page doesn't have children
			$children = wp_list_pages("title_li=&child_of=". $post->ancestors[$n] ."&echo=0&sort_column=menu_order&depth=" . ($n + 1));
		}

	} else {
		$children = wp_list_pages("title_li=&child_of=". $post->ID ."&echo=0&sort_column=menu_order&depth=1");
	}
?>

All of the counting done above($n, depth, ancestors, blah blah) is all done in order to display only the first child level. This way you are not showing all the children of the top level page.

The whole function

In the final function I’ve added some output for the children and combined everything above.

Updated 4/20/09 – the function has changed slightly since the explanation above.

//Multi-level pages menu
function wptt_multilevel_menu() {
	global $post;
	// Top level menu is always displayed
	$top_level = wp_list_pages('title_li=&depth=1&sort_column=menu_order&echo=0');

	// Get post ancestors 
	$post_ancestors = get_post_ancestors($post);

	// Check if a page has any parent pages
	if ($post_ancestors) {

		//get the top page id
		$top_page = $post_ancestors ? end($post_ancestors) : $post->ID;

		// How many ancestors does this page have? Counts the array adds one.
		$n = count($post_ancestors) + 1;

		// Get the pages children, if it has any
		$pages = get_pages();
		$page_children = get_page_children($post->ID, $pages);

		// Checks if a page has children
		if (!empty($page_children)) {
			$children = wp_list_pages("title_li=&child_of=". $top_page ."&echo=0&sort_column=menu_order&depth=" . $n);
		} else { // If the page doesn't have children
			$children = wp_list_pages("title_li=&child_of=". $top_page ."&echo=0&sort_column=menu_order&depth=" . ($n - 1));
		}

	} else {
		$children = wp_list_pages("title_li=&child_of=". $post->ID ."&echo=0&sort_column=menu_order&depth=1");
	}

	// Put it all together
	$menu = '<ul class="menu top_level">';
	$menu .= $top_level;
	$menu .= '</ul>';
	// Only show child navigation if there are children
	if ( $children ) {
		$menu .= '<ul class="menu subpages">';
		$menu .= $children;
		$menu .= '</ul>';
	}
	print $menu;
}

The future and spaceships

That is one way to do multiple level menus in wordpress, right now this function is only using pages, but I will be expanding it to use categories as well. There are actually quite a few ways I want to expand this in order to make it truly useful. This function is part of the larger WordPress Theme Tools project that I’m starting. If you have any suggestions for this, find a bug, or know a better way, let me know!

Note: I’ve updated the code on 4/20/09 but the function still works the same. As it is right now the sub pages are displayed in the default nested way that WordPress naturally does it. The benefit of the function is that it only shows one level under the parent page instead of hard coding the depth or showing all the children.

While coding the new theme for curtishenson.com I had a problem, pagination blocks would show even when there were no pages to link to(not technically wordpress’ fault), turns out it is a pretty easy fix. For post pagination blocks wrap the navigation in this:

<?php global $wp_query;
	$total_pages = $wp_query->max_num_pages;
		if ( $total_pages > 1 ) {
			//Your navigation goes here
		}
?>

This grabs the total amount pages, checks if it is greater than one, then shows the navigation if there is more than one page. For comment pagination in WordPress 2.7+ do it like this:

$total_pages = get_comment_pages_count();
	if ( $total_pages > 1 ) {
		//Your navigation goes here
	}
?>

The subtle difference is the use of the get_comment_pages_count function. Otherwise you’re just checking to see if there is more than one page.

A Helper Function

The first time I saw a helper it was in a ruby on rails program. Seemed like a good idea, don’t know why I hadn’t used this most basic implementation of DRY (Don’t Repeat Yourself) theory in WordPress themes. So while I was copy and pasting this code I decided it would be much easier to lump it into one function. The benefits: lighter template files, change the function once and the whole site changes.

This HTML bits will probably need to be changed to your liking, but this little diddy should help anyone with their themes. Just copy and paste the function in your functions.php file, then call it in your theme in place of the navigation like so: <?php ch_navigation_helper(); ?>

I have some ideas to extend this into a truly helpful …helper. I’ll be including it in my new WP Theme Tools Project for sure. If you extend it let me know!

Note: This function only works with WordPress 2.7.1

<?php
// Navigation Helper Function 
//http://curtishenson.com/wordpress-navigation-helper-function-comments-and-posts  
function ch_navigation_helper(){
	global $wp_query;
	// For templates like index, search, archive, etc.
	if ( !is_singular() ) {
		$total_pages = $wp_query->max_num_pages;
			if ( $total_pages > 1 ) { 
			$s = '';
			$s .= '<div class="navigation clearfix">';
			$s .= '<span class="alignleft">' . get_next_posts_link('Previous Entries') . '</span>';
			$s .= '<span class="alignright">' . get_previous_posts_link('Newer Entries') . '</span>';
			$s .= '</div>';
			echo $s;
		}
	}

	// For paginated comments in WP 2.7+
	if ( is_singular() && get_option('page_comments') ) {
		$total_pages = get_comment_pages_count();
		if ( $total_pages > 1 ) { 
			$s = '';
			$s .= '<div class="navigation clearfix">';
			$s .= '<div class="alignleft">';
			$s .= get_previous_comments_link('Older Comments');
			$s .= '</div>';
			$s .= '<div class="alignright">';
			$s .= get_next_comments_link('Newer Comments');
			$s .= '</div></div>';
			echo $s;
		} 
	}
}

?>

The Basic Idea

When I develop themes I spend a lot of time doing the same things, or copy and pasting code from my other themes and tweaking. Things like theme options, basic functions, filters, widgets. I also have had some trouble keeping things like widgets up to date(thank God WordPress is so forgiving).

I want to build a library that can be dropped into any theme, and be easily customized to suit the needs of that theme. This is the basic idea behind the tools project.

Theme Options

I think theme options are an integral part of modern WordPress themes. Themes are more complex than ever and I can’t imagine developing a theme without options. Theme options can be a pain, but they don’t have to be. The tools project’s first feature (and already almost done) is a library which makes creating theme options as easy as creating a few arrays. Drop in the files, customize a file and you are good to go. No more searching through long files of code.

Basic Functions and Filters

Custom functions can greatly help a theme designer, whether it is doing complex things or just helping clean up the source code. I have a few functions and filters planned already, but this could definitely use some input as I’m sure other people could add to this part.

Widgets

Custom widgets are nice…especially when they work right. Custom widgets are also a huge selling point (or give away point??) for themes. And custom widgets are also usually a huge pain in my ass. It is a lot of code, and a lot of my code is now outdated due to WordPress 2.7. I’m not sure how easily customizable the widgets will be though, any ideas on how that could work are welcome.

Widget Areas

So far this is just a bunch of arrays premade for the theme. Not sure if there is anything else that can make this basic feature better.

Your Input

That is what I currently have in mind for the project, however I’d like to extend that further. l’ll need the input of people who build themes. What do you want? How do you think it should work? Any ideas for more features?

I’m going to upload this on github once I have a good, functioning base so people will be able to branch it and commit changes and updates.

If you look at most new well thought out themes, trackbacks are separated into another tab, or somehow minimized/hidden from the user that doesn’t want them. WordPress 2.7 changed the commenting code quite a bit, and now separating everything is even easier. Add a little jQuery magic and you can hide and show those trackbacks on demand. Enough with this banter, lets rock out with our text-editor out.

First a little catchup

So things are a wee bit different in the ol’ comment file in WordPress 2.7. I highly suggest taking a peek at Otto’s WordPress 2.7 Comments Enhancements if you haven’t already. He outlines how the new comment loop works, and all the spiffy javascript for threaded comments.

Once you got a grasp on the comment changes in 2.7, checkout Matt’s article on separating pings from comments. I’m not going to go into too much detail so if you find yourself not understanding a part of the code, try checking out those articles.

Separation makes the heart grow fonder of pings

I think that is the saying. Lets start with the comment loop, first the whole thing,

if ( have_comments() ) : ?>
	<h3 class="comment_title"><?php comments_number('No Comments', 'One Comment', '% Comments' );?></h3>
		<ol class="commentlist" id="singlecomments">
			<?php wp_list_comments(array('avatar_size'=>48, 'reply_text'=>'Reply', 'type'=>'comment')); ?>
		</ol>

	<h3 class="trackback_title">Trackbacks / Pingbacks</h3>
	<a href="#pings" class="show_trackbacks">show trackbacks</a>
		<ol id="pings" class="trackback">
			<?php wp_list_comments('type=pings'); ?>
		</ol>

	<div class="comments-navigation">
		<div class="alignleft"><?php previous_comments_link() ?></div>
		<div class="alignright"><?php next_comments_link() ?></div>
	</div>
 <?php else : // this is displayed if there are no comments so far ?>

	<?php if ('open' == $post->comment_status) :
		// If comments are open, but there are no comments.
	else : 
		// comments are closed 
	endif;
endif;

There is the comment loop with the trackbacks already separated. The only trick to the separation is setting the ‘type‘ option for the wp_list_comments function. Set the ‘type’ to ‘comment’, for comments, and pings for …well pings(trackbacks). Simple enough right? Let’s take a closer look at the HTML.

<h3 class="comment_title"><?php comments_number('No Comments', 'One Comment', '% Comments' );?></h3>
		<ol class="commentlist" id="singlecomments">
			<?php wp_list_comments(array('avatar_size'=>48, 'reply_text'=>'Reply', 'type'=>'comment')); ?>
		</ol>

	<h3 class="trackback_title">Trackbacks / Pingbacks</h3>
	<a href="#pings" class="show_trackbacks">show trackbacks</a>
		<ol id="pings" class="trackback">
			<?php wp_list_comments('type=pings'); ?>
		</ol>

This is really the meat of the code, you can see the two blocks of code, one for comments and one for pings. The only real differences are setting the ‘type’ for wp_list_comments and changing the id and class names for styling. There is also one addition for the pings, a link to show them(it has a class of ‘show_trackbacks’). You can either put this link in the actual code, or inject it using javascript.

The jQuery

There’s a few ways to do this but I’m going to go with a simple slide up and slide down. First we’ll hide the trackbacks by calling slideUp() then add a function to detect the click on our show_trackbacks link which will call slideDown().

$('ol.trackback').slideUp();
$('.show_trackbacks').click(function(){
	$('ol.trackback').slideDown();
});

That’s it?? Yeah, pretty simple actually, so I’ll leave you with something else useful. A full comment file ready for wordpress 2.7.

The whole thing

<?php // Do not delete these lines
if (!empty($_SERVER['SCRIPT_FILENAME']) && 'comments.php' == basename($_SERVER['SCRIPT_FILENAME']))
	die ('Please do not load this page directly. Thanks!');
if ( post_password_required() ) { ?>
	<p class="nocomments">This post is password protected. Enter the password to view comments.</p>
<?php
	return;
}

// add a microid to all the comments
function comment_add_microid($classes) {
	$c_email=get_comment_author_email();
	$c_url=get_comment_author_url();
	if (!empty($c_email) && !empty($c_url)) {
		$microid = 'microid-mailto+http:sha1:' . sha1(sha1('mailto:'.$c_email).sha1($c_url));
		$classes[] = $microid;
	}
	return $classes;	
}
add_filter('comment_class','comment_add_microid');

//Change date format
function change_comment_date($datestring, $dateformat) {
global $comment;
return mysql2date('F j y', $comment->comment_date);
}
add_filter('get_comment_date','change_comment_date',10,2);

// show the comments
if ( have_comments() ) : ?>
	<h3 class="comment_title"><?php comments_number('No Comments', 'One Comment', '% Comments' );?></h3>
		<ol class="commentlist" id="singlecomments">
			<?php wp_list_comments(array('avatar_size'=>48, 'reply_text'=>'Reply', 'type'=>'comment')); ?>
		</ol>

	<h3 class="trackback_title">Trackbacks / Pingbacks</h3>
	<a href="#pings" class="show_trackbacks">show trackbacks</a>
		<ol id="pings" class="trackback">
			<?php wp_list_comments('type=pings'); ?>
		</ol>

	<div class="comments-navigation">
		<div class="alignleft"><?php previous_comments_link() ?></div>
		<div class="alignright"><?php next_comments_link() ?></div>
	</div>
 <?php else : // this is displayed if there are no comments so far ?>

	<?php if ('open' == $post->comment_status) :
		// If comments are open, but there are no comments.
	else : 
		// comments are closed 
	endif;
endif; 

if ('open' == $post-> comment_status) : 

// show the form
?>
<div id="respond"><h3><?php comment_form_title( 'Leave a Reply', 'Leave a Reply to %s' ); ?></h3>

<div id="cancel-comment-reply">
	<small><?php cancel_comment_reply_link(); ?></small>
</div>

<?php if ( get_option('comment_registration') && !$user_ID ) : ?>

<p>You must be <a href="<?php echo get_option('siteurl'); ?>/wp-login.php?redirect_to=<?php echo urlencode(get_permalink()); ?>">logged in</a> to post a comment.</p>

<?php else : ?>

<form action="<?php echo get_option('siteurl'); ?>/wp-comments-post.php" method="post" id="commentform" class="span-17">

	<div>
	<?php comment_id_fields(); ?>
	<input type="hidden" name="redirect_to" value="<?php echo htmlspecialchars($_SERVER["REQUEST_URI"]); ?>" /></div>

	<p><small><strong>XHTML:</strong> You can use these tags: <?php echo allowed_tags(); ?></small></p>

	<p><textarea name="comment" id="comment" cols="10" rows="10" tabindex="4"></textarea></p>

	<?php if (get_option("comment_moderation") == "1") { ?>
	 <p><small><strong>Please note:</strong> Comment moderation is enabled and may delay your comment. There is no need to resubmit your comment.</small></p>
	<?php } ?>


<?php if ( $user_ID ) : ?>

<p class="loggedin">Logged in as <a href="<?php echo get_option('siteurl'); ?>/wp-admin/profile.php"><?php echo $user_identity; ?></a>.
<a href="<?php echo wp_logout_url(get_permalink()); ?>" title="Log out of this account">Logout &raquo;</a></p>

<?php else : ?>

<p><label for="author"><small>Name <?php if ($req) echo "(required)"; ?></small></label>
<input type="text" name="author" id="author" value="<?php echo $comment_author; ?>" size="22" tabindex="1" /></p>
<p><label for="email"><small>Email <?php if ($req) echo "(required)"; ?></small></label>
<input type="text" name="email" id="email" value="<?php echo $comment_author_email; ?>" size="22" tabindex="2" /></p>
<p><label for="url"><small>Website</small></label>
<input type="text" name="url" id="url" value="<?php echo $comment_author_url; ?>" size="22" tabindex="3" /></p>

<?php endif; ?>

<p><input name="submit" type="submit" id="submit" tabindex="5" value="Submit Comment" /></p>
<?php do_action('comment_form', $post->ID); ?>
</div>

</form>

<?php 
endif;

endif;

Whoa there’s the problem, the next_posts_link() and previous_posts_link() functions don’t output anything when there are no more pages to link to. A little PHP to the rescue.

The Code

The code is pretty easy, just an if else statement. We are going to use the get_next_posts_link() and get_previous_posts_link() to test if there is a link or not.

<?php
// Check for a link to older posts
		if ( get_next_posts_link() ) {
// If there is a link to older pages output this code
			echo '';
				next_posts_link('Previous', '0');
			echo '';
		} else {
 // If there isn't a link output our own code
			echo 'no older posts';
		};

// Check for a link to newer posts
		if ( get_previous_posts_link() ) {
 // If there is a link to older pages output this code
			echo '';
				previous_posts_link('Newer', '0');
			echo '';
		} else {
 // If there isn't a link output our own code
			echo 'no newer posts';
	};
?>

To break it down a bit, there is an if else block for each link. The if statement checks get_next_posts_link() or get_previous_posts_link(), if it returns a link we call next_posts_link() or previous_posts_link() if it doesn’t we echo our own code.

Something to keep in mind is that normally “next” refers to older posts and “previous” refers to newer posts, which can be confusing while looking at the code.

Easy Post Classes

Something I really didn’t expect was the post_class() function. This makes the almost obligatory class=”post” a thing of the past, and replaces it with something infinitely more useful. Straight from the codex:

This includes several different classes of value: post, hentry (for hAtom microformat pages), category-X (where X is the slug of every category the post is in), and tag-X (similar, but with tags). It also adds “sticky” for posts marked as sticky posts.

This is great for keyword stuff…err…I mean SEO. Also it will make styling posts simple and straightforward. This is some functionality that isn’t new to some themes, but now that its part of the core, it is oh so much easier and cleaner.

How to use it

This one is simple enough, stick it inside the loop where you would normally have a class=”post” like so:

<div <?php post_class(); ?>>

Say you want to add a special class, so your posts with a certain custom field are displayed differently than a post without the custom field. Easy enough, you can pass along a single class name, space separated list, or an array of classes:

<div <?php post_class('special_class'); ?>>
<div <?php post_class('special_class class2 class3 class4'); ?>>
<div <?php post_class($my_array); ?>>

Great! But I want to use it outside of the loop, to display something in my sidebar on single post pages cause I’m cool like that. WordPress has got you covered there too, you can pass a post ID as a second parameter:

<div <?php post_class('', $post_id); ?>>

I got a feeling this is going to open up some very cool things when people start to play with it.

A Logout Link

OK so I think this one is relatively boring compared to the rest, but I know this will actually be useful in certain applications. It is the almighty wp_logout_url() function. It does just what you think it does, provides a protected log out link for your users. Use is simple just put <?php wp_logout_url(); ?> where you want it.

Page Menus

Another new function is actually a wrapper for wp_list_pages(). The wp_page_menu() can be used pretty much the same as wp_list_pages(), but one useful little add is the ability to a link to the homepage:

<?php wp_page_menu('show_home=1'); ?>

HTTP API

There’s also a new http api for plugins that looks like it could be useful. From the codex:

The HTTP API is an attempt to standardize the HTTP requests and responses for WordPress. It will eventually obsolete Snoopy and deprecate the other functions in WordPress. That is, once the HTTP API is completely stable.

I haven’t got a chance to really look into any of these, but you should be aware of them as they could be a huge part of whatever plug-in you are writing.

Comment Enhancements

I’ve saved the best for last. WordPress 2.7 has brought some much wanted comment love, threaded, paged, etc. Themes do have support all this although, which will make some of very busy. Instead of repeating all the info about the comment updates, just head over to the WordPress 2.7 Comments Enhancements post from Otto.

More…

That is all I got right now, but there are more new features you may be of interest to you in WordPress 2.7. For a complete look at the features list check out the codex page on WordPress 2.7.

What’s New?

The WordPress dev team heard the cries of the masses and has added new conditional tags to the core. A few include:

<?
is_front_page()
is_single(array(17,'beef-stew','Irish Stew'))
is_page(array(42,'about-me','About Me And Joe'))
is_page_template() ?>

Head on over to the codex conditionals page for a full list. The most important new tags are the ones which allow you to use arrays. In the past you may have had to use complex code to achieve the same result. The ability to filter content by several pages/categories/tags is incredibly useful especially in building large websites. The Codex does a good job at explaining the new tags so I won’t go into that here.

How’s Your PHP?

If you theme WordPress you probably know at least some basic PHP. The most basic and useful PHP you can learn are comparison operators. The operators will return true or false and work the same way as the WordPress conditional tags.

Let’s say you wanted some text to only show on the home page(ID is 42) and your about page. One way to do this is:

<?
if ( is_page( array (42,'About') ) ){
	echo "Hello World";
}

Lets say you didn’t know the ID of the page or the name, maybe it is in a theme and you want the user to set where the text appears. In this example $text_pages is a list set somewhere either by the user or some other function.

<?
$text_pages = get_option('pages');

if ( is_page( array($text_pages) ) ){
	echo "Hello World";
}

More complex examples

OK so far pretty basic stuff. Lets see something more complicated. We have text we want to show on a static home page, some posts in a certain category, but not in the search pages. Using PHP comparison operators and WordPress conditionals this is easy.

<?
if ( (is_front_page() || in_category('3') && !( is_search() ) ) {
	echo "Hello World";
}

Reading this in English goes like so: If is a static home page, or(||) in category 3 and(&&) is not(!) a search page. The exclamation mark is a shortcut for does not equal(!=).

As you can see developing complex conditionals can be very powerful, and can also save you from writing a bunch of repeated code. Lets take it even further and use some variables now.

Lets say you want the user to choose if there is a feature post displayed. You also want them to be able to set the categories used for a feature post. You also want don’t want the feature story repeating itself while paging. To accomplish this we’re going to use a combination of variables, WordPress conditionals, and some if else statements.

<?
$feature = get_option('feature');  // Gets the option to display feature post.
	if( ($feature == 'Yes') && !(is_paged()) ) { //Excludes the feature post when paging through posts
		$feature_cats = get_option('feature_cats'); // Gets list of feature categories
		query_posts(array('category__in' => array($feature_cats)));
		//The loop and post formatting
  	}

Making Your Own Conditionals

If you really want to get dirty, you can form your own conditionals. The Codex hints at this ability with this example:

!empty($post->post_excerpt) 

Pretty simple right? If the post excerpt is empty this will return false. Likewise removing the ! will then return false for anything that has an excerpt.

With a basic understanding of if else statements, and a not so basic understanding of WordPress functions you could create a conditional statement for just about anything granted you had something to compare to get a true or false statement.

Lets come up with another example. Say you want to display a special title whenever a post has approved comments.

<?php $foo = get_approved_comments($post->ID);
			if ( !empty($foo) ) {
				echo "<h1>I Gots Comments!</h1>";
				} ?>

Quick Comparison Operators Overview

The php comparison operators article goes into more detail but I’ll give you quick overview from a WordPress point of view.

When using these operators with WordPress conditional tags and if else statements keep track of your parenthesis! I’ve strung together quite a long string which ended in an equally long string of parenthesis, which will be a headache to decode later.

There are a few operators that are used more often. These are: equal( == ), not equal ( != ), or( || ), and( && ). Using these four you can construct some heavy conditionals.

Grouping is important! Just like math, you can group operators and conditionals to get different true or false statements. ex. (in_category(42) && !(is_search()) || is_archive())

Use !(), !empty(), empty() to achieve some more complex conditionals and create your own conditional statements.

The End

So there are some examples of complex WordPress conditionals, comparison operators, booleans, if elses, and some pie(update: I ate all the pie). This isn’t a complete list of what is possible, infact I don’t think it even scratches the surface. Conditionals are great, and are even more powerful than ever.