PHP Starter » Intermediate

Send Print Jobs Directly from PHP

Andrew — Wed, 19 May 2010 16:04:25 +0000

I recently learned that you can send print jobs directly from a PHP server. How cool is that? This article will cover sending print jobs from a PHP server to a printer on the same LAN. This does not mean that someone viewing a page over the Internet can have something print on their local printer with these functions. This does mean if you have PHP running on a Windows server in your internal network, you can print to printers that are configured on that Windows server only.

This article really only applies if you are hosting the web server in your local office or place of business. If you are hosting your web server in a data center somewhere and you never see it, this article is probably not for you. In the diagram below, pretend the server and attached printers are in your office building somewhere, and the computers in the red box are your clients out on the Internet somewhere. Note that the printers at the client side are not used in this application.

Another possible setup would be if everything is on a private internal network, like the diagram below. In this case everything is in the green box because it is all on an internal network joined by a network switch. The two printers are in yellow boxes because they are only visible to the server if shared from those attached network computers, and the computers are turned on.

So now that we have the big picture, there are a couple other things to note. The web server needs to be running Windows, not Linux. The PHP Printer functions are Windows only. The printer(s) can be connected locally via USB/Parallel, over the network via IP JetDirect, or shared off of another server/computer.

Printing Plain Text Documents

Printing plain text documents are a piece of cake. It’s going to be similar to echoing text out to the web browser with a couple differences. This is the first test I did:

The printer in line 6 is in my windows printer list, and has to be matched exactly. That function can be called without a printer parameter, and PHP will use the default printer specified in php.ini or try to detect it based on how it is set in Windows. I wanted to do close to a full page of text, so I went to lipsum.com and generated some sample text and saved it to a text file.

So here is the printed result, and the cool thing is that the text was almost exactly a full page. The not-so-cool thing was that it doesn’t do simple things like word wrap. Luckily, we can run the text through wordwrap() before sending it to the printer to easily fix that.

For future examples, I will be using my PDFCreator printer so I don’t waste paper (or money) during testing, and I encourage you to do the same.

Printing a Custom Font

If you want to print with a custom font, it is done using functions that are similar to the GD Library functions. You need to define the font, X/Y position, and other font weight properties.

In this example, I’m going to use the freely available barcode font to print a barcode on a piece of paper. In this example, I am also going to define the printer document and the individual page.

Drawing Images

The printer functions only support writing bitmaps (bmp), so you will have to convert the images to that format before using it in this application. The X,Y parameters in the printer_draw_bmp() function are in inches.

Drawing Shapes

Several shapes can be drawn as well. The example will show two horizontal & parallel lines of different length.

Practical Uses

Couple uses come to mind, and I’m sure there are others (post them if you have a good one!).

Automatically print packing slips / invoices at a shipping center as customers place orders.
On an intranet website, have all the company printers configured at the server side so users can use the web application w/o worrying about setting up the printers at their workstation.
Automatically printing out reports generated by a CLI PHP script

For more information, check out PHP print functions.

Printing from PHP on Linux Servers

“But what about Linux servers!”, you say. Well, as previously stated, the PHP functions don’t support anything other than Windows, but there is an alternative. PHP4IT.com has an article titled Printing a form directly to a PCL printer (Linux) that should help you with manually building the Postscript file and writing it through to the printer. That should help get you started.

No related posts.

Making Google Static Maps a Little More Dynamic with PHP

Andrew — Wed, 17 Mar 2010 14:00:24 +0000

If you have messed with the Google Maps API, you know that the JavaScript and API keys can be a real headache. Yes, there are very complex implementations that you can use, but what if you want…just a map? If you want just a map with no dynamic interface, Google Static Maps is just for you. I will show how easy it is to use, and then spice it up with some PHP-powered enhancements.

Check out how easy this is. If I want a map centered at a my zip code, I can create a JPEG image for that area with this link:

http://maps.google.com/maps/api/staticmap?sensor=false&center=46311&zoom=14&size=600x400

And it generates this:

No API keys, no JavaScript, and the URL is even short enough to not have to wrap on the page. As long as you don’t need the typical panning and zooming features, this is the best option. There are a limited but practical set of features including map types (satellite, hybrid, regular, etc), markers, lines, shapes, custom icons, and all in different image formats. View the Google Static Maps API page for the full details.

Making it a Little More Dynamic

