root/image-headlines/tags/2.6/image-headlines.php

<?php
/*
Plugin Name: Headline Images
Plugin URI: http://www.coldforged.org/image-headlines-plugin-for-wordpress-15/
Description: Replaces Post headlines with PNG images of text, from ALA's <a href="http://www.alistapart.com/articles/dynatext/">Dynamic Text Replacement</a>. Includes soft-shadows, improved configuration, and previews. Configure on the <a href="../wp-admin/admin.php?page=image-headlines.php">Headline Images Configuration</a> page.
Version: 2.6
Author: Brian "ColdForged" Dupuis
Author URI: http://www.coldforged.org
*/

/* 
    Bundled font is the beautiful Warp 1 by Alex Gollner. Take a
    gander at some of his other fonts at 

    http://www.project.com/alex/fonts/index.html
*/    

/*
    Plugin originally by Joel �Jaykul� Bennett, but heavily modified
    to the point seen here. 

    Dynamic Heading Generator
    By Stewart Rosenberger
    http://www.stewartspeak.com/headings/
    http://www.alistapart.com/articles/dynatext/

    This script generates PNG images of text, written in
    the font/size that you specify. These PNG images are passed
    back to the browser. Optionally, they can be cached for later use.
    If a cached image is found, a new image will not be generated,
    and the existing copy will be sent to the browser.

    Additional documentation on PHP's image handling capabilities can
    be found at http://www.php.net/image/
*/

define( "IMAGEHEADLINES_VERSION", "2.5" );

if (! isset($wp_version))
{
    require_once (dirname(dirname(dirname(__FILE__))) . "/wp-config.php");
    global $wp_version;
}

if (substr($wp_version, 0, 3) == "1.1" || substr($wp_version, 0, 3) == "1.0" || substr($wp_version, 0, 3) == "1.2" )
{
    echo "The Image Headlines Plugin requires at least WordPress version 1.3";
    return;
}

define( "FONT_DIRECTORY", dirname(dirname(__FILE__))."/image-headlines" );

if (function_exists('load_plugin_textdomain'))
{
    load_plugin_textdomain('headlinedomain');
}

if (! function_exists('ImageHeadline_update_option'))
{
    function ImageHeadline_update_option($option, $new_settings) 
    {
        update_option($option, $new_settings);
    }
    function ImageHeadline_get_settings($option)
    {
        $settings = get_settings($option);

        // HACK for problems with some WordPress 1.3 installations.
        if( is_string($settings) )
        {
            $unserialized = @ unserialize(stripslashes($settings));
            if( $unserialized !== FALSE )
                $settings = $unserialized;
        }
        return $settings;
    }
}

if (! function_exists('ImageHeadline_option_set'))
{
    function ImageHeadline_option_set($option) 
    {
        if (! $options = ImageHeadline_get_settings('ImageHeadline_options'))
            return false;
        else
            return (in_array($option, $options));
    }

}

if (! function_exists('ImageHeadline_add_options_page')) 
{
    function ImageHeadline_add_options_page() 
    {
        if (function_exists('add_options_page'))
            add_options_page(__("Headline Options Page"), __('Headlines'), 7, basename(__FILE__));
    }

}

if (! function_exists('ImageHeadline_option_set'))
{
    function ImageHeadline_option_set($option) 
    {
        if (! $options = ImageHeadline_get_settings('ImageHeadline_options'))
            return false;
        else
            return (in_array($option, $options));
    }

}

if (!function_exists('ImageHeadline_check_flag'))
{
    function ImageHeadline_check_flag($flagname, $allflags) 
    {
        echo (in_array($flagname, $allflags) ? 'checked="checked"' : '');
    }
}

if (!function_exists('ImageHeadline_check_select'))
{
    function ImageHeadline_check_select($flagname, $allflags, $value) 
    {
        echo ($allflags[$flagname] == $value ? ' selected="selected"' : '');
    }
}


if (!function_exists('ImageHeadline_check_radio'))
{
    function ImageHeadline_check_radio($flagname, $allflags, $value) 
    {
        echo ($allflags[$flagname] == $value ? 'checked="checked"' : '');
    }
}

