if ( function_exists('register_sidebar') ) {

    $allWidgetizedAreas = array("Homepage Left", "Homepage Right", "Sidebar One", "Movies", "Admin");
    
    foreach ($allWidgetizedAreas as $WidgetAreaName) {
    
        register_sidebar(array(
           'name'=> $WidgetAreaName,
           'before_widget' => '<div id="%1$s" class="widget %2$s left half">',
           'after_widget' => '</div>',
           'before_title' => '<h3 class="widgettitle">',
           'after_title' => '</h3>',
        ));
    
    }

}

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 3 comments | Add to Delicious
Categorized: PHP | Tagged: functions, PHP, widgets

<div <?php post_class() ?> id="post-<?php the_ID(); ?>">
   <!-- Post stuff -->
</div>

I was in a circumstance where I wanted to add an additional class to what that was outputting. My thought process went like this:

1. Arg. I guess I’m going to have to write a function to filter the output of that function. Let’s begin the research.
2. Wait. I bet that function has an alternate that returns a string rather than echos it. I’ll just use that, and echo it out along with my own custom class.
3. Double wait. I bet those smart WordPress folks have thought of this…

1. Filtering

This kind of thing is generally beyond my comfort zone, but you’d basically write your own little function which takes in what the output would have been, add you own stuff to it, then return the new value.

Then call the new function with a filter in your functions.php file:

add_filter('post_class','add_my_stuff');

2. Output exiting classes, then add yours

Like most functions that echo stuff, there is a version that doesn’t echo stuff, in which “get_” prefaces the function name. I didn’t even have to look it up I just knew there would be. Since it’s a list, this function returns an array, so to output them, you’ll need to loop through the array:

<div class="<?php $allClasses = get_post_class(); foreach ($allClasses as $class) { echo $class . " "; } ?> group" id="post-<?php the_ID(); ?>">

The cool part here is that is doesn’t add “class=” in the output, you can do that yourself, meaning that I can add my own classes after the output is finished.

3. Built in…

Of course, as it turns out, this is far easier than #2 made it out to be. To add additional classes, just pass them as a parameter!

<?php post_class('special'); ?>

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 2 comments | Add to Delicious
Categorized: PHP | Tagged: classes, functions, Theme

But alas…

This ain’t gonna work “out-of-the-box”

After tinkering with some far-too-complicated solutions, someone on Twitter helped me with a deliciously simple solution: Just add this to your functions.php file:

add_filter('widget_text', 'do_shortcode');

This will ensure that the text content of widgets is parsed for shortcodes and those shortcodes are ran. Awesome.

Stephanie Leary wrote a great article on Using Shortcodes Everywhere, which covers this as well as using shortcodes in a bunch of other places: Comments, templates, excerpts, etc.

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 4 comments | Add to Delicious
Categorized: PHP | Tagged: shortcode, widgets

In this DiW tutorial, you’ll learn how to separate your responses and display the comment count for each type. Here is a diagram to help visual the goal:

As you can see, separating these lists gives us a cleaner comments area, making things easier for everyone. Even better news is that we’re going to set it up in two steps. If you would rather group the pingbacks and trackbacks and just segregate the comments, just a few tweaks and you’re off to the races.

First let’s see how to separate everything, then explain the grouping of pingbacks and trackbacks before wrapping things up.

Step 1 – Display separate comments, pingbacks, and trackbacks

The first thing we need to do is separate the different response types. Fortunately, WordPress makes this very easy. First, open your them’s single.php file and use the following template tag to call your comments.php template:

comments_template('/comments.php',true);

This code will enable WordPress to segregate and count each of the different response types using the $wp_query object. Now let’s separate the comments, pingbacks, and trackbacks. In your comments.php file, use the following code as your comments loop:

<?php if (!empty($comments_by_type['comment'])) { ?>

	<h3 id="comments">Comments<h3>
	<ol class="commentlist">
		<?php wp_list_comments('type=comment'); ?>
	</ol>

<?php } if (!empty($comments_by_type['pingback'])) { ?>

	<h3 id="pingbacks">Pingbacks</h3>
	<ol class="pingbacklist">
		<?php wp_list_comments('type=pingback'); ?>
	</ol>

<?php } if (!empty($comments_by_type['trackback'])) { ?>

	<h3 id="trackbacks">Trackbacks</h3>
	<ol class="trackbacklist">
		<?php wp_list_comments('type=trackback'); ?>
	</ol>

<?php } ?>

