site_iri: comparison web/wp-includes/media.php

equal deleted inserted replaced

-:2f6f6f7551ca
+:32102edaa81b
 * 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
+* 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.
 *
 		$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
+		// 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
+		// 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 );
 	} elseif ( isset( $_wp_additional_image_sizes ) && count( $_wp_additional_image_sizes ) && in_array( $size, array_keys( $_wp_additional_image_sizes ) ) ) {
 		$max_width = intval( $_wp_additional_image_sizes[$size]['width'] );
 		$max_height = intval( $_wp_additional_image_sizes[$size]['height'] );
-		if ( intval($content_width) > 0 )
+		if ( intval($content_width) > 0 && is_admin() ) // Only in admin. Assume that theme authors know what they're doing.
 			$max_width = min( intval($content_width), $max_width );
 	}
 	// $size == 'full' has no constraint
 	else {
 		$max_width = $width;
 * @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'.
+* @param array|string $size Optional, default is 'medium'. Size of image, either array or string.
 * @return bool|array False on failure, array on success.
 */
 function image_downsize($id, $size = 'medium') {
 	if ( !wp_attachment_is_image($id) )
 	$img_url = wp_get_attachment_url($id);
 	$meta = wp_get_attachment_metadata($id);
 	$width = $height = 0;
 	$is_intermediate = false;
+	$img_url_basename = wp_basename($img_url);
 	// 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);
+		$img_url = str_replace($img_url_basename, $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);
+			$img_url = str_replace($img_url_basename, wp_basename($thumb_file), $img_url);
 			$width = $info[0];
 			$height = $info[1];
 			$is_intermediate = true;
 		}
 	}
 }
 /**
 * Registers a new image size
-*/
+*
-function add_image_size( $name, $width = 0, $height = 0, $crop = FALSE ) {
+* @since 2.9.0
+*/
+function add_image_size( $name, $width = 0, $height = 0, $crop = false ) {
 	global $_wp_additional_image_sizes;
-	$_wp_additional_image_sizes[$name] = array( 'width' => absint( $width ), 'height' => absint( $height ), 'crop' => !!$crop );
+	$_wp_additional_image_sizes[$name] = array( 'width' => absint( $width ), 'height' => absint( $height ), 'crop' => (bool) $crop );
 }
 /**
 * Registers an image size for the post thumbnail
-*/
+*
-function set_post_thumbnail_size( $width = 0, $height = 0, $crop = FALSE ) {
+* @since 2.9.0
+*/
+function set_post_thumbnail_size( $width = 0, $height = 0, $crop = false ) {
 	add_image_size( 'post-thumbnail', $width, $height, $crop );
 }
 /**
 * An <img src /> tag for an image attachment, scaling it down if requested.
 	return $html;
 }
 /**
-* Calculates the new dimentions for a downsampled image.
+* Load an image from a string, if PHP supports it.
 *
-* Same as {@link wp_shrink_dimensions()}, except the max parameters are
+* @since 2.1.0
-* optional. If either width or height are empty, no constraint is applied on
+*
+* @param string $file Filename of the image to load.
+* @return resource The resulting image resource on success, Error string on failure.
+*/
+function wp_load_image( $file ) {
+	if ( is_numeric( $file ) )
+		$file = get_attached_file( $file );
+	if ( ! file_exists( $file ) )
+		return sprintf(__('File &#8220;%s&#8221; doesn&#8217;t exist?'), $file);
+	if ( ! function_exists('imagecreatefromstring') )
+		return __('The GD image library is not installed.');
+	// Set artificially high because GD uses uncompressed images in memory
+	@ini_set( 'memory_limit', apply_filters( 'image_memory_limit', WP_MAX_MEMORY_LIMIT ) );
+	$image = imagecreatefromstring( file_get_contents( $file ) );
+	if ( !is_resource( $image ) )
+		return sprintf(__('File &#8220;%s&#8221; is not an image.'), $file);
+	return $image;
+}
+/**
+* Calculates the new dimensions for a downsampled image.
+*
+* 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.
 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;
+	$did_width = $did_height = false;
-	if ( $max_width > 0 && $current_width > 0 && $current_width > $max_width )
+	if ( $max_width > 0 && $current_width > 0 && $current_width > $max_width ) {
 		$width_ratio = $max_width / $current_width;
+		$did_width = true;
-	if ( $max_height > 0 && $current_height > 0 && $current_height > $max_height )
+	}
+	if ( $max_height > 0 && $current_height > 0 && $current_height > $max_height ) {
 		$height_ratio = $max_height / $current_height;
+		$did_height = true;
-	// the smaller ratio is the one we need to fit it to the constraining box
+	}
-	$ratio = min( $width_ratio, $height_ratio );
+	// Calculate the larger/smaller ratios
-	return array( intval($current_width * $ratio), intval($current_height * $ratio) );
+	$smaller_ratio = min( $width_ratio, $height_ratio );
+	$larger_ratio  = max( $width_ratio, $height_ratio );
+	if ( intval( $current_width * $larger_ratio ) > $max_width || intval( $current_height * $larger_ratio ) > $max_height )
+		// The larger ratio is too big. It would result in an overflow.
+		$ratio = $smaller_ratio;
+	else
+		// The larger ratio fits, and is likely to be a more "snug" fit.
+		$ratio = $larger_ratio;
+	$w = intval( $current_width  * $ratio );
+	$h = intval( $current_height * $ratio );
+	// Sometimes, due to rounding, we'll end up with a result like this: 465x700 in a 177x177 box is 117x176... a pixel short
+	// We also have issues with recursive calls resulting in an ever-changing result. Constraining to the result of a constraint should yield the original result.
+	// Thus we look for dimensions that are one pixel shy of the max value and bump them up
+	if ( $did_width && $w == $max_width - 1 )
+		$w = $max_width; // Round it up
+	if ( $did_height && $h == $max_height - 1 )
+		$h = $max_height; // Round it up
+	return array( $w, $h );
 }
 /**
 * 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
+* @uses apply_filters() Calls 'image_resize_dimensions' on $orig_w, $orig_h, $dest_w, $dest_h and
+*		$crop to provide custom resize dimensions.
 *
 * @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.
+* @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;
+	// plugins can use this to provide custom resize dimensions
+	$output = apply_filters( 'image_resize_dimensions', null, $orig_w, $orig_h, $dest_w, $dest_h, $crop );
+	if ( null !== $output )
+		return $output;
 	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);
 *
 * @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 $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()}
+* @return mixed WP_Error on failure. String with new destination path.
 */
 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);
+		return new WP_Error( 'error_loading_image', $image, $file );
 	$size = @getimagesize( $file );
 	if ( !$size )
 		return new WP_Error('invalid_image', __('Could not read image size'), $file);
 	list($orig_w, $orig_h, $orig_type) = $size;
 	$dims = image_resize_dimensions($orig_w, $orig_h, $max_w, $max_h, $crop);
 	if ( !$dims )
-		return $dims;
+		return new WP_Error( 'error_getting_dimensions', __('Could not calculate resized image dimensions') );
 	list($dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) = $dims;
 	$newimage = wp_imagecreatetruecolor( $dst_w, $dst_h );
 	imagecopyresampled( $newimage, $image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h);
 	// convert from full colors to index colors, like original PNG.
-	if ( IMAGETYPE_PNG == $orig_type && !imageistruecolor( $image ) )
+	if ( IMAGETYPE_PNG == $orig_type && function_exists('imageistruecolor') && !imageistruecolor( $image ) )
 		imagetruecolortopalette( $newimage, false, imagecolorstotal( $image ) );
 	// we don't need the original in memory anymore
 	imagedestroy( $image );
 		$suffix = "{$dst_w}x{$dst_h}";
 	$info = pathinfo($file);
 	$dir = $info['dirname'];
 	$ext = $info['extension'];
-	$name = basename($file, ".{$ext}");
+	$name = wp_basename($file, ".$ext");
 	if ( !is_null($dest_path) and $_dest_path = realpath($dest_path) )
 		$dir = $_dest_path;
 	$destfilename = "{$dir}/{$name}-{$suffix}.{$ext}";
 	if ( IMAGETYPE_GIF == $orig_type ) {
 	} elseif ( IMAGETYPE_PNG == $orig_type ) {
 		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 ( 'jpg' != $ext && 'jpeg' != $ext )
+			$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 );
 	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 ),