if( !function_exists('ImageHeadline_gd_version' ) )
{
    function ImageHeadline_gd_version() {
       static $gd_version_number = null;
       if ($gd_version_number === null) {
           // Use output buffering to get results from phpinfo()
           // without disturbing the page we're in.  Output
           // buffering is "stackable" so we don't even have to
           // worry about previous or encompassing buffering.
           ob_start();
           phpinfo(8);
           $module_info = ob_get_contents();
           ob_end_clean();
           if (preg_match("/\bgd\s+version\b[^\d\n\r]+?([\d\.]+)/i",
                   $module_info,$matches)) {
               $gd_version_number = $matches[1];
           } else {
               $gd_version_number = 0;
           }
       }
       return $gd_version_number;
    } 
}

if( !function_exists('ImageHeadline_readint'))
{
    function ImageHeadline_readint( $file, $offset, $size )
    {
        @fseek( $file, $offset, SEEK_SET );
        $string = @fread( $file, $size );
        $myarray = @unpack( (( $size == 2 ) ? "n" : "N")."*", $string );
        return intval($myarray[1]);
    }
}

if( !function_exists('ImageHeadline_get_ttf_font_name'))
{
    function ImageHeadline_get_ttf_font_name( $fullpath )
    {
        $return_string = '';
        
        $thefile = @fopen( $fullpath, "rb" );
        if( $thefile )
        {
            // Read the number of records.
            $num_tables = ImageHeadline_readint( $thefile, 4, 2 );

            // Loop through looking for the name record.
            $offset = 12;
            $name_offset = 0;
            $name_length = 0;
            for( $x = 0; ( $x < $num_tables ) && !feof( $thefile ) && ( $name_offset == 0 ); $x++ )
            {
                @fseek( $thefile, $offset, SEEK_SET );
                $tag = @fread( $thefile, 4 );

                if( !strcmp( $tag, 'name' ) )
                {
                    // Found the 'name' tag so read the offset into the file of
                    // the name table.
                    $offset += 8;
                    $name_offset = ImageHeadline_readint( $thefile, $offset, 4 );
                    $name_length = ImageHeadline_readint( $thefile, $offset+4, 4 );
                } else {
                    $offset += 16;
                }    
            }

            // See if we have an offset to the name table.
            if( $name_offset != 0 )
            {
                // Yay, likely this is a valid TTF file. That's nice. See how many name entries
                // we have.
                $num_names = ImageHeadline_readint( $thefile, $name_offset+2, 2 );
                $string_storage_offset = ImageHeadline_readint( $thefile, $name_offset+4, 2 );
                $name_id_offset = $name_offset + 12;
                
                // Let's find the name record that we desire. We're looking for a name ID
                // of 4.
                $name_string_offset = 0;
                $good_count = 0;
                $preferred = 0;
                for( $x = 0; ( $x < $num_names ) && !feof( $thefile ) /*&& ( $name_string_offset == 0 )*/; $x++ )
                {
                    $name_id = ImageHeadline_readint( $thefile, $name_id_offset, 2 );
                    if( $name_id == 4 )
                    {
                        $good_names[$good_count]["platform_id"] = ImageHeadline_readint( $thefile, $name_id_offset-6, 2 );
                        $good_names[$good_count]["encoding_id"] = ImageHeadline_readint( $thefile, $name_id_offset-4, 2 );
                        $good_names[$good_count]["language_id"] = ImageHeadline_readint( $thefile, $name_id_offset-2, 2 );

                        // Odd I know... we're searching for a Windows platform string with these
                        // precise parameters. It's the most common among fonts that I've seen. Not that this is a
                        // Unicode string so we'll have to deal with that rather naively below. The problem with
                        // the other formats is that many shareware/freeware fonts -- which a lot of people
                        // will probably use -- is that they're inconsistent with their string settings (like the
                        // bundled font... one of the strings is left at "Arial".
                        if( ( $good_names[$good_count]["platform_id"] == 3 ) && 
                            ( $good_names[$good_count]["encoding_id"] == 1 ) && 
                            ( $good_names[$good_count]["language_id"] == 1033 ) ) {
                            $preferred = $good_count;
                        }                            
                            
                        $good_names[$good_count]["string_length"] = ImageHeadline_readint( $thefile, $name_id_offset+2, 2 );
                        $good_names[$good_count++]["string_offset"] = ImageHeadline_readint( $thefile, $name_id_offset+4, 2 );
                    }                        
                    $name_id_offset += 12;
                }

                // Did we find one?
                if( $good_count )
                {
                    // This getting old yet? What a goofy file format, and PHP is far from the most
                    // efficient binary file parsers available. Anyway, we apparently have our string.
                    // Let's read out the damned thing and have done with it.
                    @fseek( $thefile, $name_offset + $string_storage_offset + $good_names[$preferred]["string_offset"], SEEK_SET );
                    $return_string = @fread( $thefile, $good_names[$preferred]["string_length"] );
                    for( $x = 0; $x < 32; $x++ )
                        $unicode_chars[] = chr($x);
                    $return_string = str_replace( $unicode_chars, "", $return_string );
                }
            }
            fclose( $thefile );
        }

        return $return_string;   
    }
}