This symmetrical slice of code will output the following markup, assuming that the post actually has all three types of responses:

<h3 id="comments">Comments<h3>
<ol class="commentlist">
	<li>Comment #1 - Blah blah blah..</li>
	<li>Comment #2 - Blah blah blah..</li>
	<li>Comment #3 - Blah blah blah..</li>
</ol>
<h3 id="pingbacks">Pingbacks</h3>
<ol class="pingbacklist">
	<li>Pingback #1 - Blah blah blah..</li>
	<li>Pingback #2 - Blah blah blah..</li>
	<li>Pingback #3 - Blah blah blah..</li>
</ol>
<h3 id="trackbacks">Trackbacks</h3>
<ol class="trackbacklist">
	<li>Trackback #1 - Blah blah blah..</li>
	<li>Trackback #2 - Blah blah blah..</li>
	<li>Trackback #3 - Blah blah blah..</li>
</ol>

When one of the different response types doesn’t exist on the post, that section will simply be omitted from the markup, keeping things nice and clean.

Step 2 – Display separate response counts

Now, to display the count for each of these response types, we can call upon the $wp_query object to retrieve and echo the information:

<?php echo count($wp_query->comments_by_type['comments']); ?>
<?php echo count($wp_query->comments_by_type['pingback']); ?>
<?php echo count($wp_query->comments_by_type['trackback']); ?>

Each of these lines displays a number corresponding to a specific response type. These response counts may be integrated into our previous code to give us the final result:

<?php if (have_comments()) : global $wp_query; ?>

	<h2 id="comments"><?php comments_number('No Responses', 'One Response', '% Responses' ); ?><h2>

	<?php if (!empty($comments_by_type['comment'])) { ?>

		<h3 id="comments"><?php echo count($wp_query->comments_by_type['comment']); ?> Comments<h3>
		<ol class="commentlist">
			<?php wp_list_comments('type=comment'); ?>
		</ol>

	<?php } ?>
	<?php if (!empty($comments_by_type['pingback'])) { ?>

		<h3 id="pingbacks"><?php echo count($wp_query->comments_by_type['pingback']); ?> Pingbacks</h3>
		<ol class="pingbacklist">
			<?php wp_list_comments('type=pingback'); ?>
		</ol>

	<?php } ?>
	<?php if (!empty($comments_by_type['trackback'])) { ?>

		<h3 id="trackbacks"><?php echo count($wp_query->comments_by_type['trackback']); ?> Trackbacks</h3>
		<ol class="trackbacklist">
			<?php wp_list_comments('type=trackback'); ?>
		</ol>

	<?php } ?>

<?php else : // if there are no comments yet ?>

	<?php if (comments_open()) : ?>
		<!-- comments open, no comments -->
	 <?php else : ?>
		<!-- comments closed, no comments -->
	<?php endif; ?>

<?php endif; ?>

That’s the magic bullet right there. Used as your comments loop, this code will display separate comments, pingbacks, and trackbacks, with each showing their respective number of responses in its heading. Notice we threw in some additional code there to make everything completely plug-n-play. Bottom line: slap it in and test it yourself. Should work perfectly for all WordPress 2.7 and better.

Separate comments from both pingbacks and trackbacks

Note that, alternately, you could segregate comments from both pingbacks and trackbacks, such that your comments display would show something like this:

To do this, we modify the comment loop (from Step 1 above) like so:

<?php if (!empty($comments_by_type['comment'])) { ?>

	<h3 id="comments">Comments<h3>
	<ol class="commentlist">
		<?php wp_list_comments('type=comment'); ?>
	</ol>

<?php } if (!empty($comments_by_type['pings'])) { ?>

	<h3 id="trackbacks">Pingbacks &amp; Trackbacks</h3>
	<ol class="ping-trackbacklist">
		<?php wp_list_comments('type=pings'); ?>
	</ol>

<?php } ?>

Grouping the pingbacks and trackbacks is easy thanks to the “pings” parameter for the second wp_list_comments loop. Then to display the count for our combined pingbacks and trackbacks, we insert the following snippet into our “Pingbacks & Trackbacks” heading (similar to Step 2 above):

