in-portal
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Mon, Feb 10, 11:20 PM

in-portal
View Options

	Index: branches/5.0.x/themes/default/img/resized
	===================================================================
	--- branches/5.0.x/themes/default/img/resized (nonexistent)
	+++ branches/5.0.x/themes/default/img/resized (revision 12873)

	Property changes on: branches/5.0.x/themes/default/img/resized
	___________________________________________________________________
	Added: svn:ignore
	## -0,0 +1 ##
	+.
	Index: branches/5.0.x/themes/advanced/platform/img/resized
	===================================================================
	--- branches/5.0.x/themes/advanced/platform/img/resized (nonexistent)
	+++ branches/5.0.x/themes/advanced/platform/img/resized (revision 12873)

	Property changes on: branches/5.0.x/themes/advanced/platform/img/resized
	___________________________________________________________________
	Added: svn:ignore
	## -0,0 +1 ##
	+.
	Index: branches/5.0.x/themes/simple/img/resized
	===================================================================
	--- branches/5.0.x/themes/simple/img/resized (nonexistent)
	+++ branches/5.0.x/themes/simple/img/resized (revision 12873)

	Property changes on: branches/5.0.x/themes/simple/img/resized
	___________________________________________________________________
	Added: svn:ignore
	## -0,0 +1 ##
	+.
	Index: branches/5.0.x/core/units/helpers/image_helper.php
	===================================================================
	--- branches/5.0.x/core/units/helpers/image_helper.php (revision 12872)
	+++ branches/5.0.x/core/units/helpers/image_helper.php (revision 12873)
	@@ -1,653 +1,665 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	class ImageHelper extends kHelper {

	/**
	* Parses format string into array
	*
	* @param string $format sample format: "resize:300x500;wm:inc/wm.png\|c\|-20"
	* @return Array sample result: Array('max_width' => 300, 'max_height' => 500, 'wm_filename' => 'inc/wm.png', 'h_margin' => 'c', 'v_margin' => -20)
	*/
	function parseFormat($format)
	{
	$res = Array ();

	$format_parts = explode(';', $format);
	foreach ($format_parts as $format_part) {
	if (preg_match('/resize:(\d)x(\d)/', $format_part, $regs)) {
	$res['max_width'] = $regs[1];
	$res['max_height'] = $regs[2];
	}
	elseif (preg_match('/wm:([^\\|])\\|([^\\|])\\|([^\\|]*)/', $format_part, $regs)) {
	$res['wm_filename'] = FULL_PATH.THEMES_PATH.'/'.$regs[1];
	$res['h_margin'] = strtolower($regs[2]);
	$res['v_margin'] = strtolower($regs[3]);
	}
	elseif (preg_match('/crop:([^\\|])\\|([^\\|])/', $format_part, $regs)) {
	$res['crop_x'] = strtolower($regs[1]);
	$res['crop_y'] = strtolower($regs[2]);
	}
	elseif ($format_part == 'img_size' \|\| $format_part == 'img_sizes') {
	$res['image_size'] = true;
	}
	elseif (preg_match('/fill:(.*)/', $format_part, $regs)) {
	$res['fill'] = $regs[1];
	}
	}

	return $res;
	}

	/**
	* Resized given image to required dimensions & saves resized image to "resized" subfolder in source image folder
	*
	* @param string $src_image full path to image (on server)
	* @param mixed $max_width maximal allowed resized image width or false if no limit
	* @param mixed $max_height maximal allowed resized image height or false if no limit
	* @return string direct url to resized image
	*/
	function ResizeImage($src_image, $max_width, $max_height = null)
	{
	$image_size = false;

	if(isset($max_height)) {
	$params['max_height'] = $max_height;
	$params['max_width'] = $max_width;
	}
	else {
	$params = $this->parseFormat($max_width);

	if (array_key_exists('image_size', $params)) {
	// image_size param shouldn't affect resized file name (crc part)
	$image_size = $params['image_size'];
	unset($params['image_size']);
	}
	}

	if ($params['max_width'] > 0 \|\| $params['max_height'] > 0) {
	list ($params['target_width'], $params['target_height'], $needs_resize) = $this->GetImageDimensions($src_image, $params['max_width'], $params['max_height'], $params);

	if (!is_numeric($params['max_width'])) {
	$params['max_width'] = $params['target_width'];
	}

	if (!is_numeric($params['max_height'])) {
	$params['max_height'] = $params['target_height'];
	}

	$src_path = dirname($src_image);
	+ $transform_keys = Array ('crop_x', 'crop_y', 'fill', 'wm_filename');

	- if ($needs_resize \|\| array_key_exists('wm_filename', $params) && $params['wm_filename']) {
	+ if ($needs_resize \|\| array_intersect(array_keys($params), $transform_keys)) {
	// resize required OR watermarking required -> change resulting image name !
	$dst_image = preg_replace('/^'.preg_quote($src_path, '/').'(.)\.(.)$/', $src_path . DIRECTORY_SEPARATOR . 'resized\\1_' . crc32(serialize($params)) . '.\\2', $src_image);
	if (!file_exists($dst_image) \|\| filemtime($src_image) > filemtime($dst_image)) {
	// resized image not available OR should be recreated due source image change
	$params['dst_image'] = $dst_image;
	$image_resized = $this->ScaleImage($src_image, $params);
	if (!$image_resized) {
	// resize failed, because of server error
	$dst_image = $src_image;
	}
	}

	// resize/watermarking ok
	$src_image = $dst_image;
	}
	}

	if ($image_size) {
	// return only image size (resized or not)
	$image_info = $this->getImageInfo($src_image);
	return $image_info ? $image_info[3] : '';
	}

	$base_url = rtrim($this->Application->BaseURL(), '/');
	return str_replace(DIRECTORY_SEPARATOR, '/', preg_replace('/^'.preg_quote(FULL_PATH, '/').'(.*)/', $base_url.'\\1', $src_image));
	}

	/**
	* Proportionally resizes given image to destination dimensions
	*
	* @param string $src_image full path to source image (already existing)
	* @param string $dst_image full path to destination image (will be created)
	* @param int $dst_width destination image width (in pixels)
	* @param int $dst_height destination image height (in pixels)
	*/
	function ScaleImage($src_image, $params)
	{
	$image_info = $this->getImageInfo($src_image);
	if (!$image_info) {
	return false;
	}

	/*list ($params['max_width'], $params['max_height'], $resized) = $this->GetImageDimensions($src_image, $params['max_width'], $params['max_height'], $params);
	if (!$resized) {
	// image dimensions are smaller or equals to required dimensions
	return false;
	}*/

	if (!$this->Application->ConfigValue('ForceImageMagickResize') && function_exists('imagecreatefromjpeg')) {
	// try to resize using GD
	$resize_map = Array (
	'image/jpeg' => 'imagecreatefromjpeg:imagejpeg:jpg',
	'image/gif' => 'imagecreatefromgif:imagegif:gif',
	'image/png' => 'imagecreatefrompng:imagepng:png',
	'image/bmp' => 'imagecreatefrombmp:imagejpeg:bmp',
	);

	$mime_type = $image_info['mime'];
	if (!isset($resize_map[$mime_type])) {
	return false;
	}

	list ($read_function, $write_function, $file_extension) = explode(':', $resize_map[$mime_type]);

	+ // when source image has large dimensions (over 1MB filesize), then 16M is not enough
	+ set_time_limit(0);
	+ ini_set('memory_limit', -1);
	+
	$src_image_rs = @$read_function($src_image);
	if ($src_image_rs) {
	- // when source image has large dimensions (over 1MB filesize), then 16M is not enough
	- set_time_limit(0);
	- ini_set('memory_limit', -1);
	-
	$dst_image_rs = imagecreatetruecolor($params['target_width'], $params['target_height']); // resize target size

	if (($file_extension == 'gif') \|\| ($file_extension == 'png')) {
	// preserve transparency of PNG and GIF images
	$dst_image_rs = $this->_preserveTransparency($src_image_rs, $dst_image_rs, $image_info[2]);
	}

	// 1. resize
	imagecopyresampled($dst_image_rs, $src_image_rs, 0, 0, 0, 0, $params['target_width'], $params['target_height'], $image_info[0], $image_info[1]);

	$watermark_size = 'target';

	if (array_key_exists('crop_x', $params) \|\| array_key_exists('crop_y', $params)) {
	// 2.1. crop image to given size
	$dst_image_rs =& $this->_cropImage($dst_image_rs, $params);
	$watermark_size = 'max';
	} elseif (array_key_exists('fill', $params)) {
	// 2.2. fill image margins from resize with given color
	$dst_image_rs =& $this->_applyFill($dst_image_rs, $params);
	$watermark_size = 'max';
	}

	// 3. apply watermark
	$dst_image_rs =& $this->_applyWatermark($dst_image_rs, $params[$watermark_size . '_width'], $params[$watermark_size . '_height'], $params);

	return @$write_function($dst_image_rs, $params['dst_image'], 100);
	}
	}
	else {
	// try to resize using ImageMagick
	// TODO: implement crop and watermarking using imagemagick
	exec('/usr/bin/convert '.$src_image.' -resize '.$params['target_width'].'x'.$params['target_height'].' '.$params['dst_image'], $shell_output, $exec_status);
	return $exec_status == 0;
	}

	return false;
	}

	/**
	* Preserve transparency for GIF and PNG images
	*
	* @param resource $src_image_rs
	* @param resource $dst_image_rs
	* @param int $image_type
	* @return resource
	*/
	function _preserveTransparency($src_image_rs, $dst_image_rs, $image_type)
	{
	$transparent_index = imagecolortransparent($src_image_rs);

	// if we have a specific transparent color
	if ($transparent_index >= 0) {
	// get the original image's transparent color's RGB values
	$transparent_color = imagecolorsforindex($src_image_rs, $transparent_index);

	// allocate the same color in the new image resource
	$transparent_index = imagecolorallocate($dst_image_rs, $transparent_color['red'], $transparent_color['green'], $transparent_color['blue']);

	// completely fill the background of the new image with allocated color
	imagefill($dst_image_rs, 0, 0, $transparent_index);

	// set the background color for new image to transparent
	imagecolortransparent($dst_image_rs, $transparent_index);

	return $dst_image_rs;
	}

	// always make a transparent background color for PNGs that don't have one allocated already
	if ($image_type == IMAGETYPE_PNG) {
	// turn off transparency blending (temporarily)
	imagealphablending($dst_image_rs, false);

	// create a new transparent color for image
	$transparent_color = imagecolorallocatealpha($dst_image_rs, 0, 0, 0, 127);

	// completely fill the background of the new image with allocated color
	imagefill($dst_image_rs, 0, 0, $transparent_color);

	// restore transparency blending
	imagesavealpha($dst_image_rs, true);
	}

	return $dst_image_rs;
	}

	/**
	* Fills margins (if any) of resized are with given color
	*
	* @param resource $src_image_rs resized image resource
	* @param Array $params crop parameters
	* @return resource
	*/
	function &_applyFill(&$src_image_rs, $params)
	{
	$x_position = round(($params['max_width'] - $params['target_width']) / 2); // center
	$y_position = round(($params['max_height'] - $params['target_height']) / 2); // center

	// crop resized image
	$fill_image_rs = imagecreatetruecolor($params['max_width'], $params['max_height']);

	$fill = $params['fill'];

	if (substr($fill, 0, 1) == '#') {
	// hexdecimal color
	$color = imagecolorallocate($fill_image_rs, hexdec( substr($fill, 1, 2) ), hexdec( substr($fill, 3, 2) ), hexdec( substr($fill, 5, 2) ));
	}
	else {
	// for now we don't support color names, but we will in future
	return $src_image_rs;
	}

	imagefill($fill_image_rs, 0, 0, $color);
	imagecopy($fill_image_rs, $src_image_rs, $x_position, $y_position, 0, 0, $params['target_width'], $params['target_height']);

	return $fill_image_rs;
	}

	/**
	* Crop given image resource using given params and return resulting image resource
	*
	* @param resource $src_image_rs resized image resource
	* @param Array $params crop parameters
	* @return resource
	*/
	function &_cropImage(&$src_image_rs, $params)
	{
	if ($params['crop_x'] == 'c') {
	$x_position = round(($params['max_width'] - $params['target_width']) / 2); // center
	}
	elseif ($params['crop_x'] >= 0) {
	$x_position = $params['crop_x']; // margin from left
	}
	else {
	$x_position = $params['target_width'] - ($params['max_width'] - $params['crop_x']); // margin from right
	}

	if ($params['crop_y'] == 'c') {
	$y_position = round(($params['max_height'] - $params['target_height']) / 2); // center
	}
	elseif ($params['crop_y'] >= 0) {
	$y_position = $params['crop_y']; // margin from top
	}
	else {
	$y_position = $params['target_height'] - ($params['max_height'] - $params['crop_y']); // margin from bottom
	}

	// crop resized image
	$crop_image_rs = imagecreatetruecolor($params['max_width'], $params['max_height']);
	$crop_image_rs =& $this->_applyFill($crop_image_rs, $params);

	imagecopy($crop_image_rs, $src_image_rs, $x_position, $y_position, 0, 0, $params['target_width'], $params['target_height']);

	return $crop_image_rs;
	}

	/**
	* Apply watermark (transparent PNG image) to given resized image resource
	*
	* @param resource $src_image_rs
	* @param int $max_width
	* @param int $max_height
	* @param Array $params
	* @return resource
	*/
	function &_applyWatermark(&$src_image_rs, $max_width, $max_height, $params)
	{
	$watermark_file = array_key_exists('wm_filename', $params) ? $params['wm_filename'] : false;

	if (!$watermark_file \|\| !file_exists($watermark_file)) {
	// no watermark required, or provided watermark image is missing
	return $src_image_rs;
	}

	$watermark_img_rs = imagecreatefrompng($watermark_file);
	list ($watermark_width, $watermark_height) = $this->getImageInfo($watermark_file);

	imagealphablending($src_image_rs, true);

	if ($params['h_margin'] == 'c') {
	$x_position = round($max_width / 2 - $watermark_width / 2); // center
	}
	elseif ($params['h_margin'] >= 0) {
	$x_position = $params['h_margin']; // margin from left
	}
	else {
	$x_position = $max_width - ($watermark_width - $params['h_margin']); // margin from right
	}

	if ($params['v_margin'] == 'c') {
	$y_position = round($max_height / 2 - $watermark_height / 2); // center
	}
	elseif ($params['v_margin'] >= 0) {
	$y_position = $params['v_margin']; // margin from top
	}
	else {
	$y_position = $max_height - ($watermark_height - $params['v_margin']); // margin from bottom
	}

	imagecopy($src_image_rs, $watermark_img_rs, $x_position, $y_position, 0, 0, $watermark_width, $watermark_height);

	return $src_image_rs;
	}

	/**
	* Returns destination image size without actual resizing (useful for <img .../> HTML tag)
	*
	* @param string $src_image full path to source image (already existing)
	* @param int $dst_width destination image width (in pixels)
	* @param int $dst_height destination image height (in pixels)
	* @param Array $params
	* @return Array resized image dimensions (0 - width, 1 - height)
	*/
	function GetImageDimensions($src_image, $dst_width, $dst_height, $params)
	{
	$image_info = $this->getImageInfo($src_image);
	if (!$image_info) {
	return false;
	}

	$orig_width = $image_info[0];
	$orig_height = $image_info[1];

	$too_large = is_numeric($dst_width) ? ($orig_width > $dst_width) : false;
	$too_large = $too_large \|\| (is_numeric($dst_height) ? ($orig_height > $dst_height) : false);

	if ($too_large) {
	$width_ratio = $dst_width ? $dst_width / $orig_width : 1;
	$height_ratio = $dst_height ? $dst_height / $orig_height : 1;

	if (array_key_exists('crop_x', $params) \|\| array_key_exists('crop_y', $params)) {
	// resize by smallest inverted radio
	$resize_by = $this->_getCropImageMinRatio($image_info, $dst_width, $dst_height);
	+
	+ if ($resize_by === false) {
	+ return Array ($orig_width, $orig_height, false);
	+ }
	+
	$ratio = $resize_by == 'width' ? $width_ratio : $height_ratio;
	}
	else {
	$ratio = min($width_ratio, $height_ratio);
	}

	$width = ceil($orig_width * $ratio);
	$height = ceil($orig_height * $ratio);
	}
	else {
	$width = $orig_width;
	$height = $orig_height;
	}

	return Array ($width, $height, $too_large);
	}

	/**
	* Returns ratio type with smaller relation of original size to target size
	*
	* @param Array $image_info image information from "ImageHelper::getImageInfo"
	* @param int $dst_width destination image width (in pixels)
	* @param int $dst_height destination image height (in pixels)
	* @return Array
	*/
	function _getCropImageMinRatio($image_info, $dst_width, $dst_height)
	{
	$width_ratio = $dst_width ? $image_info[0] / $dst_width : 1;
	$height_ratio = $dst_height ? $image_info[1] / $dst_height : 1;
	+ $minimal_ratio = min($width_ratio, $height_ratio);
	+
	+ if ($minimal_ratio < 1) {
	+ // ratio is less then 1, image will be enlarged -> don't allow that
	+ return false;
	+ }

	return $width_ratio < $height_ratio ? 'width' : 'height';
	}

	/**
	* Returns image dimensions + checks if given file is existing image
	*
	* @param string $src_image full path to source image (already existing)
	* @return mixed
	*/
	function getImageInfo($src_image)
	{
	if (!file_exists($src_image)) {
	return false;
	}

	$image_info = @getimagesize($src_image);
	if (!$image_info) {
	trigger_error('Image <b>'.$src_image.'</b> <span class="debug_error">missing or invalid</span>', E_USER_WARNING);
	return false;
	}

	return $image_info;
	}

	/**
	* Returns maximal image size (width & height) among fields specified
	*
	* @param kDBItem $object
	* @param string $fields
	* @param string $format any format, that returns full url (e.g. files_resized:WxH, resize:WxH, full_url, full_urls)
	* @return string
	*/
	function MaxImageSize(&$object, $fields, $format = null)
	{
	static $cached_sizes = Array ();

	$cache_key = $object->getPrefixSpecial().'_'.$object->GetID();
	if (!isset($cached_sizes[$cache_key])) {
	$images = Array ();

	$fields = explode(',', $fields);
	foreach ($fields as $field) {
	$image_data = $object->GetField($field, $format);
	if (!$image_data) {
	continue;
	}

	$images = array_merge($images, explode('\|', $image_data));
	}

	$max_width = 0;
	$max_height = 0;
	$base_url = rtrim($this->Application->BaseURL(), '/');

	foreach ($images as $image_url) {
	$image_path = preg_replace('/^'.preg_quote($base_url, '/').'(.*)/', FULL_PATH.'\\1', $image_url);
	$image_info = $this->getImageInfo($image_path);
	$max_width = max($max_width, $image_info[0]);
	$max_height = max($max_height, $image_info[1]);
	}

	$cached_sizes[$cache_key] = Array ($max_width, $max_height);
	}

	return $cached_sizes[$cache_key];
	}

	/**
	* Puts existing item images (from subitem) to virtual fields (in main item)
	*
	* @param kCatDBItem $object
	*/
	function LoadItemImages(&$object)
	{
	if (!$this->_canUseImages($object)) {
	return ;
	}

	$max_image_count = $this->Application->ConfigValue($object->Prefix.'_MaxImageCount');

	$sql = 'SELECT *
	FROM '.TABLE_PREFIX.'Images
	WHERE ResourceId = '.$object->GetDBField('ResourceId').'
	ORDER BY Priority DESC
	LIMIT 0, ' . (int)$max_image_count;
	$item_images = $this->Conn->Query($sql);

	$image_counter = 1;
	foreach ($item_images as $item_image) {
	$image_path = $item_image['ThumbPath'];
	if ($item_image['DefaultImg'] == 1 \|\| $item_image['Name'] == 'main') {
	// process primary image separately
	if (array_key_exists('PrimaryImage', $object->Fields)) {
	$object->SetDBField('PrimaryImage', $image_path);
	$object->SetOriginalField('PrimaryImage', $image_path);
	$object->Fields['PrimaryImage']['original_field'] = $item_image['Name'];

	$this->_loadCustomFields($object, $item_image, 0);
	}
	continue;
	}

	if (abs($item_image['Priority'])) {
	// use Priority as image counter, when specified
	$image_counter = abs($item_image['Priority']);
	}

	if (array_key_exists('Image'.$image_counter, $object->Fields)) {
	$object->SetDBField('Image'.$image_counter, $image_path);
	$object->SetOriginalField('Image'.$image_counter, $image_path);
	$object->Fields['Image'.$image_counter]['original_field'] = $item_image['Name'];

	$this->_loadCustomFields($object, $item_image, $image_counter);
	}
	$image_counter++;
	}
	}

	/**
	* Saves newly uploaded images to external image table
	*
	* @param kCatDBItem $object
	*/
	function SaveItemImages(&$object)
	{
	if (!$this->_canUseImages($object)) {
	return ;
	}

	$table_name = $this->Application->getUnitOption('img', 'TableName');
	$max_image_count = $this->Application->getUnitOption($object->Prefix, 'ImageCount'); // $this->Application->ConfigValue($object->Prefix.'_MaxImageCount');

	$i = 0;
	while ($i < $max_image_count) {
	$field = $i ? 'Image'.$i : 'PrimaryImage';
	$field_options = $object->GetFieldOptions($field);

	$image_src = $object->GetDBField($field);
	if ($image_src) {
	if (isset($field_options['original_field'])) {
	$key_clause = 'Name = '.$this->Conn->qstr($field_options['original_field']).' AND ResourceId = '.$object->GetDBField('ResourceId');

	if ($object->GetDBField('Delete'.$field)) {
	// if item was cloned, then new filename is in db (not in $image_src)
	$sql = 'SELECT ThumbPath
	FROM '.$table_name.'
	WHERE '.$key_clause;
	$image_src = $this->Conn->GetOne($sql);
	if (@unlink(FULL_PATH.$image_src)) {
	$sql = 'DELETE FROM '.$table_name.'
	WHERE '.$key_clause;
	$this->Conn->Query($sql);
	}
	}
	else {
	// image record found -> update
	$fields_hash = Array (
	'ThumbPath' => $image_src,
	);
	$this->_saveCustomFields($object, $fields_hash, $i);

	$this->Conn->doUpdate($fields_hash, $table_name, $key_clause);
	}
	}
	else {
	// image record not found -> create
	$fields_hash = Array (
	'ResourceId' => $object->GetDBField('ResourceId'),
	'Name' => $field,
	'AltName' => $field,
	'Enabled' => STATUS_ACTIVE,
	'DefaultImg' => $i ? 0 : 1, // first image is primary, others not primary
	'ThumbPath' => $image_src,
	'Priority' => ($i == 0)? 0 : $i * (-1),
	);
	$this->_saveCustomFields($object, $fields_hash, $i);

	$this->Conn->doInsert($fields_hash, $table_name);
	$field_options['original_field'] = $field;
	$object->SetFieldOptions($field, $field_options);
	}
	}
	$i++;
	}
	}

	/**
	* Adds ability to load custom fields along with main image field
	*
	* @param kCatDBItem $object
	* @param Array $fields_hash
	* @param int $counter 0 - primary image, other number - additional image number
	*/
	function _loadCustomFields(&$object, $fields_hash, $counter)
	{
	$field_name = $counter ? 'Image' . $counter . 'Alt' : 'PrimaryImageAlt';

	$object->SetDBField($field_name, (string)$fields_hash['AltName']);
	}

	/**
	* Adds ability to save custom field along with main image save
	*
	* @param kCatDBItem $object
	* @param Array $fields_hash
	* @param int $counter 0 - primary image, other number - additional image number
	*/
	function _saveCustomFields(&$object, &$fields_hash, $counter)
	{
	$field_name = $counter ? 'Image' . $counter . 'Alt' : 'PrimaryImageAlt';

	$fields_hash['AltName'] = (string)$object->GetDBField($field_name);
	}

	/**
	* Checks, that item can use image upload capabilities
	*
	* @param kCatDBItem $object
	* @return bool
	*/
	function _canUseImages(&$object)
	{
	$prefix = $object->Prefix == 'p' ? 'img' : $object->Prefix . '-img';

	return $this->Application->prefixRegistred($prefix);
	}
	}
	\ No newline at end of file
	Index: branches/5.0.x/core/units/images/image_tag_processor.php
	===================================================================
	--- branches/5.0.x/core/units/images/image_tag_processor.php (revision 12872)
	+++ branches/5.0.x/core/units/images/image_tag_processor.php (revision 12873)
	@@ -1,427 +1,450 @@
	<?php
	/**
	* @version $Id$
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2009 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/



	class ImageTagProcessor extends kDBTagProcessor {

	/**
	* Prepares all image parameters as list block parameters (for easy usage)
	*
	* @param kDBList $object
	* @param Array $block_params
	* @author Alex
	*/
	function PrepareListElementParams(&$object, &$block_params)
	{
	$image_url = $this->ImageSrc($block_params);
	if (!$image_url) {
	return ;
	}

	$parent_prefix = $this->Application->getUnitOption($object->Prefix, 'ParentPrefix');
	$parent_item =& $this->Application->recallObject($parent_prefix);

	$block_params['img_path'] = $image_url;
	$image_dimensions = $this->ImageSize($block_params);
	$block_params['img_size'] = $image_dimensions ? $image_dimensions : ' width="'.$block_params['DefaultWidth'].'"';
	$block_params['alt'] = $object->GetField('AltName')? $object->GetField('AltName') : htmlspecialchars($this->getItemTitle($parent_item));
	$block_params['align'] = array_key_exists('align', $block_params) ? $block_params['align'] : 'left';
	}

	/**
	* Returns value of object's title field
	*
	* @param kDBItem $object
	* @return string
	*/
	function getItemTitle(&$object)
	{
	$title_field = $this->Application->getUnitOption($object->Prefix, 'TitleField');
	return $object->GetField($title_field);
	}

	/**
	* [AGGREGATED TAGS] works as <inp2:CatalogItemPrefix_Image, ImageSize, ImageSrc ..../>
	*
	* @param Array $params
	* @return string
	*/
	function ItemImageTag($params)
	{
	$this->LoadItemImage($params);
	return $this->$params['original_tag']($params);
	}

	function LargeImageExists($params)
	{
	$object =& $this->getObject($params);
	if ($object->GetDBField('SameImages') == null \|\| $object->GetDBField('SameImages') == 1) {
	return false;
	}
	else {
	return true;
	}
	}

	function LoadItemImage($params)
	{
	$parent_item =& $this->Application->recallObject($params['PrefixSpecial']);
	/* @var $parent_item kCatDBItem */

	$object =& $this->Application->recallObject($this->getPrefixSpecial(), null, Array('skip_autoload' => true));
	/* @var $object kDBItem */

	$object->Clear();

	// if we need primary thumbnail which is preloaded with category item's list
	$is_primary = $this->SelectParam($params, 'primary,Primary');
	$image_id = $this->Application->GetVar($this->Prefix.'_id');

	if (
	// is primary, when primary mark set OR name & field not given
	($is_primary \|\| !(isset($params['name']) \|\| isset($params['field']))) &&

	// primary image is preloaded AND direct id not given
	isset($parent_item->Fields['ThumbPath']) && !$image_id
	) {
	$object->SetDefaultValues();
	- $object->SetDBField('Url', $parent_item->GetDBField('FullUrl'));
	- $object->SetDBField('AltName', $this->getItemTitle($parent_item));

	- $object->SetDBFieldsFromHash($parent_item->GetFieldValues(), Array('SameImages', 'LocalThumb', 'ThumbPath', 'ThumbUrl', 'LocalImage', 'LocalPath'));
	- $object->Loaded = true;
	+ if (is_null($parent_item->GetDBField('SameImages'))) {
	+ // JOIN definetly failed, because it's not-null column
	+ $object->Loaded = false;
	+ }
	+ else {
	+ $object->SetDBField('Url', $parent_item->GetDBField('FullUrl'));
	+ $object->SetDBField('AltName', $this->getItemTitle($parent_item));
	+
	+ $object->SetDBFieldsFromHash($parent_item->GetFieldValues(), Array('SameImages', 'LocalThumb', 'ThumbPath', 'ThumbUrl', 'LocalImage', 'LocalPath'));
	+ $object->Loaded = true;
	+ }
	+
	}
	else { // if requested image is not primary thumbnail - load it directly
	$id_field = $this->Application->getUnitOption($this->Prefix, 'ForeignKey');
	$parent_table_key = $this->Application->getUnitOption($this->Prefix, 'ParentTableKey');

	$keys[$id_field] = $parent_item->GetDBField($parent_table_key);

	// which image to load?
	if ($is_primary) {
	// by PrimaryImage mark
	$keys['DefaultImg'] = 1;
	}
	elseif (getArrayValue($params, 'name')) {
	// by ImageName
	$keys['Name'] = $params['name'];
	}
	elseif (getArrayValue($params, 'field')) {
	// by virtual field name in main object
	$field_options = $parent_item->GetFieldOptions($params['field']);
	$keys['Name'] = isset($field_options['original_field']) ? $field_options['original_field'] : $params['field'];
	}
	elseif ($image_id) {
	// by ID
	$keys['ImageId'] = $image_id;
	}
	else {
	// by PrimaryImage if no other criteria given
	$keys['DefaultImg'] = 1;
	}

	$object->Load($keys);

	if (isset($params['field'])) {
	$image_src = $parent_item->GetDBField($params['field']);

	// when image is uploaded to virtual field in main item, but not saved to db
	$object->SetDBField('ThumbPath', $image_src);

	- if (!$object->isLoaded()) {
	+ if (!$object->isLoaded() && $image_src) {
	// set fields for displaing new image during main item suggestion with errors
	$fields_hash = Array (
	'Url' => '',
	'ThumbUrl' => '',
	'LocalPath' => '',

	'SameImages' => 1,
	'LocalThumb' => 1,
	'LocalImage' => 1,
	);

	$object->SetDBFieldsFromHash($fields_hash);
	$object->Loaded = true;
	}
	}
	}
	}

	function getImageDimension($type, $params)
	{
	$ret = isset($params['Max'.$type]) ? $params['Max'.$type] : false;
	if (!$ret) {
	return $ret;
	}
	$parent_prefix = $this->Application->getUnitOption($this->Prefix, 'ParentPrefix');

	if ($ret == 'thumbnail') {
	$ret = $this->Application->ConfigValue($parent_prefix.'_ThumbnailImage'.$type);
	}
	if ($ret == 'fullsize') {
	$ret = $this->Application->ConfigValue($parent_prefix.'_FullImage'.$type);
	}

	return $ret;
	}

	/**
	* Appends "/" to beginning of image path (in case when missing)
	*
	* @param kDBItem $object
	* @todo old in-portal doesn't append first slash, but we do => append first slash for him :)
	*/
	function makeRelativePaths(&$object)
	{
	$thumb_path = $object->GetDBField('ThumbPath');
	if ($thumb_path && substr($thumb_path, 0, 1) != '/') {
	$object->SetDBField('ThumbPath', '/'.$thumb_path);
	}

	$local_path = $object->GetDBField('LocalPath');
	if ($local_path && substr($local_path, 0, 1) != '/') {
	$object->SetDBField('LocalPath', '/'.$local_path);
	}
	}

	function ImageSrc($params)
	{
	$object =& $this->getObject($params);
	/* @var $object kDBItem */

	$this->makeRelativePaths($object);

	// show "noimage.gif" when requested image is missing OR was not uploaded
	$use_default_image = !(defined('DBG_IMAGE_RECOVERY') && DBG_IMAGE_RECOVERY);

	$base_url = rtrim($this->Application->BaseURL(), '/');
	if (!$object->isLoaded() \|\| ($object->GetDBField('SameImages') && $object->GetDBField('ThumbPath'))) {
	// we can auto-resize image, when source image available & we use same image for thumbnail & full image in admin

	$max_width = $this->getImageDimension('Width', $params);
	$max_height = $this->getImageDimension('Height', $params);
	$format = array_key_exists('format', $params) ? $params['format'] : false;

	if (!$max_width && $format) {
	// user watermarks from format param
	$max_width = $format;
	}

	if ($max_width > 0 \|\| $max_height > 0 \|\| $format) {
	$src_image = FULL_PATH.$object->GetDBField('ThumbPath');
	+ list ($max_width, $max_height) = $this->_transformParams($params, $max_width, $max_height);
	+
	if ($object->isLoaded() && file_exists($src_image)) {
	$image_helper =& $this->Application->recallObject('ImageHelper');
	/* @var $image_helper ImageHelper */

	- $resize_format = 'resize:' . $max_width . 'x' . $max_height;
	-
	- $crop = $this->SelectParam($params, 'Crop,crop');
	- if ($crop) {
	- if (strpos($crop, ';') === false) {
	- $crop = 'c\|c';
	- }
	-
	- $max_width = (is_null($max_height) ? $max_width : $resize_format) . ';crop:' . $crop;
	- $max_height = null;
	- }
	-
	- $fill = $this->SelectParam($params, 'Fill,fill');
	- if ($fill) {
	- $max_width = (is_null($max_height) ? $max_width : $resize_format) . ';fill:' . $fill;
	- $max_height = null;
	- }
	-
	- $watermark = $this->SelectParam($params, 'Watermark,watermark');
	- if ($watermark) {
	- $max_width = (is_null($max_height) ? $max_width : $resize_format) . ';wm:' . $watermark;
	- $max_height = null;
	- }
	-
	return $image_helper->ResizeImage($src_image, $max_width, $max_height);
	}
	elseif ($use_default_image) {
	return $this->_getDefaultImage($params, $max_width, $max_height);
	}

	return $base_url . $object->GetDBField('ThumbPath');
	}
	}

	// if we need thumbnail, or full image is same as thumbnail
	$show_thumbnail = $this->SelectParam($params, 'thumbnail,Thumbnail') \|\| // old style
	(isset($params['MaxWidth']) && $params['MaxWidth'] == 'thumbnail') \|\| // new style
	(isset($params['MaxHeight']) && $params['MaxHeight'] == 'thumbnail');

	if ($show_thumbnail \|\| $object->GetDBField('SameImages')) {
	// return local image or url
	$ret = $object->GetDBField('LocalThumb') ? $base_url . $object->GetDBField('ThumbPath') : $object->GetDBField('ThumbUrl');
	}
	else { // if we need full which is not the same as thumb
	$ret = $object->GetDBField('LocalImage') ? $base_url . $object->GetDBField('LocalPath') : $object->GetDBField('Url');
	}

	if ($ret && ($ret != $base_url)) {
	// convert full url to full path!
	$dst_image = preg_replace('/^' . preg_quote($base_url, '/') . '/', FULL_PATH, $ret, 1);
	$image_found = $dst_image != $ret ? file_exists($dst_image) : true;

	if ($image_found) {
	// image isn't deleted OR is stored on remote location
	return $ret;
	}
	}

	- // return Default Image or false if NOT specified
	+ // return Default Image or false if NOT specified (only for case, when SameImages = 0)
	return $this->_getDefaultImage($params);
	}

	/**
	+ * Transforms Image/ImageSrc aggregated tag parameters into ones, that ResizeImage method understands
	+ *
	+ * @param Array $params
	+ * @param int $max_width
	+ * @param int $max_height
	+ * @return Array
	+ */
	+ function _transformParams($params, $max_width = false, $max_height = false)
	+ {
	+ $resize_format = 'resize:' . $max_width . 'x' . $max_height;
	+
	+ $crop = $this->SelectParam($params, 'Crop,crop');
	+ if ($crop) {
	+ if (strpos($crop, ';') === false) {
	+ $crop = 'c\|c';
	+ }
	+
	+ $max_width = (is_null($max_height) ? $max_width : $resize_format) . ';crop:' . $crop;
	+ $max_height = null;
	+ }
	+
	+ $fill = $this->SelectParam($params, 'Fill,fill');
	+ if ($fill) {
	+ $max_width = (is_null($max_height) ? $max_width : $resize_format) . ';fill:' . $fill;
	+ $max_height = null;
	+ }
	+
	+ $watermark = $this->SelectParam($params, 'Watermark,watermark');
	+ if ($watermark) {
	+ $max_width = (is_null($max_height) ? $max_width : $resize_format) . ';wm:' . $watermark;
	+ $max_height = null;
	+ }
	+
	+ return Array ($max_width, $max_height);
	+ }
	+
	+ /**
	* Returns default full url to default images
	*
	* @param Array $params
	* @param int $max_width
	* @param int $max_height
	* @return string
	*/
	function _getDefaultImage($params, $max_width = false, $max_height = false)
	{
	$default_image = $this->SelectParam($params, 'default_image,DefaultImage');
	if (!$default_image) {
	return '';
	}

	// show default image, use different base urls for admin and front-end
	$base_url = rtrim($this->Application->BaseURL(), '/');
	$sub_folder = $this->Application->isAdmin ? rtrim(IMAGES_PATH, '/') : THEMES_PATH;

	- if ($max_width > 0 \|\| $max_height > 0) {
	+ if (($max_width !== false) \|\| ($max_height !== false)) {
	$image_helper =& $this->Application->recallObject('ImageHelper');
	/* @var $image_helper ImageHelper */

	$src_image = FULL_PATH . $sub_folder . '/' . $default_image;

	return $image_helper->ResizeImage($src_image, $max_width, $max_height);
	}

	return $base_url . $sub_folder . '/' . $default_image;
	}

	function getFullPath($path)
	{
	if (!$path) {
	return $path;
	}

	// absolute url
	if (preg_match('/^(.):\/\/(.)$/U', $path)) {
	return preg_replace('/^'.preg_quote($this->Application->BaseURL(), '/').'(.*)/', FULL_PATH.'/\\1', $path);
	}

	// relative url
	return FULL_PATH.'/'.mb_substr(THEMES_PATH, 1).'/'.$path;
	}

	/**
	* Makes size clause for img tag, such as
	* ' width="80" height="100"' according to max_width
	* and max_heght limits.
	*
	* @param array $params
	* @return string
	*/
	function ImageSize($params)
	{
	$img_path = $this->getFullPath($params['img_path']);

	$image_helper =& $this->Application->recallObject('ImageHelper');
	/* @var $image_helper ImageHelper */

	$max_width = $this->getImageDimension('Width', $params);
	$max_height = $this->getImageDimension('Height', $params);

	$image_dimensions = $image_helper->GetImageDimensions($img_path, $max_width, $max_height, $params);
	if (!$image_dimensions) {
	return false;
	}

	return ' width="'.$image_dimensions[0].'" height="'.$image_dimensions[1].'"';
	}

	/**
	* Prepares image parameters & parses block with them (for admin)
	*
	* @param Array $params
	* @return string
	*/
	function Image($params)
	{
	$image_url = $this->ImageSrc($params);
	if (!$image_url) {
	return ;
	}

	$object =& $this->getObject($params);
	$params['img_path'] = $image_url;
	$image_dimensions = $this->ImageSize($params);
	$params['img_size'] = $image_dimensions ? $image_dimensions : ' width="'.$params['DefaultWidth'].'"';
	$params['alt'] = htmlspecialchars($object->GetField('AltName')); // really used ?
	$params['name'] = $this->SelectParam($params, 'block,render_as');
	$params['align'] = array_key_exists('align', $params) ? $params['align'] : 'left';
	$params['no_editing'] = 1;

	if (!$object->isLoaded() && !$this->SelectParam($params, 'default_image,DefaultImage')) {
	return false;
	}

	return $this->Application->ParseBlock($params);
	}


	/**
	* Returns url for image in case when image source is url (for admin)
	*
	* @param Array $params
	* @return string
	*/
	function ImageUrl($params)
	{
	$object =& $this->getObject($params);
	if ($object->GetDBField('SameImages') ? $object->GetDBField('LocalThumb') : $object->GetDBField('LocalImage') ) {
	$ret = $this->Application->Phrase(getArrayValue($params,'local_phrase'));
	}
	else {
	$ret = $object->GetDBField('SameImages') ? $object->GetDBField('ThumbUrl') : $object->GetDBField('Url');
	}
	return $ret;
	}

	/**
	* If data was modfied & is in TempTables mode, then parse block with name passed;
	* remove modification mark if not in TempTables mode
	*
	* @param Array $params
	* @return string
	* @access public
	* @author Alexey
	*/
	function SaveWarning($params)
	{
	if ($this->Prefix == 'c-img') {
	return $this->Application->ProcessParsedTag('c', 'SaveWarning', $params);
	}

	return parent::SaveWarning($params);
	}
	}
	\ No newline at end of file

in-portalNo OneTemporaryActions

File Metadata

in-portalView Options

Event Timeline

in-portal
No OneTemporary
Actions

in-portal
View Options