<?php

/**

 * WordPress API for media display.

 *

 * @package WordPress

 */

/**

 * Scale down the default size of an image.

 *

 * This is so that the image is a better fit for the editor and theme.

 *

 * The $size parameter accepts either an array or a string. The supported string

 * values are 'thumb' or 'thumbnail' for the given thumbnail size or defaults at

 * 128 width and 96 height in pixels. Also supported for the string value is

 * 'medium' and 'full'. The 'full' isn't actually supported, but any value other

 * than the supported will result in the content_width size or 500 if that is

 * not set.

 *

 * Finally, there is a filter named, 'editor_max_image_size' that will be called

 * on the calculated array for width and height, respectively. The second

 * parameter will be the value that was in the $size parameter. The returned

 * type for the hook is an array with the width as the first element and the

 * height as the second element.

 *

 * @since 2.5.0

 * @uses wp_constrain_dimensions() This function passes the widths and the heights.

 *

 * @param int $width Width of the image

 * @param int $height Height of the image

 * @param string|array $size Size of what the result image should be.

 * @return array Width and height of what the result image should resize to.

 */

function image_constrain_size_for_editor($width, $height, $size = 'medium') {

	global $content_width;

	if ( is_array($size) ) {

		$max_width = $size[0];

		$max_height = $size[1];

	}

	elseif ( $size == 'thumb' || $size == 'thumbnail' ) {

		$max_width = intval(get_option('thumbnail_size_w'));

		$max_height = intval(get_option('thumbnail_size_h'));

		// last chance thumbnail size defaults

		if ( !$max_width && !$max_height ) {

			$max_width = 128;

			$max_height = 96;

		}

	}

	elseif ( $size == 'medium' ) {

		$max_width = intval(get_option('medium_size_w'));

		$max_height = intval(get_option('medium_size_h'));

		// if no width is set, default to the theme content width if available

	}

	elseif ( $size == 'large' ) {

		// we're inserting a large size image into the editor.  if it's a really

		// big image we'll scale it down to fit reasonably within the editor

		// itself, and within the theme's content width if it's known.  the user

		// can resize it in the editor if they wish.

		$max_width = intval(get_option('large_size_w'));

		$max_height = intval(get_option('large_size_h'));

		if ( intval($content_width) > 0 )

			$max_width = min( intval($content_width), $max_width );

	}

	// $size == 'full' has no constraint

	else {

		$max_width = $width;

		$max_height = $height;

	}

	list( $max_width, $max_height ) = apply_filters( 'editor_max_image_size', array( $max_width, $max_height ), $size );

	return wp_constrain_dimensions( $width, $height, $max_width, $max_height );

}

/**

 * Retrieve width and height attributes using given width and height values.

 *

 * Both attributes are required in the sense that both parameters must have a

 * value, but are optional in that if you set them to false or null, then they

 * will not be added to the returned string.

 *

 * You can set the value using a string, but it will only take numeric values.

 * If you wish to put 'px' after the numbers, then it will be stripped out of

 * the return.

 *

 * @since 2.5.0

 *

 * @param int|string $width Optional. Width attribute value.

 * @param int|string $height Optional. Height attribute value.

 * @return string HTML attributes for width and, or height.

 */

function image_hwstring($width, $height) {

	$out = '';

	if ($width)

		$out .= 'width="'.intval($width).'" ';

	if ($height)

		$out .= 'height="'.intval($height).'" ';

	return $out;

}

/**

 * Scale an image to fit a particular size (such as 'thumb' or 'medium').

 *

 * Array with image url, width, height, and whether is intermediate size, in

 * that order is returned on success is returned. $is_intermediate is true if

 * $url is a resized image, false if it is the original.

 *

 * The URL might be the original image, or it might be a resized version. This

 * function won't create a new resized copy, it will just return an already

 * resized one if it exists.

 *

 * A plugin may use the 'image_downsize' filter to hook into and offer image

 * resizing services for images. The hook must return an array with the same

 * elements that are returned in the function. The first element being the URL

 * to the new image that was resized.

 *

 * @since 2.5.0

 * @uses apply_filters() Calls 'image_downsize' on $id and $size to provide

 *		resize services.

 *

 * @param int $id Attachment ID for image.

 * @param string $size Optional, default is 'medium'. Size of image, can be 'thumbnail'.

 * @return bool|array False on failure, array on success.

 */