<?php echo count($wp_query->comments_by_type['pings']); ?>

That’s all there is to it! Once you get everything in place and working properly, you’ll have some clean HTML canvas to paint with any CSS styles you wish. Sounds like a great way to spend some time ;)

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 12 comments | Add to Delicious
Categorized: Design, PHP | Tagged: comments, tips, tricks

Widgetize Your WordPress Theme: Step 1

Make a fist and howl at the monitor. Then place this code into your active theme’s functions.php file:

if (function_exists('register_sidebar')) {

	register_sidebar(array(
		'name' => 'Widgetized Area',
		'id'   => 'widgetized-area',
		'description'   => 'This is a widgetized area.',
		'before_widget' => '<div id="%1$s" class="widget %2$s">',
		'after_widget'  => '</div>',
		'before_title'  => '<h4>',
		'after_title'   => '</h4>'
	));

}

This is all that is needed for the first step. Once this widgetizing code is placed in your functions.php file, proceed to Step 2. The remainder of this section is explanation.

This code checks to make sure that the current version of WordPress supports widgets, and then declares an array of values that will be used to create the widgetized area in your theme. Here are the different values:

• name – the name of the widgetized area as displayed in the WP Admin
• id – a unique identifier for your widgetized area
• description – description of the widgetized area
• before_widget – the markup generated before any user-added widgets
• after_widget – the markup generated after any user-added widgets
• before_title – the markup generated before the title of any user-added widgets
• after_title – the markup generated after the title of any user-added widgets

So, given these parameters, our widgetizing code would result in the following output, say, if the built-in Search widget were added to our widgetized area:

<div id="search-3" class="widget widget_search">
	<h4>Search</h4>
	<form role="search" method="get" id="searchform" action="http://localhost/283/" >
		<div>
			<label class="screen-reader-text" for="s">Search for:</label>
			<input type="text" value="" name="s" id="s" />
			<input type="submit" id="searchsubmit" value="Search" />
		</div>
	</form>
</div>

Note the markup created for the opening <div>, which gets its attribute information based on the wild-card matching specified in our widgetizing array. To see this more clearly, examine the following side-by-side comparison of the sprintf directives and the resulting (X)HTML source code:

'before_widget' => '<div id="%1$s" class="widget %2$s">',
<div id="search-3" class="widget widget_search">

Hopefully the relationship is clear. This is a powerful way to ensure that all widgets have a similar class names and unique IDs, which are important for easy CSS styles.

Let’s continue with Step 2..

Widgetize Your WordPress Theme: Step 2

Finally, add the following code to the location in your theme’s template file(s) where you would like the widgetized area to appear:

<div id="widgetized-area">

	<?php if (function_exists('dynamic_sidebar') && dynamic_sidebar('widgetized-area')) : else : ?>

	<div class="pre-widget">
		<p><strong>Widgetized Area</strong></p>
		<p>This panel is active and ready for you to add some widgets via the WP Admin</p>
	</div>

	<?php endif; ?>

</div>

With both steps complete, your theme should now feature a widgetized area in the location of your choosing. Nothing else needs to be done at this point. If you get it, then get to it and continue developing your theme. For more information and some juicy tips and tricks, continue reading.

Let’s examine the code used in this second step. Everything located between the if/endif statements will be output to the browser when no widgets have been activated. This is a good place to inform the user that the area is widgetized and may be customized via the Widgets area in the WordPress Admin. I also include a “pre-widget” class to help style the pre-widget area. With multiple widgetized areas on a page, having a class name to hang styles on is super nice.

Also, note that we are using the id specified in the widgetizing array (refer to Step 1) as the parameter value for the specific dynamic_sidebar() check in the third line.

Multiple widgetized areas

So we now have a nice, widgetized sidebar. But why stop there? Implementing additional widgetized areas is as simple as replicating the code in Step 1 and Step 2. For example, let’s say we wanted to widgetize the header, sidebar, and footer areas of our theme. We would be put this in our functions.php file:

if (function_exists('register_sidebar')) {

	register_sidebar(array(
		'name' => 'Header',
		'id'   => 'header',
		'description'   => 'This is the widgetized header.',
		'before_widget' => '<div id="%1$s" class="widget %2$s">',
		'after_widget'  => '</div>',
		'before_title'  => '<h4>',
		'after_title'   => '</h4>'
	));
	register_sidebar(array(
		'name' => 'Sidebar',
		'id'   => 'sidebar',
		'description'   => 'This is the widgetized sidebar.',
		'before_widget' => '<div id="%1$s" class="widget %2$s">',
		'after_widget'  => '</div>',
		'before_title'  => '<h4>',
		'after_title'   => '</h4>'
	));
	register_sidebar(array(
		'name' => 'Footer',
		'id'   => 'footer',
		'description'   => 'This is the widgetized footer.',
		'before_widget' => '<div id="%1$s" class="widget %2$s">',
		'after_widget'  => '</div>',
		'before_title'  => '<h4>',
		'after_title'   => '</h4>'
	));

}

..and then we would place the following code chunks into their respective locations within our theme template files:

<div id="widgetized-header">

	<?php if (function_exists('dynamic_sidebar') && dynamic_sidebar('header')) : else : ?>

	<div class="pre-widget">
		<p><strong>Widgetized Header</strong></p>
		<p>This panel is active and ready for you to add some widgets via the WP Admin</p>
	</div>

	<?php endif; ?>

</div>
<div id="widgetized-sidebar">

	<?php if (function_exists('dynamic_sidebar') && dynamic_sidebar('sidebar')) : else : ?>

	<div class="pre-widget">
		<p><strong>Widgetized Sidebar</strong></p>
		<p>This panel is active and ready for you to add some widgets via the WP Admin</p>
	</div>

	<?php endif; ?>

</div>
<div id="widgetized-footer">

	<?php if (function_exists('dynamic_sidebar') && dynamic_sidebar('footer')) : else : ?>

	<div class="pre-widget">
		<p><strong>Widgetized Footer</strong></p>
		<p>This panel is active and ready for you to add some widgets via the WP Admin</p>
	</div>

	<?php endif; ?>

</div>

That’s all there is to it. Of course, you’ll probably want to tweak the details to suit your specific needs, but these two steps are all you need to widgetize your WordPress theme. Now let’s wrap things up with some juicy widgetizing tricks..

Some Juicy Widgetizing Tricks

Here are some sweet little tips for widgetizing your theme:

Streamline & organize custom widgets

The first thing that I do after widgetizing a new theme is to include a separate “widgets.php” that contains all of the custom widgets. A simple line of code is all that is required to acheive this functionality:

if ($wp_version >= 2.8) require_once(TEMPLATEPATH.'/widgets.php');

Place that code into your functions.php file and place all of your widgets into a file called widgets.php. Once in place, this method will ensure that your widgets are loaded and available for all supportive versions of WordPress. This is a great way to keep your theme files nice and organized.

Replace WordPress’ default widgets

Many of the default WordPress widgets leave something to be desired. Fortunately, it’s super-easy to override any of the default widgets with your own creations. For example, here is one way to replace the default Search Widget with your own version:

<?php function custom_search_widget() { ?>

<form action="http://localhost/283/index.php" method="get">
	<div>
		<label for="s">Site Search</label>
		<input id="s" name="s" alt="Search" type="text" />
	</div>
</form>

<?php } if (function_exists('register_sidebar_widget'))

register_sidebar_widget(__('Search'), 'custom_search_widget'); ?>

Hide unused widget areas

An empty widgetized area of your theme can look strange, especially when CSS styles are applied to the container element. To prevent this from happening, we can wrap each of our widgetized areas with the following code:

<?php if (function_exists('is_sidebar_active') && is_sidebar_active('sidebar')) { ?>

<!-- code from Step 2 or whatever you want -->

<?php } ?>

With this conditional code, widgetized areas will only be displayed if they contain at least one active widget. Nice :) Also note that this conditional technique works for displaying things other than widgets.

More..?

Hopefully this easy two-step widgetizing guide will be useful for you during your next round of theme development. As always, if you know of any other sweet widgetizing tricks, please share them in the comments!

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 19 comments | Add to Delicious
Categorized: PHP, Theme | Tagged: PHP, Theme, widgets

I ran across some simple code in the official WordPress forums with a solution (thanks, t31os_!).