+				'file' => wp_basename( $resized_file ),
 				'width' => $info[0],
 				'height' => $info[1],
 			);
 		}
 	}
 * The metadata 'sizes' is used for compatible sizes that can be used for the
 * parameter $size value.
 *
 * The url path will be given, when the $size parameter is a string.
 *
+* If you are passing an array for the $size, you should consider using
+* add_image_size() so that a cropped version is generated. It's much more
+* efficient than having to find the closest-sized image and then having the
+* browser scale down the image.
+*
 * @since 2.5.0
+* @see add_image_size()
 *
 * @param int $post_id Attachment ID for image.
 * @param array|string $size Optional, default is 'thumbnail'. Size of image, either array or string.
 * @return bool|array False on failure or array of file path, width, and height on success.
 */
 			// find for the smallest image not smaller than the desired size
 			ksort($areas);
 			foreach ( $areas as $_size ) {
 				$data = $imagedata['sizes'][$_size];
 				if ( $data['width'] >= $size[0] || $data['height'] >= $size[1] ) {
+					// Skip images with unexpectedly divergent aspect ratios (crops)
+					// First, we calculate what size the original image would be if constrained to a box the size of the current image in the loop
+					$maybe_cropped = image_resize_dimensions($imagedata['width'], $imagedata['height'], $data['width'], $data['height'], false );
+					// If the size doesn't match within one pixel, then it is of a different aspect ratio, so we skip it, unless it's the thumbnail size
+					if ( 'thumbnail' != $_size && ( !$maybe_cropped || ( $maybe_cropped[4] != $data['width'] && $maybe_cropped[4] + 1 != $data['width'] ) || ( $maybe_cropped[5] != $data['height'] && $maybe_cropped[5] + 1 != $data['height'] ) ) )
+						continue;
+					// If we're still here, then we're going to use this size
 					$file = $data['file'];
 					list($width, $height) = image_constrain_size_for_editor( $data['width'], $data['height'], $size );
 					return compact( 'file', 'width', 'height' );
 				}
 			}
 	}
 	return $data;
 }
 /**
+* Get the available image sizes
+* @since 3.0.0
+* @return array Returns a filtered array of image size strings
+*/
+function get_intermediate_image_sizes() {
+	global $_wp_additional_image_sizes;
+	$image_sizes = array('thumbnail', 'medium', 'large'); // Standard sizes
+	if ( isset( $_wp_additional_image_sizes ) && count( $_wp_additional_image_sizes ) )
+		$image_sizes = array_merge( $image_sizes, array_keys( $_wp_additional_image_sizes ) );
+	return apply_filters( 'intermediate_image_sizes', $image_sizes );
+}
+/**
 * Retrieve an image to represent an attachment.
 *
 * A mime icon for files, thumbnail or intermediate size for images.
 *
 * @since 2.5.0
 	$src = false;
 	if ( $icon && $src = wp_mime_type_icon($attachment_id) ) {
 		$icon_dir = apply_filters( 'icon_dir', ABSPATH . WPINC . '/images/crystal' );
-		$src_file = $icon_dir . '/' . basename($src);
+		$src_file = $icon_dir . '/' . wp_basename($src);
 		@list($width, $height) = getimagesize($src_file);
 	}
 	if ( $src && $width && $height )
 		return array( $src, $width, $height );
 	return false;
 }
 /**
 * Get an HTML img element representing an image attachment
 *
+* While $size will accept an array, it is better to register a size with
+* add_image_size() so that a cropped version is generated. It's much more
+* efficient than having to find the closest-sized image and then having the
+* browser scale down the image.
+*
+* @see add_image_size()
 * @uses apply_filters() Calls 'wp_get_attachment_image_attributes' hook on attributes array
 * @uses wp_get_attachment_image_src() Gets attachment file URL and dimensions
 * @since 2.5.0
 *
 * @param int $attachment_id Image attachment ID.
 			$size = join('x', $size);
 		$attachment =& get_post($attachment_id);
 		$default_attr = array(
 			'src'	=> $src,
 			'class'	=> "attachment-$size",
-			'alt'	=> trim(strip_tags( $attachment->post_excerpt )),
+			'alt'	=> trim(strip_tags( get_post_meta($attachment_id, '_wp_attachment_image_alt', true) )), // Use Alt field first
 			'title'	=> trim(strip_tags( $attachment->post_title )),
 		);
+		if ( empty($default_attr['alt']) )
+			$default_attr['alt'] = trim(strip_tags( $attachment->post_excerpt )); // If not, Use the Caption
+		if ( empty($default_attr['alt']) )
+			$default_attr['alt'] = trim(strip_tags( $attachment->post_title )); // Finally, use the title
 		$attr = wp_parse_args($attr, $default_attr);
 		$attr = apply_filters( 'wp_get_attachment_image_attributes', $attr, $attachment );
 		$attr = array_map( 'esc_attr', $attr );
 		$html = rtrim("<img $hwstring");
 		foreach ( $attr as $name => $value ) {
 	return $html;
 }
 /**
-* Adds a 'wp-post-image' class to post thumbnail thumbnails
+* Adds a 'wp-post-image' class to post thumbnails
 * Uses the begin_fetch_post_thumbnail_html and end_fetch_post_thumbnail_html action hooks to
-* dynamically add/remove itself so as to only filter post thumbnail thumbnails
+* dynamically add/remove itself so as to only filter post thumbnails
 *
-* @author Mark Jaquith
 * @since 2.9.0
 * @param array $attr Attributes including src, class, alt, title
 * @return array
 */
 function _wp_post_thumbnail_class_filter( $attr ) {
 }
 /**
 * Adds _wp_post_thumbnail_class_filter to the wp_get_attachment_image_attributes filter
 *
-* @author Mark Jaquith
 * @since 2.9.0
 */
 function _wp_post_thumbnail_class_filter_add( $attr ) {
 	add_filter( 'wp_get_attachment_image_attributes', '_wp_post_thumbnail_class_filter' );
 }
 /**
 * Removes _wp_post_thumbnail_class_filter from the wp_get_attachment_image_attributes filter
 *
-* @author Mark Jaquith
 * @since 2.9.0
 */
 function _wp_post_thumbnail_class_filter_remove( $attr ) {
 	remove_filter( 'wp_get_attachment_image_attributes', '_wp_post_thumbnail_class_filter' );
 }
 * @param array $attr Attributes attributed to the shortcode.
 * @param string $content Optional. Shortcode content.
 * @return string
 */
 function img_caption_shortcode($attr, $content = null) {
+	// New-style shortcode with the caption inside the shortcode with the link and image tags.
+	if ( ! isset( $attr['caption'] ) ) {
+		if ( preg_match( '#((?:<a [^>]+>\s*)?<img [^>]+>(?:\s*</a>)?)(.*)#is', $content, $matches ) ) {
+			$content = $matches[1];
+			$attr['caption'] = trim( $matches[2] );
+		}
+	}
 	// Allow plugins/themes to override the default caption template.
 	$output = apply_filters('img_caption_shortcode', '', $attr, $content);
 	if ( $output != '' )
 		return $output;
 * This implements the functionality of the Gallery Shortcode for displaying
 * WordPress images on a post.
 *
 * @since 2.5.0
 *
-* @param array $attr Attributes attributed to the shortcode.
+* @param array $attr Attributes of the shortcode.
 * @return string HTML content to display gallery.
 */
 function gallery_shortcode($attr) {
-	global $post, $wp_locale;
+	global $post;
 	static $instance = 0;
 	$instance++;
 	// Allow plugins/themes to override the default gallery template.
 	$itemtag = tag_escape($itemtag);
 	$captiontag = tag_escape($captiontag);
 	$columns = intval($columns);
 	$itemwidth = $columns > 0 ? floor(100/$columns) : 100;
-	$float = $wp_locale->text_direction == 'rtl' ? 'right' : 'left';
+	$float = is_rtl() ? 'right' : 'left';
 	$selector = "gallery-{$instance}";
-	$output = apply_filters('gallery_style', "
+	$gallery_style = $gallery_div = '';
+	if ( apply_filters( 'use_default_gallery_style', true ) )
+		$gallery_style = "
 		<style type='text/css'>
 			#{$selector} {
 				margin: auto;
 			}
 			#{$selector} .gallery-item {
 				float: {$float};
 				margin-top: 10px;
 				text-align: center;
-				width: {$itemwidth}%;			}
+				width: {$itemwidth}%;
+			}
 			#{$selector} img {
 				border: 2px solid #cfcfcf;
 			}
 			#{$selector} .gallery-caption {
 				margin-left: 0;
 			}
 		</style>
