The register_post_type() function takes care of telling WordPress about how we define each new piece of content. Like most things WordPress, it’s described in great detail over at the Codex, along with its dizzying array of configuration arguments (See what we did there—array? Okay, tough crowd …). In this chapter, we’ll just refer to the ones we need.

We’ll wrap all these up in our own function, conference_post_types_register(), and call on that function whenever the init action occurs:

function conference_post_types_register() {
    register_post_type( 'conference_speaker',
        array(
            'labels' => array((1)
                'name' => __( 'Speakers' ),
                'singular_name' => __( 'Speaker' ),
                'add_new' => __( 'Add New Speaker' ),
                'add_new_item' => __( 'Add New Speaker' ),
                'edit' => __( 'Edit' ),
                'edit_item' => __( 'Edit Speaker' ),
                'new_item' => __( 'New Speaker' ),
                'view' => __( 'View Speaker' ),
                'view_item' => __( 'View Speaker' ),
                'search_items' => __( 'Search Speakers' ),
                'not_found' => __( 'No speakers' ),
                'not_found_in_trash' => __( 'No speakers in the Trash' ),
            ),
            'hierarchical' => false,(2)
            'public' => true,(3)
            'menu_position' => 25,(4)
            'menu_icon' => plugins_url( 'icons/user_comment.png' , __FILE__ ),(5)
            'has_archive' => 'speakers',(6)
            'rewrite' => array('slug' => 'speaker'),(7)
            'supports' => array( 'title', 'excerpt', 'editor', 'thumbnail'),(8)
            'description' => "A conference speaker page is a page of↵
               information about a person who'll appear at this event."

        )
    );
}

add_action( 'init', 'conference_post_types_register' );

That’s a lot of arguments, but can you believe that this is all you need to create a basic new post type? It’s true! Save your work and have a look at your WordPress admin screen. You should find that your menu now contains a new item for Speakers, as seen in Figure 4.1.

Figure 4.1. Creating a new speaker

Neat, hey? But we still need to add some new fields; that’s what will come next.

Our conference speakers’ pages need to include a note about who they work for (even if it’s themselves), and their website’s URL and title. Now, you could include these in the text of each page, if you wanted, but that’s hardly the same as properly structured data.

This problem’s been solved for a long time in the world of WordPress, of course; its custom fields feature allows you to create metadata about a post. Used properly, custom fields are a deadly weapon in the hands of an expert WordPress ninja—unfortunately, it also means that our users need to remember which field goes with what type of data. For example, you might want certain blog posts that represent quotations to have a source name and URL, so you’d have to remember to pick the right label, put the source in, and hope there’s nothing you’ve forgotten. And if you use custom fields for several types of posts, they’re all shown right there in the Custom Posts pull-down, which just seems superfluous.

For improved usability, wouldn’t it be better just to fill in a clearly labeled set of fields? Sure it would—that’s why we’ve hidden that interface element from our posting screen. We’ll write our own Edit Screen, with our own form fields.

Let’s create a function that reads the values of a number of custom fields, and prints form fields for each. Here’s a fairly simplistic bit of PHP form creation:

function conference_speaker_fields (){
    global $post;
    $custom = get_post_custom($post->ID);
    $conference_speaker_business = $custom["conference_speaker_business"][0];
    $conference_speaker_website_name = $custom↵
      ["conference_speaker_website_name"][0];
    $conference_speaker_website_url = $custom["conference_speaker_website_url"]↵
      [0];
    $conference_speaker_location = $custom["conference_speaker_location"][0];
    ?>

    <p>
    <label>Employer/Business Name:</label><br />
    <input size="45" name="conference_speaker_business" 
       value="<?php echo $conference_speaker_business; ?>" />
    </p>
    <p>
    <label>Website Name:</label><br />
    <input size="45" name="conference_speaker_website_name" 
       value="<?php echo $conference_speaker_website_name; ?>" />
    </p>
    <p>
    <label>Website URL:</label><br />
    <input size="45" name="conference_speaker_website_url" 
       value="<?php echo $conference_speaker_website_url; ?>" />
    </p>
    <p>
    <label>Location:</label><br />
    <input size="45" name="conference_speaker_location" 
       value="<?php echo $conference_speaker_location; ?>" /></p>

    <?php
}

Notice that we’ve prefixed every post meta field with conference_speaker_? You never know when you might install a plugin that has fields that clash with your existing ones. Using a prefix like this makes it less likely to occur.