function the_title_trim($title) {

	$title = attribute_escape($title);

	$findthese = array(
		'#Protected:#',
		'#Private:#'
	);

	$replacewith = array(
		'', // What to replace "Protected:" with
		'' // What to replace "Private:" with
	);

	$title = preg_replace($findthese, $replacewith, $title);
	return $title;
}
add_filter('the_title', 'the_title_trim');

I saw a plugin to do this too, but I think since this is rather theme-specific, functions.php code makes the most sense.

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 6 comments | Add to Delicious
Categorized: PHP | Tagged: functions, PHP, tips

Remove nofollow attributes from post content

To clean up your post content, simply add the following code to your active theme’s functions.php file:

function remove_nofollow($string) {
	$string = str_ireplace(' rel="nofollow"', '', $string);
	return $string;
}
add_filter('the_content', 'remove_nofollow');

That’s all there is to it — no further editing required. Once in place, this function will filter all post content and remove any instances of rel="nofollow". Note that if you have some posts about nofollow, this function will remove rel="nofollow" from your code examples as well.

Remove nofollow attributes from post content and comment text

It’s just as easy to remove nofollow tags from comment text by including another add_filter function:

function remove_nofollow($string) {
	$string = str_ireplace(' rel="nofollow"', '', $string);
	return $string;
}
add_filter('the_content', 'remove_nofollow');
add_filter('comment_text', 'remove_nofollow');

With the additional add_filter, this code will eliminate all instances of rel="nofollow" that would have otherwise appeared in your post content and comment text.

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 18 comments | Add to Delicious
Categorized: PHP | Tagged: functions, posts, tips, tricks

The “comments closed” message on CSS-Tricks

Doing this is as simple as going to Settings > Discussion in your Admin area and setting the number of days before comments are turned off. This setting is completely global in that any single place on your entire site where comments are enabled, they will close after this number of days. On CSS-Tricks, I decided that while I like closing comments on articles after a certain amount of days, I wanted to leave comments open forever on my “snippets”, as I thought that those really aren’t meant for lengthy discussions anyway, and the comments are more for people sharing what works and what doesn’t. There really is no need for comments to be turned on for those.

Unfortunately I had no idea how to accomplish such a thing. So I emailed the smart guys over at WP Engineer, who came up with some good stuff.

Leave comments open forever on a particular CATEGORY

This is the code in it’s original form from WP Engineer:

/**
 * Close comments on an old post.  Hooked to comments_open and pings_open.
 * small modifications on the default functions of WordPress
 *
 * @param bool $open Comments open or closed
 * @param int $post_id Post ID
 * @param int $cat Category ID (cat_ID), set '' or empty for all categories
 * @param int $days_old Days to close comments, set '' for use value from settings
 * @return bool $open
 */
function wpe_close_comments_for_old_post( $open, $post_id, $cat = array(1, 4), $days_old = '' ) {
	if ( !$open )
		return $open;
 
	if ( in_category($cat) )
		return $open;
 
	if ( '' === $days_old )
		$days_old = (int) get_option('close_comments_days_old');
 
	if ( !$days_old )
		return $open;
 
	$post = get_post($post_id);
 
	if ( time() - strtotime( $post->post_date_gmt ) > ( $days_old * 24 * 60 * 60 ) )
		return false;
 
	return $open;
}
add_filter( 'comments_open', 'wpe_close_comments_for_old_post', 10, 2 );
add_filter( 'pings_open',    'wpe_close_comments_for_old_post', 10, 2 );

Leave comments open forever for a particular PAGE TEMPLATE

My own needs were slightly different in that I needed this to work for a special page template not a specific category (my snippets use page/parent structure not posts). I also just wanted regular posts to default to whatever setting was in the Admin, not set that number from the function.

And so my modified version is:

function wpe_close_comments_for_old_post( $open, $post_id, $template = 'page-snippet.php' ) {

	global $wp_query;
	
	if ( !$post_id ) {
		$post_id = $wp_query->post->ID;
    }
 
	if ( get_post_meta($post_id, '_wp_page_template', true) == $template && get_option('close_comments_for_old_posts') ) {
		return true;
	}

	return $open;
	
}
add_filter( 'comments_open', 'wpe_close_comments_for_old_post', 10, 2 );
add_filter( 'pings_open',    'wpe_close_comments_for_old_post', 10, 2 );