-		<!-- see gallery_shortcode() in wp-includes/media.php -->
+		<!-- see gallery_shortcode() in wp-includes/media.php -->";
-		<div id='$selector' class='gallery galleryid-{$id}'>");
+	$size_class = sanitize_html_class( $size );
+	$gallery_div = "<div id='$selector' class='gallery galleryid-{$id} gallery-columns-{$columns} gallery-size-{$size_class}'>";
+	$output = apply_filters( 'gallery_style', $gallery_style . "\n\t\t" . $gallery_div );
 	$i = 0;
 	foreach ( $attachments as $id => $attachment ) {
 		$link = isset($attr['link']) && 'file' == $attr['link'] ? wp_get_attachment_link($id, $size, false, false) : wp_get_attachment_link($id, $size, true, false);
 			<{$icontag} class='gallery-icon'>
 				$link
 			</{$icontag}>";
 		if ( $captiontag && trim($attachment->post_excerpt) ) {
 			$output .= "
-				<{$captiontag} class='gallery-caption'>
+				<{$captiontag} class='wp-caption-text gallery-caption'>
 				" . wptexturize($attachment->post_excerpt) . "
 				</{$captiontag}>";
 		}
 		$output .= "</{$itemtag}>";
 		if ( $columns > 0 && ++$i % $columns == 0 )
 *
 * Retrieves the current attachment object from the $post global.
 *
 * @since 2.5.0
 *
-* @param bool $prev Optional. Default is true to display previous link, true for next.
+* @param bool $prev Optional. Default is true to display previous link, false for next.
 */
 function adjacent_image_link($prev = true, $size = 'thumbnail', $text = false) {
 	global $post;
 	$post = get_post($post);
 	$attachments = array_values(get_children( array('post_parent' => $post->post_parent, 'post_status' => 'inherit', 'post_type' => 'attachment', 'post_mime_type' => 'image', 'order' => 'ASC', 'orderby' => 'menu_order ID') ));
 /**
 * Check if the installed version of GD supports particular image type
 *
 * @since 2.9.0
 *
-* @param $mime_type string
+* @param string $mime_type
 * @return bool
 */
 function gd_edit_image_support($mime_type) {
 	if ( function_exists('imagetypes') ) {
 		switch( $mime_type ) {
 /**
 * Create new GD image resource with transparency support
 *
 * @since 2.9.0
 *
-* @param $width
+* @param int $width Image width
-* @param $height
+* @param int $height Image height
 * @return image resource
 */
 function wp_imagecreatetruecolor($width, $height) {
 	$img = imagecreatetruecolor($width, $height);
 	if ( is_resource($img) && function_exists('imagealphablending') && function_exists('imagesavealpha') ) {
 	var $post_ID;
 	var $usecache = true;
 	var $linkifunknown = true;
 	/**
-	 * PHP4 constructor
+	 * Constructor
-	 */
-	function WP_Embed() {
-		return $this->__construct();
-	}
-	/**
-	 * PHP5 constructor
 	 */
 	function __construct() {
 		// Hack to get the [embed] shortcode to run before wpautop()
 		add_filter( 'the_content', array(&$this, 'run_shortcode'), 8 );
+		// Shortcode placeholder for strip_shortcodes()
+		add_shortcode( 'embed', '__return_false' );
 		// Attempts to embed all URLs in a post
 		if ( get_option('embed_autourls') )
 			add_filter( 'the_content', array(&$this, 'autoembed'), 8 );
 	 * @return string Content with shortcode parsed
 	 */
 	function run_shortcode( $content ) {
 		global $shortcode_tags;
-		// Backup current registered shortcodes and clear them all out
+		// Back up current registered shortcodes and clear them all out
 		$orig_shortcode_tags = $shortcode_tags;
 		remove_all_shortcodes();
 		add_shortcode( 'embed', array(&$this, 'shortcode') );
 		return $content;
 	}
 	/**
-	 * If a post/page was saved, then output Javascript to make
+	 * If a post/page was saved, then output JavaScript to make
 	 * an AJAX request that will call WP_Embed::cache_oembed().
 	 */
 	function maybe_run_ajax_cache() {
 		global $post_ID;
 ?>
 <script type="text/javascript">
 /* <![CDATA[ */
 	jQuery(document).ready(function($){
-		$.get("<?php echo admin_url( 'admin-ajax.php?action=oembed-cache&post=' . $post_ID ); ?>");
+		$.get("<?php echo admin_url( 'admin-ajax.php?action=oembed-cache&post=' . $post_ID, 'relative' ); ?>");
 	});
 /* ]]> */
 </script>
 <?php
 	}
 	 * @uses wp_cache_set()
 	 * @uses get_post_meta()
 	 * @uses update_post_meta()
 	 *
 	 * @param array $attr Shortcode attributes.
-	 * @param string $url The URL attempting to be embeded.
+	 * @param string $url The URL attempting to be embedded.
 	 * @return string The embed HTML on success, otherwise the original URL.
 	 */
 	function shortcode( $attr, $url = '' ) {
 		global $post;
 		if ( empty($url) )
 			return '';
 		$rawattr = $attr;
 		$attr = wp_parse_args( $attr, wp_embed_defaults() );
+		// kses converts & into &amp; and we need to undo this
+		// See http://core.trac.wordpress.org/ticket/11311
+		$url = str_replace( '&amp;', '&', $url );
 		// Look for known internal handlers
 		ksort( $this->handlers );
 		foreach ( $this->handlers as $priority => $handlers ) {
 			foreach ( $handlers as $id => $handler ) {
 				// Failures are cached
 				if ( '{{unknown}}' === $cache )
 					return $this->maybe_make_link( $url );
 				if ( !empty($cache) )
-					return apply_filters( 'embed_oembed_html', $cache, $url, $attr );
+					return apply_filters( 'embed_oembed_html', $cache, $url, $attr, $post_ID );
 			}
 			// Use oEmbed to get the HTML
-			$attr['discover'] = ( apply_filters('embed_oembed_discover', false) && author_can( $post_ID, 'unfiltered_html' ) ) ? true : false;
+			$attr['discover'] = ( apply_filters('embed_oembed_discover', false) && author_can( $post_ID, 'unfiltered_html' ) );
 			$html = wp_oembed_get( $url, $attr );
 			// Cache the result
 			$cache = ( $html ) ? $html : '{{unknown}}';
 			update_post_meta( $post_ID, $cachekey, $cache );
 			// If there was a result, return it
 			if ( $html )
-				return apply_filters( 'embed_oembed_html', $html, $url, $attr );
+				return apply_filters( 'embed_oembed_html', $html, $url, $attr, $post_ID );
 		}
 		// Still unknown
 		return $this->maybe_make_link( $url );
 	}
 	function maybe_make_link( $url ) {
 		$output = ( $this->linkifunknown ) ? '<a href="' . esc_attr($url) . '">' . esc_html($url) . '</a>' : $url;
 		return apply_filters( 'embed_maybe_make_link', $output, $url );
 	}
 }
-$wp_embed = new WP_Embed();
+$GLOBALS['wp_embed'] = new WP_Embed();
 /**
 * Register an embed handler. This function should probably only be used for sites that do not support oEmbed.
 *
 * @since 2.9.0
 	if ( !empty($GLOBALS['content_width']) )
 		$theme_width = (int) $GLOBALS['content_width'];
 	$width = get_option('embed_size_w');
-	if ( !$width && !empty($theme_width) )
+	if ( empty($width) && !empty($theme_width) )
 		$width = $theme_width;
-	if ( !$width )
+	if ( empty($width) )
 		$width = 500;
+	$height = get_option('embed_size_h');
+	if ( empty($height) )
+		$height = 700;
 	return apply_filters( 'embed_defaults', array(
-		'width' => $width,
+		'width'  => $width,
-		'height' => 700,
+		'height' => $height,
 	) );
 }
 /**
 * Based on a supplied width/height example, return the biggest possible dimensions based on the max width/height.
 * @see WP_oEmbed
 *
 * @uses _wp_oembed_get_object()
 * @uses WP_oEmbed::get_html()
 *
-* @param string $url The URL that should be embeded.
+* @param string $url The URL that should be embedded.
-* @param array $args Addtional arguments and parameters.
+* @param array $args Additional arguments and parameters.
-* @return string The original URL on failure or the embed HTML on success.
+* @return bool|string False on failure or the embed HTML on success.
 */
 function wp_oembed_get( $url, $args = '' ) {
-	require_once( 'class-oembed.php' );
+	require_once( ABSPATH . WPINC . '/class-oembed.php' );
 	$oembed = _wp_oembed_get_object();
 	return $oembed->get_html( $url, $args );
 }
 /**
 *
 * @uses _wp_oembed_get_object()
 *
 * @param string $format The format of URL that this provider can handle. You can use asterisks as wildcards.
 * @param string $provider The URL to the oEmbed provider.
-* @param boolean $regex Whether the $format parameter is in a regex format or not.
+* @param boolean $regex Whether the $format parameter is in a regex format.
 */
 function wp_oembed_add_provider( $format, $provider, $regex = false ) {
-	require_once( 'class-oembed.php' );
+	require_once( ABSPATH . WPINC . '/class-oembed.php' );
 	$oembed = _wp_oembed_get_object();
 	$oembed->providers[$format] = array( $provider, $regex );
 }
+/**
+* Determines if default embed handlers should be loaded.
+*
+* Checks to make sure that the embeds library hasn't already been loaded. If
+* it hasn't, then it will load the embeds library.
+*
+* @since 2.9.0
+*/
+function wp_maybe_load_embeds() {
+	if ( ! apply_filters( 'load_default_embeds', true ) )
+		return;
+	wp_embed_register_handler( 'googlevideo', '#http://video\.google\.([A-Za-z.]{2,5})/videoplay\?docid=([\d-]+)(.*?)#i', 'wp_embed_handler_googlevideo' );
+}
+/**
+* The Google Video embed handler callback. Google Video does not support oEmbed.
+*
+* @see WP_Embed::register_handler()
+* @see WP_Embed::shortcode()
+*
+* @param array $matches The regex matches from the provided regex when calling {@link wp_embed_register_handler()}.
+* @param array $attr Embed attributes.
+* @param string $url The original URL that was matched by the regex.
+* @param array $rawattr The original unmodified attributes.
+* @return string The embed HTML.
+*/
+function wp_embed_handler_googlevideo( $matches, $attr, $url, $rawattr ) {
+	// If the user supplied a fixed width AND height, use it
+	if ( !empty($rawattr['width']) && !empty($rawattr['height']) ) {
+		$width  = (int) $rawattr['width'];
+		$height = (int) $rawattr['height'];
+	} else {
+		list( $width, $height ) = wp_expand_dimensions( 425, 344, $attr['width'], $attr['height'] );
+	}
+	return apply_filters( 'embed_googlevideo', '<embed type="application/x-shockwave-flash" src="http://video.google.com/googleplayer.swf?docid=' . esc_attr($matches[2]) . '&amp;hl=en&amp;fs=true" style="width:' . esc_attr($width) . 'px;height:' . esc_attr($height) . 'px" allowFullScreen="true" allowScriptAccess="always" />', $matches, $attr, $url, $rawattr );
+}
+/**
+* Prints default plupload arguments.
+*
+* @since 3.4.0
+*/
+function wp_plupload_default_settings() {
+	global $wp_scripts;
+	$max_upload_size = wp_max_upload_size();
+	$defaults = array(
+		'runtimes'            => 'html5,silverlight,flash,html4',
+		'file_data_name'      => 'async-upload', // key passed to $_FILE.
+		'multiple_queues'     => true,
+		'max_file_size'       => $max_upload_size . 'b',
+		'url'                 => admin_url( 'admin-ajax.php', 'relative' ),
+		'flash_swf_url'       => includes_url( 'js/plupload/plupload.flash.swf' ),
+		'silverlight_xap_url' => includes_url( 'js/plupload/plupload.silverlight.xap' ),
+		'filters'             => array( array( 'title' => __( 'Allowed Files' ), 'extensions' => '*') ),
+		'multipart'           => true,
+		'urlstream_upload'    => true,
+	);
+	$defaults = apply_filters( 'plupload_default_settings', $defaults );
+	$params = array(
+		'action' => 'upload-attachment',
+	);
+	$params = apply_filters( 'plupload_default_params', $params );
+	$params['_wpnonce'] = wp_create_nonce( 'media-form' );
+	$defaults['multipart_params'] = $params;
+	$settings = array(
+		'defaults' => $defaults,
+		'browser'  => array(
+			'mobile'    => wp_is_mobile(),
+			'supported' => _device_can_upload(),
+		),
+	);
+	$script = 'var _wpPluploadSettings = ' . json_encode( $settings ) . ';';
+	$data = $wp_scripts->get_data( 'wp-plupload', 'data' );
+	if ( $data )
+		$script = "$data\n$script";
+	$wp_scripts->add_data( 'wp-plupload', 'data', $script );
+}
+add_action( 'customize_controls_enqueue_scripts', 'wp_plupload_default_settings' );

changeset 194	32102edaa81b
parent 136	bde1974c263b
child 204	09a1c134465b