This is a site on PHP. I can’t show you how to create static maps and leave it at that. There are several good reasons why we might want to dynamically generate that URL.

Simple “You Are Here” Map

For starters, how about a map that shows your local area based on your IP address geolocation? This sample below uses the code from a previous article that showed how to determine the geographic location from any IP address.

Run This Example

Static Map for Your Location

Static map for your town:

If you are placed in the middle of an ocean, your IP address is probably not in the database. The blue marker is your specific IP location (probably not exact).

&markers=color:blue|,&zoom=13&size=600x400" />

Details from IP GeoLocation:

Show Your Position With Other Objects

We already know how to find a list of the closest items in our area from this post: Locate the Nearest Radar Station and Display Radar Images. Now, let’s apply it to generating a Static Google Map. This uses the “Implicit Positioning” feature where you can just list a bunch of points, and the map will automatically create a zoom level and center based on the created points.

Run This Example

Static Map for Your Location

5 Closest Radar Sites to You

Red marker is you.

&markers=color:red|,&size=600x400" />

Details from IP GeoLocation:

Radar Sites:

These examples are meant to get your creative juices flowing. Have some other cool concepts for Google Static Maps? Post them below.

No related posts.

Merge Image Layers in PHP

Andrew — Fri, 17 Jul 2009 12:00:40 +0000

In a previous article, I showed how to Locate the Nearest Radar Station and Display Radar Images. A commenter, mike, pointed out the idea of merging the image layers using PHP instead of layering all the images separately using CSS. Here is how to do it.

Just like the previous article on finding the closest radar station, I am going to use IP geolocation to find the closest radar site. See that previous article for an explanation on how to do that.

Run This Example

fetch($url);
		file_put_contents($filename, $snoopy->results);
		$snoopy->results = '';
	}
}

/* download the radar images */
$radar_id = $radar['id'];
dl_cache("http://radar.weather.gov/Overlays/Topo/Short/{$radar_id}_Topo_Short.jpg", "maps/{$radar_id}_Topo_Short.jpg");
dl_cache("http://radar.weather.gov/RadarImg/N0R/{$radar_id}_N0R_0.gif", "maps/{$radar_id}_N0R_0.gif");
dl_cache("http://radar.weather.gov/Overlays/County/Short/{$radar_id}_County_Short.gif", "maps/{$radar_id}_County_Short.gif");
dl_cache("http://radar.weather.gov/Overlays/Highways/Short/{$radar_id}_Highway_Short.gif", "maps/{$radar_id}_Highway_Short.gif");
dl_cache("http://radar.weather.gov/Overlays/Rivers/Short/{$radar_id}_Rivers_Short.gif", "maps/{$radar_id}_Rivers_Short.gif");
dl_cache("http://radar.weather.gov/Overlays/Cities/Short/{$radar_id}_City_Short.gif", "maps/{$radar_id}_City_Short.gif");
dl_cache("http://radar.weather.gov/Legend/N0R/{$radar_id}_N0R_Legend_0.gif", "maps/{$radar_id}_N0R_Legend_0.gif");
dl_cache("http://radar.weather.gov/Warnings/Short/{$radar_id}_Warnings_0.gif", "maps/{$radar_id}_Warnings_0.gif");

/* load the radar layers into an array */
$layers = array();
$layers[] = imagecreatefromjpeg("maps/{$radar_id}_Topo_Short.jpg");
$layers[] = imagecreatefromgif("maps/{$radar_id}_N0R_0.gif");
$layers[] = imagecreatefromgif("maps/{$radar_id}_County_Short.gif");
$layers[] = imagecreatefromgif("maps/{$radar_id}_Highway_Short.gif");
$layers[] = imagecreatefromgif("maps/{$radar_id}_Rivers_Short.gif");
$layers[] = imagecreatefromgif("maps/{$radar_id}_City_Short.gif");
$layers[] = imagecreatefromgif("maps/{$radar_id}_N0R_Legend_0.gif");
$layers[] = imagecreatefromgif("maps/{$radar_id}_Warnings_0.gif");

$image = imagecreatetruecolor(600, 550);


/* merge the layers */
for ($i = 0; $i < count($layers); $i++)
{
	imagecopy($image, $layers[$i], 0, 0, 0, 0, 600, 550);
}

/* we're done! output the image... */
header('Content-type: image/jpeg');
imagejpeg($image);