Works like a charm!

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 2 comments | Add to Delicious
Categorized: PHP | Tagged: comments, functions, PHP

Hence, the Custom Query Shortcode!

This is basically how I wanted it to work. You have a shortcode with one single parameter called “query”. (Remember, shortcodes are those things in brackets you can use in the body of Pages/Posts that do special stuff). In the “query” parameter, you literally enter exactly what you would enter for a query when using the query_posts() function. In other words:

[loop query=""]

You can pass whatever query you want to it. For example, let’s say you wanted to query for 20 Pages that were the child of a specific page and list them in Ascending order:

[loop the_query="showposts=20&post_type=page&post_parent=453&ord=ASC"]

What it returns

This is totally customizable in the function itself, but I made the judgement call for myself that it would return list items with linked post titles inside. So you’d go like this:

<ul>
[loop query="posts_per_page=3"]
</ul>

and you’d get:

<ul>
<li><a href="http://digwp.com/post-1/">Post 1</a></li>
<li><a href="http://digwp.com/post-2/">Post 2</a></li>
<li><a href="http://digwp.com/post-3/">Post 3</a></li>
</ul>

And of course those would be real URL’s and real Post titles…

The Code

This would go in your themes functions.php file. Now that I’m thinking more clearly about it, this probably makes more sense to be a plugin since it probably shouldn’t be theme-dependant, but oh well, we can do that another day.

function custom_query_shortcode($atts) {

   // EXAMPLE USAGE:
   // [loop the_query="showposts=100&post_type=page&post_parent=453"]
   
   // Defaults
   extract(shortcode_atts(array(
      "the_query" => ''
   ), $atts));

   // de-funkify query
   $the_query = preg_replace('~&#x0*([0-9a-f]+);~ei', 'chr(hexdec("\\1"))', $the_query);
   $the_query = preg_replace('~&#0*([0-9]+);~e', 'chr(\\1)', $the_query);

   // query is made               
   query_posts($the_query);
   
   // Reset and setup variables
   $output = '';
   $temp_title = '';
   $temp_link = '';
   
   // the loop
   if (have_posts()) : while (have_posts()) : the_post();
   
      $temp_title = get_the_title($post->ID);
      $temp_link = get_permalink($post->ID);
      
      // output all findings - CUSTOMIZE TO YOUR LIKING
      $output .= "<li><a href='$temp_link'>$temp_title</a></li>";
          
   endwhile; else:
   
      $output .= "nothing found.";
      
   endif;
   
   wp_reset_query();
   return $output;
   
}
add_shortcode("loop", "custom_query_shortcode");

Credit

When I first wrote this up to use, it totally didn’t work. I couldn’t figure it out… the query was getting passed over just fine, and if I hard coded the query, the whole thing would work just fine. It turns out that because the shortcode lived inside the content of a Post/Page, the ampersand characters in the query were getting encoded, and thus screwing up the query.

Dan Smith had the genius idea to use html_entity_decode() on the query before using it in query_posts(), but for some reason I couldn’t get it to take.

Roger Stringer coded up the solution with regular expressions you see above. Thanks guys!

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 8 comments | Add to Delicious
Categorized: PHP | Tagged: functions, loop, shortcode

Put in functions.php file

//Google Maps Shortcode
function fn_googleMaps($atts, $content = null) {
   extract(shortcode_atts(array(
      "width" => '640',
      "height" => '480',
      "src" => ''
   ), $atts));
   return '<iframe width="'.$width.'" height="'.$height.'" frameborder="0" scrolling="no" marginheight="0" marginwidth="0" src="'.$src.'"></iframe>';
}
add_shortcode("googlemap", "fn_googleMaps");

Usage inside Post/Page:

[googlemap width="200" height="200" src="[url]"]

Notice the three parameters above. Width and height are self explanitory, don’t use them at all for the default values set in the function itself. The src URL you can snag from Google Maps like this:

Easy!

This post is a good reminder of how easy it is to build your own shortcodes for specific bits of functionality that are specifically useful to you, whatever that might be. In the past, we’ve covered making shortcode permalinks.

Like the article? Get the book!

© 2010 Digging into WordPress | Permalink | 11 comments | Add to Delicious
Categorized: PHP | Tagged: functions, PHP, shortcode