How do we place them on the edit screen? add_meta_box() is the function that will help us, and it accepts seven arguments. The four mandatory arguments are:

Optional arguments are:

Let’s take all that HTML we made before in conference_speaker_fields(), and put it in a new meta box called conference_speaker_info, with a title of Speaker Details. Naturally, we only want this to appear in the conference_speaker content type. Here’s a function to create it:

 function add_conference_speaker_box(){
    add_meta_box(
        "conference_speaker_info",
        "Speaker Details",
        "conference_speaker_fields",
        "conference_speaker"
        );
}

Here, we’ve only used the four mandatory arguments.

We’ll also need a function to save them. update_post_meta() is the WordPress function that inserts values as custom fields. We’ll take the value of each field from the POST variable, and save them in an appropriately named custom field for the current post:

function save_conference_speaker_attributes(){
    global $post;
    update_post_meta($post->ID, "conference_speaker_business",↵
      $_POST["conference_speaker_business"]);
    update_post_meta($post->ID, "conference_speaker_website_url",↵
      $_POST["conference_speaker_website_url"]);
    update_post_meta($post->ID, "conference_speaker_website_name",↵
      $_POST["conference_speaker_website_name"]);
    update_post_meta($post->ID, "conference_speaker_location",↵
      $_POST["conference_speaker_location"]);
}

The admin_init action is triggered whenever an admin page is loaded; accordingly, it’s the right place to call on our function that adds the conference speaker box:

add_action( 'admin_init', 'add_conference_speaker_box' ); 

We also want to jump aboard when the save and publish actions happen, so that we can save what’s in our customized fields:

add_action('save_post', 
'save_conference_speaker_attributes'),
add_action('publish_post', 
'save_conference_speaker_attributes'),

Let’s expand on our plugin a little further, and create our conference sessions post type, with a Sessions submenu in the Admin menu. We have already learned how to set up one of these, so the following register_post_type() should be reasonably familiar to you:

register_post_type( 'conference_session',
    array(
        'labels' => array(
            'name' => __( 'Sessions' ),
            'singular_name' => __( 'Session' ),
            'add_new' => __( 'Add New Session' ),
            'add_new_item' => __( 'Add New Session' ),
            'edit' => __( 'Edit' ),
            'edit_item' => __( 'Edit Session' ),
            'new_item' => __( 'New Session' ),
            'view' => __( 'View Session' ),
            'view_item' => __( 'View Session' ),
            'search_items' => __( 'Search Session' ),
            'not_found' => __( 'No sessions' ),
            'not_found_in_trash' => __( 'No sessions in the Trash' ),
        ),
        'public' => true,
        'hierarchical' => false,
        'exclude_from_search' => false,
        'menu_position' => 20,
        'menu_icon' => plugins_url( 'icons/calendar_view_day.png' ,↵
           __FILE__ ),
        'query_var' => true,
        'can_export' => true,
        'has_archive' => 'sessions',
        'description' => "A conference session is an event: a↵ 
           workshop, talk, panel, or get-together.",
        'rewrite' => array('slug' => 'sessions'),
        'supports' => array( 'title', 'excerpt', 'editor', 'thumbnail' )
    )
);
                  

Again, although it’s relatively long, it’s also fairly straightforward. Each piece of session content represents an event in our conference, but in many other respects it resembles a regular sort of post: it’ll have an excerpt, a post body, and a title. We’ll also need some details about where and when the session will be held, so we’ll add another meta box, like so:

function conference_session_admin(){
    add_meta_box("conference_session_meta", "Session Details",↵
                  "conference_session_meta", "conference_session",↵
                  "normal", "core");
}

function conference_session_meta (){
    global $post;
    $custom = get_post_custom($post->ID);
    $conference_session_room = $custom["conference_session_room"][0];
    $conference_session_date = $custom["conference_session_date"][0];
    ?>

    <p>
    <label>Room</label><br />
    <select name="conference_session_room">
      <option value="Grand Ballroom">Grand Ballroom</option>
      <option value="Plenary A">Plenary A</option>
      <option value="Plenary B">Plenary B</option>
      <option value="Theatre">Theatre</option>
    </select>
    </p>

    <p><label>Session date and time</label><br />
    <input size="45" id="conference_session_date" 
       name="conference_session_date" 
       value="<?php echo $conference_session_date; ?>" />
    </p>    

    <?php
}

In this example, we’ve chosen to use a pull-down for each of the conference session venues, since they won’t change. The date and time information is open—that makes it easy to insert flexible statements like “From 8 till late” or “6:30pm for a 7pm start.” So far, so good, and still familiar territory.