/**
 * Why do I comment out the PHP closing tag?
 * See: http://phpstarter.net/2009/01/omit-the-php-closing-tag/
 */
/* ?> */

The code from line ~31 on is pretty self-explanatory. Basically, I am caching the maps locally, and then loading the images into PHP image resources. I am putting the images in a PHP array because I want to make it easy add/delete/move layers. For the application I’m using it for, it’s not likely, but your needs may differ.

The important function is imagecopy(), which is defined as:

bool imagecopy ( resource $dst_im , resource $src_im , int $dst_x , int $dst_y , int $src_x , int $src_y , int $src_w , int $src_h )

Since I am copying whole pictures directly on top of each other – all the same size – it’s very easy. You can specify image sizes and location in case you are copying a smaller image onto a larger image, like a logo copyright on a photo, for example.

So there you have it. Although I believe the first method of layering the images via CSS works just fine, this method will work when you need to deliver a single image.

Loading INI Files in PHP

Andrew — Tue, 14 Apr 2009 12:00:23 +0000

PHP parses the php.ini file for the global PHP settings, but you can create an INI file that is specific to your own PHP application. You can also load those settings into as associate array with a native PHP function. How cool is that?

Why?

Having your config settings in a INI file makes it easier to edit, especially for those that don’t have PHP experience. It also comes in handy if you have protected PHP scripts, and you want someone to have the option of changing settings without having access to any of the PHP code. There are a couple negative effects though. Obviously, there is going to be some performance overhead because PHP will have to parse this file for each and every request made by a site visitor. Also, you can’t assign any dynamic values here, like time(), etc. You will have to make the call to determine if this method is best for you.

How it Works

Below is a sample INI file that the later examples will be loading. Notice the syntax used. The double quotes are not needed, but I am in the habit of using them because they are required if any special characters are in the values.

;some general settings not related to anything else
[general]
home_url = "http://www.example.com/"
contact_email = "contact@example.com"
app_path = "/path/to/app/root"
name = "application name"

;settings required to connect to a MySQL database
[database]
host = "localhost"
name = "database_name"
user = "db_user"
pass = "db_password"

;show we can have an array
[arrays]
test[] = "value1"
test[] = "value2"
test[] = "value3"

In the first load example, we are going to load all of the settings in one block. In other words, we are going to ignore the sections, defined in the ‘[ ]‘ characters.

Run This Example

*/

In the above example, we have a problem. Notice that we have the setting “name” in more than one block, and because of that, we had a name conflict and lost one of the values. To avoid this, we can put these setting blocks in their own associative array with the following statement.

Run This Example

*/

Now all the setting blocks are separated, and easily accessible.

So there you have it – a different type of configuration file that may be an option for your next PHP application. It’s pretty simple, and you really only need one function call to load all the settings, so the learning curve is minimal. If you want more information on this PHP function, check out the function reference.

Parse ZFP (Zone Forecast Product) Data in PHP – Option 1

Working with AJAX

Kurtis — Thu, 05 Mar 2009 06:00:24 +0000

AJAX is all over the internet today, and though completely unnecessary, a website with it can function much more quickly. Data can be transferred to and from users efficiently, but a major drawback is the extra code needed and some security issues inherent. Nevertheless, for certain applications, AJAX is great to know and take your project to a new level.The truth is that tutorials for learning the basics of AJAX are all over the internet. For the quick setup of JavaScript, check out any of these. What I want to focus on are more practical applications of the PHP end of AJAX. Surely you can understand the basics of passing variables to a PHP processing page, but let’s go over a few examples to understand what AJAX can accomplish for us.
First of all, a soon-to-come feature on JeoReview is on the page where boards can be created. The issue is that there is a chance that someone will pick a board name that is already in use, and while the PHP is set up to catch the error, I would like for JavaScript to be able to handle it earlier and more quickly to prevent posting to pages over and over again. So we will set up the JavaScript much like the examples show:

var xmlHttp;

function checkName(name) {
var url="checkName.php";
url=url+"?n="+name;
xmlHttp.onreadystatechange=stateChanged;
xmlHttp.open("GET",url,true);
xmlHttp.send(null);
}