function image_downsize($id, $size = 'medium') {

	if ( !wp_attachment_is_image($id) )

		return false;

	$img_url = wp_get_attachment_url($id);

	$meta = wp_get_attachment_metadata($id);

	$width = $height = 0;

	$is_intermediate = false;

	// plugins can use this to provide resize services

	if ( $out = apply_filters('image_downsize', false, $id, $size) )

		return $out;

	// try for a new style intermediate size

	if ( $intermediate = image_get_intermediate_size($id, $size) ) {

		$img_url = str_replace(basename($img_url), $intermediate['file'], $img_url);

		$width = $intermediate['width'];

		$height = $intermediate['height'];

		$is_intermediate = true;

	}

	elseif ( $size == 'thumbnail' ) {

		// fall back to the old thumbnail

		if ( ($thumb_file = wp_get_attachment_thumb_file($id)) && $info = getimagesize($thumb_file) ) {

			$img_url = str_replace(basename($img_url), basename($thumb_file), $img_url);

			$width = $info[0];

			$height = $info[1];

			$is_intermediate = true;

		}

	}

	if ( !$width && !$height && isset($meta['width'], $meta['height']) ) {

		// any other type: use the real image

		$width = $meta['width'];

		$height = $meta['height'];

	}

	if ( $img_url) {

		// we have the actual image size, but might need to further constrain it if content_width is narrower

		list( $width, $height ) = image_constrain_size_for_editor( $width, $height, $size );

		return array( $img_url, $width, $height, $is_intermediate );

	}

	return false;

}

/**

 * An <img src /> tag for an image attachment, scaling it down if requested.

 *

 * The filter 'get_image_tag_class' allows for changing the class name for the

 * image without having to use regular expressions on the HTML content. The

 * parameters are: what WordPress will use for the class, the Attachment ID,

 * image align value, and the size the image should be.

 *

 * The second filter 'get_image_tag' has the HTML content, which can then be

 * further manipulated by a plugin to change all attribute values and even HTML

 * content.

 *

 * @since 2.5.0

 *

 * @uses apply_filters() The 'get_image_tag_class' filter is the IMG element

 *		class attribute.

 * @uses apply_filters() The 'get_image_tag' filter is the full IMG element with

 *		all attributes.

 *

 * @param int $id Attachment ID.

 * @param string $alt Image Description for the alt attribute.

 * @param string $title Image Description for the title attribute.

 * @param string $align Part of the class name for aligning the image.

 * @param string $size Optional. Default is 'medium'.

 * @return string HTML IMG element for given image attachment

 */

function get_image_tag($id, $alt, $title, $align, $size='medium') {

	list( $img_src, $width, $height ) = image_downsize($id, $size);

	$hwstring = image_hwstring($width, $height);

	$class = 'align' . esc_attr($align) .' size-' . esc_attr($size) . ' wp-image-' . $id;

	$class = apply_filters('get_image_tag_class', $class, $id, $align, $size);

	$html = '<img src="' . esc_attr($img_src) . '" alt="' . esc_attr($alt) . '" title="' . esc_attr($title).'" '.$hwstring.'class="'.$class.'" />';

	$html = apply_filters( 'get_image_tag', $html, $id, $alt, $title, $align, $size );

	return $html;

}

/**

 * Calculates the new dimentions for a downsampled image.

 *

 * Same as {@link wp_shrink_dimensions()}, except the max parameters are

 * optional. If either width or height are empty, no constraint is applied on

 * that dimension.

 *

 * @since 2.5.0

 *

 * @param int $current_width Current width of the image.

 * @param int $current_height Current height of the image.

 * @param int $max_width Optional. Maximum wanted width.

 * @param int $max_height Optional. Maximum wanted height.

 * @return array First item is the width, the second item is the height.

 */