Where our sessions will differ significantly from our earlier efforts will be in how we treat the topic of, well, topics.

If you’ve attended a conference lately, you’ll know how tricky it is to decide which sessions to attend—and if it was a really good conference, you would have found yourself spoiled for choice! It’s helpful to be able to plan your timetable by gaining a sense of which sessions will best suit your interests and skills. How can we make this easy for our site’s visitors? One way is by creating a custom taxonomy for our conference sessions. In the general sense, a taxonomy is a scheme of classification. In the WordPress sense, taxonomies are what we call sets of categories and tags. A vanilla install of WordPress already comes with three: post tags, categories, and link categories. Custom taxonomies work like these familiar tags and categories to add more meaning to custom post types.

In our conference scenario, we’ll be expecting our speakers to hold forth on a number of web-type topics—such as JavaScript, usability, or WordPress—so it makes sense for our conference session post types to allow for this. You can create a new taxonomy using the register_taxonomy() function, which accepts three parameters: the name of the taxonomy, the type of content it’s to be used with, and an array of additional arguments. In the below example, we’ll set up a new taxonomy for session topics:

We’ll wrap it all up in a function, create_conference_taxonomy(), like so:

function create_conference_taxonomy() {

    $topiclabels = array(
      'name' => 'Topic',
      'singular_name' => 'topic',
      'search_items' =>  'Search topics',
      'popular_items' => 'Popular topics',
      'all_items' => 'All topics',
      'parent_item' => null,
      'parent_item_colon' => null,
      'edit_item' => 'Edit topic', 
      'update_item' => 'Update topic',
      'add_new_item' => 'Add new topic',
      'new_item_name' => 'New topic name',
      'separate_items_with_commas' => 'Separate topics with commas',
      'add_or_remove_items' => 'Add or remove topics',
      'choose_from_most_used' => 'Choose from common topics',
      'menu_name' => 'Conference topics',
    ); 
    register_taxonomy( 'conference_topics', 'conference_session',
        array(
       'hierarchical' => false,
             'labels' => $topiclabels,
             'query_var' => true,
             'update_count_callback' => '_update_post_term_count',
             'rewrite' => array('slug' => 'topics' )
        )
    );
}

Finally, you’ll need to initialize this function—associate it with the init action as follows:

add_action('init', 'create_conference_taxonomy', 0);

Once you’ve put all this together, your new taxonomy will be in your administration area, and should look like Figure 4.2. Since topics are associated with questions, you’ll find them in the Sessions menu.

Figure 4.2. Our new taxonomy, ready for action

In this example, we’ll use a child theme for the the Twenty Eleven template. Let’s save ourselves some extra work, and make a copy of Twenty Eleven’s single.php template; then we’ll rename it according to the rules of the Template Hierarchy—let’s call it single-conference_speaker.php.

Looking inside the template, we’ll see that there’s a <nav> element containing forward and back links (remember previous_post_link() and next_post_link()?), a reference to a template part, and a reference to the comments template. These are all surplus to our requirements, so be merciless with the delete key! Get rid of this superfluous markup, and you should be left with an empty shell of a template containing an empty loop:

get_header(); ?>

        <div id="primary">
            <div id="content" role="main">

                <?php while ( have_posts() ) : the_post(); ?>


                <?php endwhile; // end of the loop. ?>

            </div><!-- #content -->
        </div><!-- #primary -->

<?php get_footer(); ?>

That certainly is a big, empty hole in the middle of that template. Let’s fill it with template tags!

For our speakers, we’ll list the speaker’s name (the item’s title), plus the company, website, and location (all post meta fields). After that, we’ll show the entry’s content. Here’s some markup and template tags that will help us achieve that effect:

<?php while ( have_posts() ) : the_post(); ?>

    <article id="post-<?php the_ID(); ?>" <?php post_class(); ?>>
        <header class="entry-header">
            <h1 class="entry-title">
                Speaker Profile: <span><?php the_title(); ?></span>
            </h1>
            <p class="speaker-meta">
            Works at: <?php echo get_post_meta($post->ID,↵
                       'conference_speaker_business', true); ?>
            | Visit <a href="<?php echo get_post_meta($post->ID,↵
                       'conference_speaker_website_url', true); ?>">
                <?php echo get_post_meta($post->ID,↵
                   'conference_speaker_website_name', true); ?>
            </a>
          | Comes from: <?php echo get_post_meta($post->ID,↵ 
                         'conference_speaker_location', true); ?>
            </p>
        </header>

        <div class="entry-content">
            <?php the_content(); ?>
        </div><!-- .entry-content -->

    </article>