function stateChanged()
{
if (xmlHttp.readyState==4 || xmlHttp.readyState=="complete")
{
document.getElementById("nStatus").innerHTML=xmlHttp.responseText;
}
}
function GetXmlHttpObject()
{
var xmlHttp=null;
try
{
// Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}
catch (e)
{
// Internet Explorer
try
{
xmlHttp=new ActiveXObject("Msxml2.XMLHTTP");
}
catch (e)
{
xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");
}
}

return xmlHttp;
}

I would place this into a separate JavaScript file and link it to the page where the action takes place, but all that is really needed from this point is to add an event trigger to the form field to execute this function. Something like this:

...

Please enter a name for your board.

...

You can see then that the value from the form field will be checked in the function which will send the data to a PHP file which we must now define. Whatever that PHP file “responds” with (or echoes back) will be displayed in the ‘p’ tag we defined below the input field. So let’s finish it off with the PHP file which must check the name entered against the boards already existing in the MySQL database, leading to something like this:

Depending on your application, the echoed strings would be changed and perhaps even a bit more complex, but these work fine for the basic application we worked through.

As I noted above, we used the GET method, just like what is used in normal forms, where variables are passed through the URL to be accessed by the PHP file. However, POST can be used and should be used in certain situations. In general, they coincide with the general rules for form method choosing. GET should be used for shorter requests of one or two variables and POST for multiple fields and especially those sent to the database. Remember that the URL from GET can only be so long before cut off and may not be able to hold all the information from a long request. Therefore, POST is certainly the most viable choice because it can be used in all applications by simply altering the method in the JavaScript and PHP and adding a few lines as noted on the tutorials listed above.

Still wondering where AJAX can come in handy? We’ve all seen those handy “username checks” on registration pages and the suggestions provided by Google, Yahoo!, YouTube, and other big-name websites, and these all employ AJAX. Whether you realized it or not because of their speed, these pages actually utilize more code than a typical PHP/ASP check, but they have certain disadvantages and will always be up for debate.

No related posts.

Regular Expressions May Cause Irregularity

Kurtis — Tue, 24 Feb 2009 06:00:14 +0000

Regular expressions seem rather complex, even like a foreign language to beginning programmers. The mixture of symbols and characters can bring you to tears if you have a limited understanding, but with the knowledge of the significance of each symbol and construct, regular expressions can bring you from irregularity to peaceful contention bliss.A regular expression (regex for short) is a pattern describing a string of text. There are levels of complexity for regular expressions, from simple strings of literal characters to repetition and grouping.

The most basic regular expression consists of a single literal character like a. It will match that character in a string, but only on the first time, unless you apply repetitive properties to it or are more specific. To use literal symbols, [, \, ^, $, ., |, ?, *, (, ) you must escape them with a backslash (\). For example, 1\+1=2 is the correct regular expression to match 1+1=2.

Next are character classes or character sets. Instead of specifying each letter of the alphabet or digit, it is possible instead to use sets of alphanumeric characters to match a string. For instance six[a-z]+ matches sixteen, sixty, and sixlet, among others. Charcter sets should be placed within brackets and can include any range of lower-case characters, upper-case characters, digits from 0 to 9, hyphens, and underscores.

Regular expressions do have some shorthand character classes to ease your mind: \d for all digits, \w for all alphanumeric characters or the underscore (“_”), \s for whitespace characters including tabs and line breaks, \t for tabs individually, \r for carriage returns, and \n for line feeds. Remember that Windows text files use \r\n to terminate lines while UNIX text files simply use \n.

The dot or period (“.”) stands for any character except line break characters, meaning the same as [^\n], where the ^ character means the negation of the following character (“anything but …”). Often times a character class or negated character class is faster and more precise, so be cautious when using the dot.

Alternation allows for some choice in your regular expressions. Using the vertical pipe bar (“|”), you can make sixteen, sixty, and sixlet all match the following regular expression: six(teen|ty|let). The question mark (“?”) allows for optional characters, for instance when dealing with British-English and American-English spellings (colou?r matches color and colour).

Lastly is the issue of repetition. The asterisk (“*”) tells the engine to atempt to match the class zero or more times. The plus sign (“+”) tries to match one or more times. An integer in curly brackets following a class can specify an exact amount of instances.

Now for some examples. The description above can seem quite weighty and boring, but some applications should solidify the ideas and clarify any confusion.

Format of an e-mail address

You can run through each e-mail address above, and the one named as good will work while the others will fail. Notice that we allow for three or four letter domains as well as those like “co.uk” where the domain would have two periods (“.”).

Another common use of regular expressions is in URL rewriting. For instance, on my website, JeoReview, when a user access a URL like ‘http://www.jeoreview.com/board/Board-Name’ a different page is served to show the board itself. In truth, that URL does not exist. The regular expression, as placed in the .htaccess file, looks like this:


Options FollowSymLinks
RewriteEngine On
RewriteRule ^board/(.+)$ loadboard.php?name=$1

The caret (“^”) marks the beginning of the string and the dollar sign (“$”) marks the end. Because nearly any character can be used for the board name, a dot (“.”) is used to match the name itself. In truth, the better alternative would be to match exactly what characters can be used to increase speed and accuracy. In any case, the $1 refers to the first character case, and each subsequent integer is filled with the following character cases, though in this example there is only one.

There are plenty of other great uses of regular expressions. Check some out by visiting these great resources and cheat sheets:

Regular-Expressions Reference (http://www.regular-expressions.info/reference.html)
Regular Expression Checker (http://regjex.com/)
Cheat Sheet (http://www.addedbytes.com/cheat-sheets/regular-expressions-cheat-sheet/)
Using Regular Expressions and PHP (http://www.regular-expressions.info/php.html)

No related posts.

Create Dynamic Banner Ads for Blogs & News Sites

Andrew — Thu, 12 Feb 2009 12:00:48 +0000

When you visit a site, their usual advertisers might catch your eye once or twice, but after that, you forget it’s there. Designing a banner ad that automatically updates with information such as current sales or latest blog posts is a great way to get repeat clicks and return visitors. In this article, I’m going to explain the code behind a dynamic ad implementation I use right here on this site.

If you go look at our Promote this Site page, you will see that a dynamic ad is offered that shows the most recent article on this site. This is accomplished by creating a PHP script that reads this site’s RSS Feed, finding the latest post title, and overlaying it onto a graphic template.

I think this concept has potential with blogs and news sites because static banner ads become holes in the page to repeat visitors. If I get somebody interested in this site once, then that banner will continue to catch their eyes when the article changes, and if they see a title that interests them again, they will visit the site again to read the latest article.

Here is some sample code based on what I have implemented on this site’s advertising page:

Run This Example

fetch('http://phpstarter.net/feed/');
		
		/* save this to a local cache file so the RSS feed isn't called too often */
		file_put_contents('feed.cache', $snoopy->results);
	}
	
	/**
	 * We will use lastRSS to parse the feed.
	 * See: http://phpstarter.net/2009/01/load-rss-feeds-into-php-arrays-with-lastrss/
	 */
	require('../includes/lastRSS.php');
	$rss = new lastRss();
	
	/* load the cached file */
	$feed = $rss->get('feed.cache');
	
	/* this is the banner add that we will overlay the text on top of */
	$im = imagecreatefromgif('banner_ad_article.gif');
	
	/* set some colors */
	$black = imagecolorallocate($im, 0, 0, 0);
	$white = imagecolorallocate($im, 255, 255, 255);
	$orange = imagecolorallocate($im, 249, 160, 33);
	
	/* load the font we want to use */
	$f_domestic = '../includes/Domestic_Manners.ttf';
	
	/* this is the title taken from the RSS feed's first (or most recent) item */
	$title = $feed['items'][0]['title'];
	
	/* get the width of the to-be-printed text so we can center it */
	$bbox = imagettfbbox(12, 0, $f_domestic, $title);
	$x = $bbox[0] + (imagesx($im) / 2) - ($bbox[4] / 2);
	
	/* write the text to the base image */
	imagettftext($im, 12, 0, $x, 52, $orange, $f_domestic, $title);
	
	/* tell the browser that we are outputting a GIF image */
	header('Content-type: image/gif');
	
	/* render the image */
	imagegif($im);
?>

No related posts.

Dynamically Converting Text to an Image

Kurtis — Thu, 05 Feb 2009 06:00:28 +0000

As CSS expands, so does web design as a whole, but where it still lacks (and most likely will always lack) is in the area of fonts. Depending on the user’s home computer and the actions he/she has taken on it, there are different fonts inherently available. In this article, however, we will talk about bypassing the user’s system and use the fonts you would like, via PHP and the GD library.

SEO experts would say using images to replace text is a bad idea because crawlers cannot read the text on images to analyze the content on your website, but this process will effectively use JavaScript to overcome that. First, we’ll talk about the basic idea of creating an image with the text using a basic GD function, imageloadfont().

You can see the file is in a strange format, but you can safely use this program to convert Windows font files to the necessary format. Using this program within the spectrum of an image created with PHP, text can be written on the image with a certain font:

You can see the image is tailored to fit the text so there is no extra whitespace. The only downside is that the ‘charwidth’ and ‘charheight’ variables have to be altered for different fonts.

With just this basic script you can turn text into an image, but how about returning to the overarching idea of dynamically turning text on a website into an image to utilize a desired font. We’ll use some simple JavaScript for that.

Note: I’m using the most basic template of an HTML file to show the idea of the script.

Text to Image Conversion

This will become an image

This won't become an image.

This will also become an image.

Referencing the PHP file we created in the JavaScript of this file will turn each ‘h2′ element into an image. As I mentioned earlier, this will not mess with most search engines, though, because the text will remain for those where JavaScript is turned off. Note, though, that that also means that users with JavaScript disabled will not see the fancy image either, just the plain text, so be sure to style it with CSS as well to insure the design of your website.

No related posts.

Editing Images – Resizing, Cropping, and more!

Kurtis — Thu, 29 Jan 2009 06:00:09 +0000

We’ve seen the graphics PHP can create for you, but how extensive is PHP’s ability to edit preexisiting images? In this article, I will explore some common functions that image editing software provides, but I’ll only use PHP. We’ll focus mainly on cropping, resizing, flipping, and adding some effects to photos.Of course there are hundreds of image editing software packages available, many for free, but there is something to be said for editing images with PHP. In fact, it just may be that working with graphics may mean utilizing internet programs to do what we typically do with programs like Photoshop.

First of all, let’s talk about cropping and resizing images as the two use the same function, just in a slightly different way. The function is imagecopyresampled().

It’s quite a doozy, but all of the parameters are self-explanatory. The variables ‘newX’ and ‘oldX’ refer to the new starting x-coordinates and old coordinate, respectively, and so on for the y-coordinates as well.

To crop an image, the idea is that we select a rectangular section of the original image and copy it to a new image. Realize that in this case the ‘oldWidth’ and ‘oldHeight’ variables refer to the selection cropped, not the entire original image. The process looks like this:

Next is the very similar resizing function. The only difference with resizing is that you don’t need to pick a certain area of the image; the entire image will be copied, simply at a different width and height.

You can see that these two ideas are very closely related, so there isn’t much difference between the two functions. Next, let’s talk about flipping images, both horizontally and vertically.

There are two new functions we’ll talk about here, one that gets the color of the image at a specified pixel, and the other sets the color of the image at a specified pixel.

The only other thing we need to talk about is the idea of rolling through each pixel, and we’ll do this using two simultaneous ‘for’ statements, one that runs through the image pixel-by-pixel horizontally, and another one that runs through each vertically at the same time. This will allow us to get and set the color of each pixel in the image.

To flip an image horizontally, the left-most pixel becomes the right-most and vice-versa. The top-most and bottom-most pixels switch when we flip vertically. The process looks like this:

Last, but not least, I’ll show you how to apply several different types of effects to an image, and this doesn’t require any special calculations, just one function, imagefilter(). You can read about all of the different filters available, but the main ones are blurring, converting to gray scale, and changing contrast/brightness.

With these GD functions in tow, there is very little you can’t do with PHP. Alright, so there’s still quite a bit that PHP can’t do with images practically, but it’s only a matter of time before programmers are able to apply even the most complex Photoshop functions to PHP.

No related posts.

Sort Posts by Comment Count in WordPress

Andrew — Tue, 20 Jan 2009 12:00:10 +0000

I use this technique to show the most popular posts on our homepage, and although this isn’t a core feature in WordPress, it’s not all that hard to do. All it takes is a little PHP and a single edit to one of your WordPress template files.

I decided not to use a plugin because I find it easier to just edit the templates directly. Here is the code:

get_results("SELECT ID, comment_count FROM wp_posts WHERE post_type = 'post' && post_status = 'publish' ORDER BY comment_count DESC LIMIT 5");
foreach ($results as $r):
	query_posts(array('p' => $r->ID));
	while (have_posts()):
		the_post();
?>

This code manually calls a SQL query because there is no template tag that supports this method of sorting as of WordPress 2.7. We are only querying for the post IDs because we will use that ID to call up the WordPress loop which will allow us to use the normal template tags inside the manual WordPress loop.

No related posts.