function wp_constrain_dimensions( $current_width, $current_height, $max_width=0, $max_height=0 ) {

	if ( !$max_width and !$max_height )

		return array( $current_width, $current_height );

	$width_ratio = $height_ratio = 1.0;

	if ( $max_width > 0 && $current_width > 0 && $current_width > $max_width )

		$width_ratio = $max_width / $current_width;

	if ( $max_height > 0 && $current_height > 0 && $current_height > $max_height )

		$height_ratio = $max_height / $current_height;

	// the smaller ratio is the one we need to fit it to the constraining box

	$ratio = min( $width_ratio, $height_ratio );

	return array( intval($current_width * $ratio), intval($current_height * $ratio) );

}

/**

 * Retrieve calculated resized dimensions for use in imagecopyresampled().

 *

 * Calculate dimensions and coordinates for a resized image that fits within a

 * specified width and height. If $crop is true, the largest matching central

 * portion of the image will be cropped out and resized to the required size.

 *

 * @since 2.5.0

 *

 * @param int $orig_w Original width.

 * @param int $orig_h Original height.

 * @param int $dest_w New width.

 * @param int $dest_h New height.

 * @param bool $crop Optional, default is false. Whether to crop image or resize.

 * @return bool|array False, on failure. Returned array matches parameters for imagecopyresampled() PHP function.

 */

function image_resize_dimensions($orig_w, $orig_h, $dest_w, $dest_h, $crop=false) {

	if ($orig_w <= 0 || $orig_h <= 0)

		return false;

	// at least one of dest_w or dest_h must be specific

	if ($dest_w <= 0 && $dest_h <= 0)

		return false;

	if ( $crop ) {

		// crop the largest possible portion of the original image that we can size to $dest_w x $dest_h

		$aspect_ratio = $orig_w / $orig_h;

		$new_w = min($dest_w, $orig_w);

		$new_h = min($dest_h, $orig_h);

		if (!$new_w) {

			$new_w = intval($new_h * $aspect_ratio);

		}

		if (!$new_h) {

			$new_h = intval($new_w / $aspect_ratio);

		}

		$size_ratio = max($new_w / $orig_w, $new_h / $orig_h);

		$crop_w = ceil($new_w / $size_ratio);

		$crop_h = ceil($new_h / $size_ratio);

		$s_x = floor(($orig_w - $crop_w)/2);

		$s_y = floor(($orig_h - $crop_h)/2);

	}

	else {

		// don't crop, just resize using $dest_w x $dest_h as a maximum bounding box

		$crop_w = $orig_w;

		$crop_h = $orig_h;

		$s_x = 0;

		$s_y = 0;

		list( $new_w, $new_h ) = wp_constrain_dimensions( $orig_w, $orig_h, $dest_w, $dest_h );

	}

	// if the resulting image would be the same size or larger we don't want to resize it

	if ($new_w >= $orig_w && $new_h >= $orig_h)

		return false;

	// the return array matches the parameters to imagecopyresampled()

	// int dst_x, int dst_y, int src_x, int src_y, int dst_w, int dst_h, int src_w, int src_h

	return array(0, 0, $s_x, $s_y, $new_w, $new_h, $crop_w, $crop_h);

}

/**

 * Scale down an image to fit a particular size and save a new copy of the image.

 *

 * The PNG transparency will be preserved using the function, as well as the

 * image type. If the file going in is PNG, then the resized image is going to

 * be PNG. The only supported image types are PNG, GIF, and JPEG.

 *

 * Some functionality requires API to exist, so some PHP version may lose out

 * support. This is not the fault of WordPress (where functionality is

 * downgraded, not actual defects), but of your PHP version.

 *

 * @since 2.5.0

 *

 * @param string $file Image file path.

 * @param int $max_w Maximum width to resize to.

 * @param int $max_h Maximum height to resize to.

 * @param bool $crop Optional. Whether to crop image or resize.

 * @param string $suffix Optional. File Suffix.

 * @param string $dest_path Optional. New image file path.

 * @param int $jpeg_quality Optional, default is 90. Image quality percentage.

 * @return mixed WP_Error on failure. String with new destination path. Array of dimensions from {@link image_resize_dimensions()}

 */