<?php endwhile; ?>

As you can see, it’s just like theming a single post or page—but this time, we’re making use of those custom meta fields. It will be similar for our sessions, but we’ll also throw in an if statement that checks to see if the taxonomy exists. If it does, we’ll use get_the_term_list() to build up a set of links:

<?php while ( have_posts() ) : the_post(); ?>

    <article id="post-<?php the_ID(); ?>" <?php post_class(); ?>>
        <header class="entry-header">
            <h1 class="entry-title"><?php the_title(); ?></h1>
            <div class="session-meta">
            <dl>
            <dt>Where</dt>
            <dd><?php echo get_post_meta($post->ID, 'conference_session_room',↵
              true); ?></dd>
            <dt>When</dt>
            <dd><?php echo get_post_meta($post->ID, 'conference_session_date',↵
              true); ?></dd>
            <?php
            if(taxonomy_exists('conference_topics')) { 
                echo get_the_term_list( $post->ID, 'conference_topics',↵
                  '<dt>Topics</dt><dd>', ', ', '</dd>' ); 
                 } ?>
            </dl>
            </div>
        </header>

        <div class="entry-content">
            <?php the_content(); ?>
        </div><!-- .entry-content -->

    </article>
<?php endwhile; ?>

There are very few differences between regular, built-in WordPress content types and your own custom ones. If you’re a skilled themer, you’ll have no problem showing off your custom types!

Earlier in this chapter, we talked about how we could specify an archive page for each of our custom types—the pages that represent each archive will be found at Speakers and Sessions. Now that we’re digging around in our theme, it’s time to put these archives together. Looking back at our Template Hierarchy structure, we can see that WordPress will check for a file called archive-{posttype}.php, so we’ll need two files, archive-conference_session.php and archive-conference_speaker.php.

Once again, we’ll create an archive template by copying the one that comes with Twenty Eleven, stripping out the unnecessary parts, and enhancing the rest. We can also manipulate The Loop using our old friend query_posts(). In this example, we’re collecting our conference_session items at 30 items per page, ordered by title:

$args = array(
        'posts_per_page' => 30,
        'order' => 'ASC',
        'orderby' => 'title',
        'post_type' => 'conference_session'
    );
  query_posts($args);

And if we have posts, we’ll display our list. If we happen to have more than 30 events, we’ll paginate. twentyeleven_content_nav() is a function defined by our parent theme that does the job here:

if ( have_posts() ) : ?>

<header class="archive-header">
    <h1>
        Sessions
    </h1>
</header>
<p>You'll love our packed timetable! ...</p>

<?php twentyeleven_content_nav( 'nav-above' ); ?>

<?php /* Start the Loop */ ?>
<?php while ( have_posts() ) : the_post(); ?>

    <article class="session">
        <h2><a href="<?php the_permalink() ?>"><?php the_title(); 
            ?></a></h2>
        <div class="session-meta">
        <dl>
        <dt>Where</dt>
        <dd><?php echo get_post_meta($post->ID,↵
             'conference_session_room', true); ?></dd>
        <dt>When</dt>
        <dd><?php echo get_post_meta($post->ID,↵
             'conference_session_date', true); ?></dd>
        <?php if(taxonomy_exists('conference_topics')) { 
            echo get_the_term_list( $post->ID, 'conference_topics',↵
           '<dt>Topics</dt><dd>', ', ', '</dd>' ); 
             } ?>
        </dl>
        </div>
        <?php the_excerpt(); ?>

    </article>

<?php endwhile; ?>

<?php twentyeleven_content_nav( 'nav-below' ); ?>

If there’s nothing to display, it’s probably because we’re yet to post any sessions, so we’ll show a message to that effect:

<?php else : ?>

    <article id="post-0" class="post no-results not-found">
        <header class="entry-header">
            <h1 class="entry-title">Watch this space!</h1>
        </header><!-- .entry-header -->

        <div class="entry-content">
            <p>We've yet to post any sessions, but if you
               subscribe to our newsletter you'll be the first 
               to find out!</p>
            <?php get_search_form(); ?>
        </div><!-- .entry-content -->
    </article><!-- #post-0 -->

<?php endif; ?>

Once you have your templates sorted, your custom post modifications are complete!