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!

There are a few things that have been the realm of premium themes and some rare free themes: post thumbnails, and easy video embedding(that doesn’t suck). Press75 just released two simple yet powerful and incredibly useful plugins: Simple Post Thumbnails and Simple Video Embedder. Go check them out, and let Jason know how awesome they are.

WordPress themes seem prone to this sort of repeating your code. I believe this mostly has to do with WordPress theme developers not being “developers” in a traditional sense, more designers who can code. This habit of repeating code also comes from introductory tutorials and the like which have you creating templates which are mostly the same thing over and over.

Themes are getting more and more advanced, WordPress itself is getting more flexible. As these themes get more complex they need to be simpler. I learned this with my Checkmate theme. It was quickly getting out of hand with the numerous files, lack of organization, and changing code took entirely too long.

K.I.S.S.

I want to rock and roll all night, and party every day too, but I’m busy changing one line of code…in ten different template files. That shouldn’t happen, my new goal is now to create the lightest template files I can, and be heavy on other tools. I also like to cut down on the number of templates I have. The simpler the file structure and code the easier to change or update.

HTML and CSS strive to separate style from content, so you should also try to separate logic from your views. Essentially separate your php from your html as much as possible. This is much more apparent on really complex themes requiring more than your basic template tags.

The Tools

So what tools are there to help in the endeavor to not repeat ourselves? There are quite a few stupidly useful ones.

Template Hierarchy

The first step is understanding what files WordPress looks for at any given time. This can help you strategically use files and save yourself a lot of copying and pasting. The best place to learn about hierarchy is the WordPress Codex Template Hierarchy page.

A quick example of how I use the hierarchy is by using archive.php to display category, tag and author pages. Often these pages are the exact same with minimal changes. Using conditional statements you can serve parts of the page depending on what is requested. Checkmate’s archive file uses this type of system to dynamically display information for tags, categories, or author information.

Conditional Statements

After you know the template hierarchy, you’ll need to understand the use of conditional statements to make the most of your template files. I’ve written twice about conditional statements: Write Less Code, and Complex WordPress Conditional Tags. The WordPress codex page on Conditional Tags will explain everything in great detail.

Conditional tags are just ways to create powerful PHP if else statements very easily. You can use them to dynamically display select parts of a template only in certain specific circumstances.

The Functions File

The functions file is your friend, a powerful friend, a good friend, a wing man of sorts. I use the functions file to call all my other goodies, allowing me to keep a nice clean structured theme folder. Pearsonified has a great article on how to use the functions file. Toxane also has a good article with some examples for WordPress’ function file. The function file can be used

PHP Itself

Some basic PHP can go a long way coupled with some of WordPress’ functions. Learning to read the API and knowing the lingo can go a long way in accomplishing whatever you want.

Helper Functions

In the near future I’ll be releasing my WordPress Tools Project, which is a bunch of functions all ready to be included into themes to help do some mundane things. But you don’t have to wait for me, make up your own, go back into old themes and abstract out some of the advanced things you do. Always using the same HTML code around a template tag? Put it into a function and make your own template tag.

I’ve started posting some of these functions to serve as examples: WordPress Navigation Helper, and Dynamic Multi-Level Page Menus.

Some Tips

Try to keep things organized, for instance put all your javascript in one folder, all your php functions in another, css in another.

Develop a solid framework. I find myself working off Checkmate a lot, I know it very well and know what can be stripped out immediately. Developing a solid theme and releasing is a great way to find errors in your code, essentially it is like having thousands of testers in all sorts of different scenarios.

Learn from other themes. There are a few themes that do this extremely well. Thematic is one of my favorites.

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;

The interface has gotten a huge and much needed update. The layout is still simple and clean but now is more polished and modern. Customizing the CSS and the look of theme is even better, the entire site was coded with the end user customizing the site in mind.

Download Checkmate 2.0

• View the Demo Site
• Checkmate 2.0 (3675)

Theme Options

There has been a total redesign of the theme options page, and also new theme options to make customizing Checkmate even easier. Checkmate 2.0 has the ability to automatically detect uploads for CSS, logos, and backgrounds, which can easily be changed via the theme options page.

Layout Options

I mentioned the layout has been updated, well now it is also more flexible. Several users wanted a true 3 column layout(columns on each side of the content), now this is possible along with a single right column, a split right column, or a combo right column. All this is controlled using theme options and widget areas, no code editing!

Ad Management

Ad management remains in Checkmate 2.0 unchanged. It is the same simple and flexible widget and theme options combination which gives you a quick and easy way to get ads on your theme.

Support

Support for Checkmate has always been a strong point and something I’ve strove to provide the best support a free theme offers. Alas WordPress comments and email aren’t the best solution, so all support will now be handled via Tender. Where you can ask questions, read documentation, and contribute to discussions.

Features

Checkmate already had a big feature list, now it is even bigger:

• Optional background header images controlled by theme options and uploads are automatically detected
• User defined style sheets, easily changed and uploads are automatically detected
• Auto detected logo controlled through theme options
• Optional featured categories
• Feedburner integration
• Drop down Page menu, with theme options to control which Pages show in the menu
• Optional footer widget areas
• Option to use Checkmate’s previous rounded corner look
• Ability to insert code or content into the header, after a post, or footer, without editing theme files
• Ad management
• Checkmate comes with 4 color themes for you to build on: grey, brown, cake, and dark.
• Custom widgets built for Checkmate.
• Tabbed Content Box – widget enabled
• Two, Three, or Split Column Design
• Feedburner Integration
• Optional Widget enabled footer
• Custom Icons
• Gravatar support for authors and comments(WordPress 2.5)
• Custom author, archive, tag, category, and search pages.
• Widget Enabled Sidebars

Updates

• Version 2.0.1
• Updated for WordPress 2.7
• Threaded Comments Enabled
• Utilizes post_class()
• Automatically Checks for Updates
• Version 2.0.2
• Trackbacks/pingbacks style change, automatically hidden
• Comments navigation for 2.7 fixed
• Upgraded theme to use jQuery 1.3
• disabled auto check for update for now due to server load
• Version 2.0.3
• Added Localization
• Changed title structure for single post pages
• Version 2.0.4
• Converted widgets to 2.8 API
• Fixed bugs in widgets

License

Checkmate is released under the Creative Commons Attribution-Share Alike 3.0 license. All I ask is that you link back to my website somewhere in your site.

• Checkmate 2.0 (3675)

Really Like It?

If you really like this theme and would like updates, more features, and new styles, why not grease the wheel and make a donation?
PayPal takes $0.35 commission for a $1 donation. Please enter at least $1.35 , thank you! Please enter the amount you wish to donate and try again. Transferring to PayPal, please wait...

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.