function image_resize( $file, $max_w, $max_h, $crop=false, $suffix=null, $dest_path=null, $jpeg_quality=90) {

	$image = wp_load_image( $file );

	if ( !is_resource( $image ) )

		return new WP_Error('error_loading_image', $image);

	list($orig_w, $orig_h, $orig_type) = getimagesize( $file );

	$dims = image_resize_dimensions($orig_w, $orig_h, $max_w, $max_h, $crop);

	if (!$dims)

		return $dims;

	list($dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) = $dims;

	$newimage = imagecreatetruecolor( $dst_w, $dst_h);

	// preserve PNG transparency

	if ( IMAGETYPE_PNG == $orig_type && function_exists( 'imagealphablending' ) && function_exists( 'imagesavealpha' ) ) {

		imagealphablending( $newimage, false);

		imagesavealpha( $newimage, true);

	}

	imagecopyresampled( $newimage, $image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h);

	// we don't need the original in memory anymore

	imagedestroy( $image );

	// $suffix will be appended to the destination filename, just before the extension

	if ( !$suffix )

		$suffix = "{$dst_w}x{$dst_h}";

	$info = pathinfo($file);

	$dir = $info['dirname'];

	$ext = $info['extension'];

	$name = basename($file, ".{$ext}");

	if ( !is_null($dest_path) and $_dest_path = realpath($dest_path) )

		$dir = $_dest_path;

	$destfilename = "{$dir}/{$name}-{$suffix}.{$ext}";

	if ( $orig_type == IMAGETYPE_GIF ) {

		if (!imagegif( $newimage, $destfilename ) )

			return new WP_Error('resize_path_invalid', __( 'Resize path invalid' ));

	}

	elseif ( $orig_type == IMAGETYPE_PNG ) {

		if (!imagepng( $newimage, $destfilename ) )

			return new WP_Error('resize_path_invalid', __( 'Resize path invalid' ));

	}

	else {

		// all other formats are converted to jpg

		$destfilename = "{$dir}/{$name}-{$suffix}.jpg";

		if (!imagejpeg( $newimage, $destfilename, apply_filters( 'jpeg_quality', $jpeg_quality, 'image_resize' ) ) )

			return new WP_Error('resize_path_invalid', __( 'Resize path invalid' ));

	}

	imagedestroy( $newimage );

	// Set correct file permissions

	$stat = stat( dirname( $destfilename ));

	$perms = $stat['mode'] & 0000666; //same permissions as parent folder, strip off the executable bits

	@ chmod( $destfilename, $perms );

	return $destfilename;

}

/**

 * Resize an image to make a thumbnail or intermediate size.

 *

 * The returned array has the file size, the image width, and image height. The

 * filter 'image_make_intermediate_size' can be used to hook in and change the

 * values of the returned array. The only parameter is the resized file path.

 *

 * @since 2.5.0

 *

 * @param string $file File path.

 * @param int $width Image width.

 * @param int $height Image height.

 * @param bool $crop Optional, default is false. Whether to crop image to specified height and width or resize.

 * @return bool|array False, if no image was created. Metadata array on success.

 */

function image_make_intermediate_size($file, $width, $height, $crop=false) {

	if ( $width || $height ) {

		$resized_file = image_resize($file, $width, $height, $crop);

		if ( !is_wp_error($resized_file) && $resized_file && $info = getimagesize($resized_file) ) {

			$resized_file = apply_filters('image_make_intermediate_size', $resized_file);

			return array(

				'file' => basename( $resized_file ),

				'width' => $info[0],

				'height' => $info[1],

			);

		}

	}

	return false;

}