if( !function_exists( 'ImageHeadline_clear_cache' ) )
{
    function ImageHeadline_clear_cache( $dirname, $lifetime )
    {
        if( ( $mydir = @opendir( $dirname ) ) !== false )
        {
            while( ( $file = @readdir( $mydir ) ) !== false )
            {
               if( preg_match("/[a-f0-9]{32}\.png/i", $file) ) 
               {
                   $difftime = ( time() - filectime( "$dirname/$file" ) ) / 60 / 60 / 24;
                   if( $difftime > $lifetime ) 
                   {
                       @unlink( "$dirname/$file" );
                   }
               }
            }
        }
    }
}

if( !function_exists( 'ImageHeadline_maybe_clear_cache' ) )
{
    function ImageHeadline_maybe_clear_cache( $dirname, $lifetime )
    {
        $clearit = false;

        // Determine if the cache needs clearing. We do this every 12 hours.
        if( file_exists( "$dirname/cache.info" ) )
        {
            $difftime = time() - filectime( "$dirname/cache.info" );
            if( $difftime > ( 12 * 60 * 60 ) )
            {
                $clearit = true;
                @touch( "$dirname/cache.info" );
            }
        }
        else
        {
            if( ( $file = @fopen( "$dirname/cache.info", "wb" ) ) !== false )
            {
                @fwrite( $file, "Hi there." );
                @fclose( $file );
            }
            $clearit = true;
        }

        if( $clearit ) 
        {
            ImageHeadline_clear_cache($dirname, $lifetime);
        }
    }
}
if( !function_exists( 'ImageHeadline_traverse_directory' ) )
{
    function ImageHeadline_traverse_directory($dirname, &$return_array)
    {
        $current_num = count($return_array);

        // Get a list of files in the directory.
        if( ($mydir = @opendir( $dirname )) !== false )
        {
            while(($file = readdir($mydir))!== false )
            {
                if ($file != "." && $file != "..")
                {
                    $font_name = ImageHeadline_get_ttf_font_name( $dirname."/".$file );
                    if( $font_name != '' )
                    {
                        $return_array[$current_num]["font_name"] = $font_name;
                        $return_array[$current_num++]["font_file"] = $dirname."/".$file;
                    }
                }
            }

            closedir($mydir);
        }
        return $current_num;
    }
}

if( !function_exists( 'ImageHeadline_get_fonts' ) )
{
    /* Returns an associative array of font file names and the corresponding font name */
    function ImageHeadline_get_fonts()
    {
        $num_fonts = 0;
        $return_array = Array();

        // Get a list of files in the directory. We'll also check the upload directory
        // since that's an easy place for WordPress administrators to put new files.
        ImageHeadline_traverse_directory( FONT_DIRECTORY, $return_array );
        ImageHeadline_traverse_directory( get_settings('fileupload_realpath'), $return_array );

        // For each supposed font file parse out a font name string.
        return $return_array;
    }
}

if( !function_exists( 'ImageHeadline_gaussian' ) ) {
    function ImageHeadline_gaussian( &$image, $width, $height, $spread )
    {
        $use_GD1 = ImageHeadline_option_set( 'only_use_imagecreate' );
        if( $use_GD1 )
            return;

        // Check for silly spreads
        if( $spread == 0 )
            return;

        if( $spread > 10 )
            $spread = 10;

        if( strlen( $memory_limit = trim(ini_get('memory_limit' )) ) > 0 )
        {
            $last = strtolower($memory_limit{strlen($memory_limit)-1});
            switch($last) {
                // The 'G' modifier is available since PHP 5.1.0
                case 'g':
                    $memory_limit *= 1024;
                case 'm':
                    $memory_limit *= 1024;
                case 'k':
                    $memory_limit *= 1024;
            }

            if( $memory_limit <= 8 * 1024 * 1024 )
            {
                $use_low_memory_method = true;
            }
            
        } else {
            $use_low_memory_method = false;
        }

        // Perform gaussian blur convlution. First, prepare the convolution 
        // kernel and precalculated multiplication array. Algorithm
        // adapted from the simply exceptional code by Mario Klingemann
        // <http://incubator.quasimondo.com>. Kernel is essentially an
        // approximation of a gaussian distribution by utilizing squares.
        $kernelsize = $spread*2-1;
        $kernel = array_fill( 0, $kernelsize, 0 );
        $mult = array_fill( 0, $kernelsize, array_fill( 0, 256, 0 ) );
        for( $i = 1; $i < $spread; $i++ )
        {
            $smi = $spread - $i;
            $kernel[$smi-1]=$kernel[$spread+$i-1]=$smi*$smi;
            for( $j = 0; $j < 256; $j++ )
            {
                $mult[$smi-1][$j] = $mult[$spread+$i-1][$j] = $kernel[$smi-1]*$j;
            }
        }
        $kernel[$spread-1]=$spread*$spread;
        for( $j = 0; $j < 256; $j++ )
        {
            $mult[$spread-1][$j] = $kernel[$spread-1]*$j;
        }

        if( !$use_low_memory_method ) {

            // Kernel and multiplication array calculated, let's get the image
            // read out into a usable format.
            $imagebytes = $width*$height;
            $i = 0;
            for( $x = 0; $x < $width; $x++ )
            {
                for( $y = 0; $y < $height; $y++ )
                {
                    $rgb = imagecolorat( $image, $x, $y );
                    $imagearray[$i++] = $rgb;
                }                
            }
        }
            
        // Everything's set. Let's run the first pass. Our first pass will be a 
        // vertical pass.
        for( $x = 0; $x < $width; $x++ )
        {
            for( $y = 0; $y < $height; $y++ )
            {
                $sum = 0;
                $cr = $cg = $cb = 0;
                for( $j = 0; $j < $kernelsize; $j++ )
                {
                    $kernely = $y + ( $j - ( $spread - 1 ) );
                    if( ( $kernely >= 0 ) && ( $kernely < $height ) )
                    {
                        if( !$use_low_memory_method ) {
                            $ci = ( $x * $height ) + $kernely;
                            $rgb = $imagearray[$ci];
                        } else {
                            $rgb = imagecolorat( $image, $x, $kernely );
                        }
                        $cr += $mult[$j][($rgb >> 16 ) & 0xFF];
                        $cg += $mult[$j][($rgb >> 8 ) & 0xFF];
                        $cb += $mult[$j][$rgb & 0xFF];
                        $sum += $kernel[$j];
                    }
                }
                $ci = ( $x * $height ) + $y;
                $shadowarray[$ci] = ( ( intval(round($cr/$sum)) & 0xff ) << 16 ) | ( ( intval(round($cg/$sum)) & 0xff ) << 8 ) | ( intval(round($cb/$sum)) & 0xff );
            }
        }            

        // Free up some memory
        if( isset( $imagearray ) ) {
            unset( $imagearray );
        }

        // Now let's make with the horizontal passing. That sentence
        // contruct never gets old: "make with the". Oh the humor.
        for( $x = 0; $x < $width; $x++ )
        {
            for( $y = 0; $y < $height; $y++ )
            {
                $sum = 0;
                $cr = $cg = $cb = 0;
                for( $j = 0; $j < $kernelsize; $j++ )
                {
                    $kernelx = $x + ( $j - ( $spread - 1 ) );
                    if( ( $kernelx >= 0 ) && ( $kernelx < $width ) )
                    {
                        $ci = ( $kernelx * $height ) + $y;
                        $cr += $mult[$j][($shadowarray[$ci] >> 16 ) & 0xFF];
                        $cg += $mult[$j][($shadowarray[$ci] >> 8 ) & 0xFF];
                        $cb += $mult[$j][$shadowarray[$ci] &