Subversion Repositories Applications.papyrus

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2005 Aurelien 1 
<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
2 
/**
3 
 * CodeIgniter
4 
 *
5 
 * An open source application development framework for PHP 4.3.2 or newer
6 
 *
7 
 * @package		CodeIgniter
8 
 * @author		ExpressionEngine Dev Team
9 
 * @copyright	Copyright (c) 2008, EllisLab, Inc.
10 
 * @license		http://codeigniter.com/user_guide/license.html
11 
 * @link		http://codeigniter.com
12 
 * @since		Version 1.0
13 
 * @filesource
14 
 */
15
16 
// ------------------------------------------------------------------------
17
18 
/**
19 
 * Image Manipulation class
20 
 *
21 
 * @package		CodeIgniter
22 
 * @subpackage	Libraries
23 
 * @category	Image_lib
24 
 * @author		ExpressionEngine Dev Team
25 
 * @link		http://codeigniter.com/user_guide/libraries/image_lib.html
26 
 */
27 
class CI_Image_lib {
28
29 
	var $image_library		= 'gd2';  	// Can be:  imagemagick, netpbm, gd, gd2
30 
	var $library_path		= '';
31 
	var $dynamic_output		= FALSE;	// Whether to send to browser or write to disk
32 
	var $source_image		= '';
33 
	var $new_image			= '';
34 
	var $width				= '';
35 
	var $height				= '';
36 
	var $quality			= '90';
37 
	var $create_thumb		= FALSE;
38 
	var $thumb_marker		= '_thumb';
39 
	var $maintain_ratio		= TRUE;  	// Whether to maintain aspect ratio when resizing or use hard values
40 
	var $master_dim			= 'auto';	// auto, height, or width.  Determines what to use as the master dimension
41 
	var $rotation_angle		= '';
42 
	var $x_axis				= '';
43 
	var	$y_axis				= '';
44
45 
	// Watermark Vars
46 
	var $wm_text			= '';			// Watermark text if graphic is not used
47 
	var $wm_type			= 'text';		// Type of watermarking.  Options:  text/overlay
48 
	var $wm_x_transp		= 4;
49 
	var $wm_y_transp		= 4;
50 
	var $wm_overlay_path	= '';			// Watermark image path
51 
	var $wm_font_path		= '';			// TT font
52 
	var $wm_font_size		= 17;			// Font size (different versions of GD will either use points or pixels)
53 
	var $wm_vrt_alignment	= 'B';			// Vertical alignment:   T M B
54 
	var $wm_hor_alignment	= 'C';			// Horizontal alignment: L R C
55 
	var $wm_padding			= 0;			// Padding around text
56 
	var $wm_hor_offset		= 0;			// Lets you push text to the right
57 
	var $wm_vrt_offset		= 0;			 // Lets you push  text down
58 
	var $wm_font_color		= '#ffffff';	// Text color
59 
	var $wm_shadow_color	= '';			// Dropshadow color
60 
	var $wm_shadow_distance	= 2;			// Dropshadow distance
61 
	var $wm_opacity			= 50; 			// Image opacity: 1 - 100  Only works with image
62
63 
	// Private Vars
64 
	var $source_folder		= '';
65 
	var $dest_folder		= '';
66 
	var $mime_type			= '';
67 
	var $orig_width			= '';
68 
	var $orig_height		= '';
69 
	var $image_type			= '';
70 
	var $size_str			= '';
71 
	var $full_src_path		= '';
72 
	var $full_dst_path		= '';
73 
	var $create_fnc			= 'imagecreatetruecolor';
74 
	var $copy_fnc			= 'imagecopyresampled';
75 
	var $error_msg			= array();
76 
	var $wm_use_drop_shadow	= FALSE;
77 
	var $wm_use_truetype	= FALSE;
78
79 
	/**
80 
	 * Constructor
81 
	 *
82 
	 * @access	public
83 
	 * @param	string
84 
	 * @return	void
85 
	 */
86 
	function CI_Image_lib($props = array())
87 
	{
88 
		if (count($props) > 0)
89 
		{
90 
			$this->initialize($props);
91 
		}
92
93 
		log_message('debug', "Image Lib Class Initialized");
94 
	}
95
96 
	// --------------------------------------------------------------------
97
98 
	/**
99 
	 * Initialize image properties
100 
	 *
101 
	 * Resets values in case this class is used in a loop
102 
	 *
103 
	 * @access	public
104 
	 * @return	void
105 
	 */
106 
	function clear()
107 
	{
108 
		$props = array('source_folder', 'dest_folder', 'source_image', 'full_src_path', 'full_dst_path', 'new_image', 'image_type', 'size_str', 'quality', 'orig_width', 'orig_height', 'rotation_angle', 'x_axis', 'y_axis', 'create_fnc', 'copy_fnc', 'wm_overlay_path', 'wm_use_truetype', 'dynamic_output', 'wm_font_size', 'wm_text', 'wm_vrt_alignment', 'wm_hor_alignment', 'wm_padding', 'wm_hor_offset', 'wm_vrt_offset', 'wm_font_color', 'wm_use_drop_shadow', 'wm_shadow_color', 'wm_shadow_distance', 'wm_opacity');
109
110 
		foreach ($props as $val)
111 
		{
112 
			$this->$val = '';
113 
		}
114
115 
		// special consideration for master_dim
116 
		$this->master_dim = 'auto';
117 
	}
118
119 
	// --------------------------------------------------------------------
120
121 
	/**
122 
	 * initialize image preferences
123 
	 *
124 
	 * @access	public
125 
	 * @param	array
126 
	 * @return	void
127 
	 */
128 
	function initialize($props = array())
129 
	{
130 
		/*
131 
		 * Convert array elements into class variables
132 
		 */
133 
		if (count($props) > 0)
134 
		{
135 
			foreach ($props as $key => $val)
136 
			{
137 
				$this->$key = $val;
138 
			}
139 
		}
140
141 
		/*
142 
		 * Is there a source image?
143 
		 *
144 
		 * If not, there's no reason to continue
145 
		 *
146 
		 */
147 
		if ($this->source_image == '')
148 
		{
149 
			$this->set_error('imglib_source_image_required');
150 
			return FALSE;
151 
		}
152
153 
		/*
154 
		 * Is getimagesize() Available?
155 
		 *
156 
		 * We use it to determine the image properties (width/height).
157 
		 * Note:  We need to figure out how to determine image
158 
		 * properties using ImageMagick and NetPBM
159 
		 *
160 
		 */
161 
		if ( ! function_exists('getimagesize'))
162 
		{
163 
			$this->set_error('imglib_gd_required_for_props');
164 
			return FALSE;
165 
		}
166
167 
		$this->image_library = strtolower($this->image_library);
168
169 
		/*
170 
		 * Set the full server path
171 
		 *
172 
		 * The source image may or may not contain a path.
173 
		 * Either way, we'll try use realpath to generate the
174 
		 * full server path in order to more reliably read it.
175 
		 *
176 
		 */
177 
		if (function_exists('realpath') AND @realpath($this->source_image) !== FALSE)
178 
		{
179 
			$full_source_path = str_replace("\\", "/", realpath($this->source_image));
180 
		}
181 
		else
182 
		{
183 
			$full_source_path = $this->source_image;
184 
		}
185
186 
		$x = explode('/', $full_source_path);
187 
		$this->source_image = end($x);
188 
		$this->source_folder = str_replace($this->source_image, '', $full_source_path);
189
190 
		// Set the Image Properties
191 
		if ( ! $this->get_image_properties($this->source_folder.$this->source_image))
192 
		{
193 
			return FALSE;
194 
		}
195
196 
		/*
197 
		 * Assign the "new" image name/path
198 
		 *
199 
		 * If the user has set a "new_image" name it means
200 
		 * we are making a copy of the source image. If not
201 
		 * it means we are altering the original.  We'll
202 
		 * set the destination filename and path accordingly.
203 
		 *
204 
		 */
205 
		if ($this->new_image == '')
206 
		{
207 
			$this->dest_image = $this->source_image;
208 
			$this->dest_folder = $this->source_folder;
209 
		}
210 
		else
211 
		{
212 
			if (strpos($this->new_image, '/') === FALSE)
213 
			{
214 
				$this->dest_folder = $this->source_folder;
215 
				$this->dest_image = $this->new_image;
216 
			}
217 
			else
218 
			{
219 
				if (function_exists('realpath') AND @realpath($this->new_image) !== FALSE)
220 
				{
221 
					$full_dest_path = str_replace("\\", "/", realpath($this->new_image));
222 
				}
223 
				else
224 
				{
225 
					$full_dest_path = $this->new_image;
226 
				}
227
228 
				// Is there a file name?
229 
				if ( ! preg_match("#\.(jpg|jpeg|gif|png)$#i", $full_dest_path))
230 
				{
231 
					$this->dest_folder = $full_dest_path.'/';
232 
					$this->dest_image = $this->source_image;
233 
				}
234 
				else
235 
				{
236 
					$x = explode('/', $full_dest_path);
237 
					$this->dest_image = end($x);
238 
					$this->dest_folder = str_replace($this->dest_image, '', $full_dest_path);
239 
				}
240 
			}
241 
		}
242
243 
		/*
244 
		 * Compile the finalized filenames/paths
245 
		 *
246 
		 * We'll create two master strings containing the
247 
		 * full server path to the source image and the
248 
		 * full server path to the destination image.
249 
		 * We'll also split the destination image name
250 
		 * so we can insert the thumbnail marker if needed.
251 
		 *
252 
		 */
253 
		if ($this->create_thumb === FALSE OR $this->thumb_marker == '')
254 
		{
255 
			$this->thumb_marker = '';
256 
		}
257
258 
		$xp	= $this->explode_name($this->dest_image);
259
260 
		$filename = $xp['name'];
261 
		$file_ext = $xp['ext'];
262
263 
		$this->full_src_path = $this->source_folder.$this->source_image;
264 
		$this->full_dst_path = $this->dest_folder.$filename.$this->thumb_marker.$file_ext;
265
266 
		/*
267 
		 * Should we maintain image proportions?
268 
		 *
269 
		 * When creating thumbs or copies, the target width/height
270 
		 * might not be in correct proportion with the source
271 
		 * image's width/height.  We'll recalculate it here.
272 
		 *
273 
		 */
274 
		if ($this->maintain_ratio === TRUE && ($this->width != '' AND $this->height != ''))
275 
		{
276 
			$this->image_reproportion();
277 
		}
278
279 
		/*
280 
		 * Was a width and height specified?
281 
		 *
282 
		 * If the destination width/height was
283 
		 * not submitted we will use the values
284 
		 * from the actual file
285 
		 *
286 
		 */
287 
		if ($this->width == '')
288 
			$this->width = $this->orig_width;
289
290 
		if ($this->height == '')
291 
			$this->height = $this->orig_height;
292
293 
		// Set the quality
294 
		$this->quality = trim(str_replace("%", "", $this->quality));
295
296 
		if ($this->quality == '' OR $this->quality == 0 OR ! is_numeric($this->quality))
297 
			$this->quality = 90;
298
299 
		// Set the x/y coordinates
300 
		$this->x_axis = ($this->x_axis == '' OR ! is_numeric($this->x_axis)) ? 0 : $this->x_axis;
301 
		$this->y_axis = ($this->y_axis == '' OR ! is_numeric($this->y_axis)) ? 0 : $this->y_axis;
302
303 
		// Watermark-related Stuff...
304 
		if ($this->wm_font_color != '')
305 
		{
306 
			if (strlen($this->wm_font_color) == 6)
307 
			{
308 
				$this->wm_font_color = '#'.$this->wm_font_color;
309 
			}
310 
		}
311
312 
		if ($this->wm_shadow_color != '')
313 
		{
314 
			if (strlen($this->wm_shadow_color) == 6)
315 
			{
316 
				$this->wm_shadow_color = '#'.$this->wm_shadow_color;
317 
			}
318 
		}
319
320 
		if ($this->wm_overlay_path != '')
321 
		{
322 
			$this->wm_overlay_path = str_replace("\\", "/", realpath($this->wm_overlay_path));
323 
		}
324
325 
		if ($this->wm_shadow_color != '')
326 
		{
327 
			$this->wm_use_drop_shadow = TRUE;
328 
		}
329
330 
		if ($this->wm_font_path != '')
331 
		{
332 
			$this->wm_use_truetype = TRUE;
333 
		}
334
335 
		return TRUE;
336 
	}
337
338 
	// --------------------------------------------------------------------
339
340 
	/**
341 
	 * Image Resize
342 
	 *
343 
	 * This is a wrapper function that chooses the proper
344 
	 * resize function based on the protocol specified
345 
	 *
346 
	 * @access	public
347 
	 * @return	bool
348 
	 */
349 
	function resize()
350 
	{
351 
		$protocol = 'image_process_'.$this->image_library;
352
353 
		if (eregi("gd2$", $protocol))
354 
		{
355 
			$protocol = 'image_process_gd';
356 
		}
357
358 
		return $this->$protocol('resize');
359 
	}
360
361 
	// --------------------------------------------------------------------
362
363 
	/**
364 
	 * Image Crop
365 
	 *
366 
	 * This is a wrapper function that chooses the proper
367 
	 * cropping function based on the protocol specified
368 
	 *
369 
	 * @access	public
370 
	 * @return	bool
371 
	 */
372 
	function crop()
373 
	{
374 
		$protocol = 'image_process_'.$this->image_library;
375
376 
		if (eregi("gd2$", $protocol))
377 
		{
378 
			$protocol = 'image_process_gd';
379 
		}
380
381 
		return $this->$protocol('crop');
382 
	}
383
384 
	// --------------------------------------------------------------------
385
386 
	/**
387 
	 * Image Rotate
388 
	 *
389 
	 * This is a wrapper function that chooses the proper
390 
	 * rotation function based on the protocol specified
391 
	 *
392 
	 * @access	public
393 
	 * @return	bool
394 
	 */
395 
	function rotate()
396 
	{
397 
		// Allowed rotation values
398 
		$degs = array(90, 180, 270, 'vrt', 'hor');
399
400 
		if ($this->rotation_angle == '' OR ! in_array($this->rotation_angle, $degs, TRUE))
401 
		{
402 
			$this->set_error('imglib_rotation_angle_required');
403 
			return FALSE;
404 
		}
405
406 
		// Reassign the width and height
407 
		if ($this->rotation_angle == 90 OR $this->rotation_angle == 270)
408 
		{
409 
			$this->width	= $this->orig_height;
410 
			$this->height	= $this->orig_width;
411 
		}
412 
		else
413 
		{
414 
			$this->width	= $this->orig_width;
415 
			$this->height	= $this->orig_height;
416 
		}
417
418
419 
		// Choose resizing function
420 
		if ($this->image_library == 'imagemagick' OR $this->image_library == 'netpbm')
421 
		{
422 
			$protocol = 'image_process_'.$this->image_library;
423
424 
			return $this->$protocol('rotate');
425 
		}
426
427 
		if ($this->rotation_angle == 'hor' OR $this->rotation_angle == 'vrt')
428 
		{
429 
			return $this->image_mirror_gd();
430 
		}
431 
		else
432 
		{
433 
			return $this->image_rotate_gd();
434 
		}
435 
	}
436
437 
	// --------------------------------------------------------------------
438
439 
	/**
440 
	 * Image Process Using GD/GD2
441 
	 *
442 
	 * This function will resize or crop
443 
	 *
444 
	 * @access	public
445 
	 * @param	string
446 
	 * @return	bool
447 
	 */
448 
	function image_process_gd($action = 'resize')
449 
	{
450 
		$v2_override = FALSE;
451
452 
		// If the target width/height match the source, AND if the new file name is not equal to the old file name
453 
		// we'll simply make a copy of the original with the new name... assuming dynamic rendering is off.
454 
		if ($this->dynamic_output === FALSE)
455 
		{
456 
			if ($this->orig_width == $this->width AND $this->orig_height == $this->height)
457 
			{
458 
 				if ($this->source_image != $this->new_image)
459 
 				{
460 
					if (@copy($this->full_src_path, $this->full_dst_path))
461 
					{
462 
						@chmod($this->full_dst_path, DIR_WRITE_MODE);
463 
					}
464 
				}
465
466 
				return TRUE;
467 
			}
468 
		}
469
470 
		// Let's set up our values based on the action
471 
		if ($action == 'crop')
472 
		{
473 
			//  Reassign the source width/height if cropping
474 
			$this->orig_width  = $this->width;
475 
			$this->orig_height = $this->height;
476
477 
			// GD 2.0 has a cropping bug so we'll test for it
478 
			if ($this->gd_version() !== FALSE)
479 
			{
480 
				$gd_version = str_replace('0', '', $this->gd_version());
481 
				$v2_override = ($gd_version == 2) ? TRUE : FALSE;
482 
			}
483 
		}
484 
		else
485 
		{
486 
			// If resizing the x/y axis must be zero
487 
			$this->x_axis = 0;
488 
			$this->y_axis = 0;
489 
		}
490
491 
		//  Create the image handle
492 
		if ( ! ($src_img = $this->image_create_gd()))
493 
		{
494 
			return FALSE;
495 
		}
496
497 
 		//  Create The Image
498 
		//
499 
		//  old conditional which users report cause problems with shared GD libs who report themselves as "2.0 or greater"
500 
		//  it appears that this is no longer the issue that it was in 2004, so we've removed it, retaining it in the comment
501 
		//  below should that ever prove inaccurate.
502 
		//
503 
		//  if ($this->image_library == 'gd2' AND function_exists('imagecreatetruecolor') AND $v2_override == FALSE)
504 
 		if ($this->image_library == 'gd2' AND function_exists('imagecreatetruecolor'))
505 
		{
506 
			$create	= 'imagecreatetruecolor';
507 
			$copy	= 'imagecopyresampled';
508 
		}
509 
		else
510 
		{
511 
			$create	= 'imagecreate';
512 
			$copy	= 'imagecopyresized';
513 
		}
514
515 
		$dst_img = $create($this->width, $this->height);
516 
		$copy($dst_img, $src_img, 0, 0, $this->x_axis, $this->y_axis, $this->width, $this->height, $this->orig_width, $this->orig_height);
517
518 
		//  Show the image
519 
		if ($this->dynamic_output == TRUE)
520 
		{
521 
			$this->image_display_gd($dst_img);
522 
		}
523 
		else
524 
		{
525 
			// Or save it
526 
			if ( ! $this->image_save_gd($dst_img))
527 
			{
528 
				return FALSE;
529 
			}
530 
		}
531
532 
		//  Kill the file handles
533 
		imagedestroy($dst_img);
534 
		imagedestroy($src_img);
535
536 
		// Set the file to 777
537 
		@chmod($this->full_dst_path, DIR_WRITE_MODE);
538
539 
		return TRUE;
540 
	}
541
542 
	// --------------------------------------------------------------------
543
544 
	/**
545 
	 * Image Process Using ImageMagick
546 
	 *
547 
	 * This function will resize, crop or rotate
548 
	 *
549 
	 * @access	public
550 
	 * @param	string
551 
	 * @return	bool
552 
	 */
553 
	function image_process_imagemagick($action = 'resize')
554 
	{
555 
		//  Do we have a vaild library path?
556 
		if ($this->library_path == '')
557 
		{
558 
			$this->set_error('imglib_libpath_invalid');
559 
			return FALSE;
560 
		}
561
562 
		if ( ! eregi("convert$", $this->library_path))
563 
		{
564 
			if ( ! eregi("/$", $this->library_path)) $this->library_path .= "/";
565
566 
			$this->library_path .= 'convert';
567 
		}
568
569 
		// Execute the command
570 
		$cmd = $this->library_path." -quality ".$this->quality;
571
572 
		if ($action == 'crop')
573 
		{
574 
			$cmd .= " -crop ".$this->width."x".$this->height."+".$this->x_axis."+".$this->y_axis." \"$this->full_src_path\" \"$this->full_dst_path\" 2>&1";
575 
		}
576 
		elseif ($action == 'rotate')
577 
		{
578 
			switch ($this->rotation_angle)
579 
			{
580 
				case 'hor' 	: $angle = '-flop';
581 
					break;
582 
				case 'vrt' 	: $angle = '-flip';
583 
					break;
584 
				default		: $angle = '-rotate '.$this->rotation_angle;
585 
					break;
586 
			}
587
588 
			$cmd .= " ".$angle." \"$this->full_src_path\" \"$this->full_dst_path\" 2>&1";
589 
		}
590 
		else  // Resize
591 
		{
592 
			$cmd .= " -resize ".$this->width."x".$this->height." \"$this->full_src_path\" \"$this->full_dst_path\" 2>&1";
593 
		}
594
595 
		$retval = 1;
596
597 
		@exec($cmd, $output, $retval);
598
599 
		//	Did it work?
600 
		if ($retval > 0)
601 
		{
602 
			$this->set_error('imglib_image_process_failed');
603 
			return FALSE;
604 
		}
605
606 
		// Set the file to 777
607 
		@chmod($this->full_dst_path, DIR_WRITE_MODE);
608
609 
		return TRUE;
610 
	}
611
612 
	// --------------------------------------------------------------------
613
614 
	/**
615 
	 * Image Process Using NetPBM
616 
	 *
617 
	 * This function will resize, crop or rotate
618 
	 *
619 
	 * @access	public
620 
	 * @param	string
621 
	 * @return	bool
622 
	 */
623 
	function image_process_netpbm($action = 'resize')
624 
	{
625 
		if ($this->library_path == '')
626 
		{
627 
			$this->set_error('imglib_libpath_invalid');
628 
			return FALSE;
629 
		}
630
631 
		//  Build the resizing command
632 
		switch ($this->image_type)
633 
		{
634 
			case 1 :
635 
						$cmd_in		= 'giftopnm';
636 
						$cmd_out	= 'ppmtogif';
637 
				break;
638 
			case 2 :
639 
						$cmd_in		= 'jpegtopnm';
640 
						$cmd_out	= 'ppmtojpeg';
641 
				break;
642 
			case 3 :
643 
						$cmd_in		= 'pngtopnm';
644 
						$cmd_out	= 'ppmtopng';
645 
				break;
646 
		}
647
648 
		if ($action == 'crop')
649 
		{
650 
			$cmd_inner = 'pnmcut -left '.$this->x_axis.' -top '.$this->y_axis.' -width '.$this->width.' -height '.$this->height;
651 
		}
652 
		elseif ($action == 'rotate')
653 
		{
654 
			switch ($this->rotation_angle)
655 
			{
656 
				case 90		:	$angle = 'r270';
657 
					break;
658 
				case 180	:	$angle = 'r180';
659 
					break;
660 
				case 270 	:	$angle = 'r90';
661 
					break;
662 
				case 'vrt'	:	$angle = 'tb';
663 
					break;
664 
				case 'hor'	:	$angle = 'lr';
665 
					break;
666 
			}
667
668 
			$cmd_inner = 'pnmflip -'.$angle.' ';
669 
		}
670 
		else // Resize
671 
		{
672 
			$cmd_inner = 'pnmscale -xysize '.$this->width.' '.$this->height;
673 
		}
674
675 
		$cmd = $this->library_path.$cmd_in.' '.$this->full_src_path.' | '.$cmd_inner.' | '.$cmd_out.' > '.$this->dest_folder.'netpbm.tmp';
676
677 
		$retval = 1;
678
679 
		@exec($cmd, $output, $retval);
680
681 
		//  Did it work?
682 
		if ($retval > 0)
683 
		{
684 
			$this->set_error('imglib_image_process_failed');
685 
			return FALSE;
686 
		}
687
688 
		// With NetPBM we have to create a temporary image.
689 
		// If you try manipulating the original it fails so
690 
		// we have to rename the temp file.
691 
		copy ($this->dest_folder.'netpbm.tmp', $this->full_dst_path);
692 
		unlink ($this->dest_folder.'netpbm.tmp');
693 
		@chmod($this->full_dst_path, DIR_WRITE_MODE);
694
695 
		return TRUE;
696 
	}
697
698 
	// --------------------------------------------------------------------
699
700 
	/**
701 
	 * Image Rotate Using GD
702 
	 *
703 
	 * @access	public
704 
	 * @return	bool
705 
	 */
706 
	function image_rotate_gd()
707 
	{
708 
		// Is Image Rotation Supported?
709 
		// this function is only supported as of PHP 4.3
710 
		if ( ! function_exists('imagerotate'))
711 
		{
712 
			$this->set_error('imglib_rotate_unsupported');
713 
			return FALSE;
714 
		}
715
716 
		//  Create the image handle
717 
		if ( ! ($src_img = $this->image_create_gd()))
718 
		{
719 
			return FALSE;
720 
		}
721
722 
		// Set the background color
723 
		// This won't work with transparent PNG files so we are
724 
		// going to have to figure out how to determine the color
725 
		// of the alpha channel in a future release.
726
727 
		$white	= imagecolorallocate($src_img, 255, 255, 255);
728
729 
		//  Rotate it!
730 
		$dst_img = imagerotate($src_img, $this->rotation_angle, $white);
731
732 
		//  Save the Image
733 
		if ($this->dynamic_output == TRUE)
734 
		{
735 
			$this->image_display_gd($dst_img);
736 
		}
737 
		else
738 
		{
739 
			// Or save it
740 
			if ( ! $this->image_save_gd($dst_img))
741 
			{
742 
				return FALSE;
743 
			}
744 
		}
745
746 
		//  Kill the file handles
747 
		imagedestroy($dst_img);
748 
		imagedestroy($src_img);
749
750 
		// Set the file to 777
751
752 
		@chmod($this->full_dst_path, DIR_WRITE_MODE);
753
754 
		return true;
755 
	}
756
757 
	// --------------------------------------------------------------------
758
759 
	/**
760 
	 * Create Mirror Image using GD
761 
	 *
762 
	 * This function will flip horizontal or vertical
763 
	 *
764 
	 * @access	public
765 
	 * @return	bool
766 
	 */
767 
	function image_mirror_gd()
768 
	{
769 
		if ( ! $src_img = $this->image_create_gd())
770 
		{
771 
			return FALSE;
772 
		}
773
774 
		$width  = $this->orig_width;
775 
		$height = $this->orig_height;
776
777 
		if ($this->rotation_angle == 'hor')
778 
		{
779 
			for ($i = 0; $i < $height; $i++)
780 
			{
781 
				$left  = 0;
782 
				$right = $width-1;
783
784 
				while ($left < $right)
785 
				{
786 
					$cl = imagecolorat($src_img, $left, $i);
787 
					$cr = imagecolorat($src_img, $right, $i);
788
789 
					imagesetpixel($src_img, $left, $i, $cr);
790 
					imagesetpixel($src_img, $right, $i, $cl);
791
792 
					$left++;
793 
					$right--;
794 
				}
795 
			}
796 
		}
797 
		else
798 
		{
799 
			for ($i = 0; $i < $width; $i++)
800 
			{
801 
				$top = 0;
802 
				$bot = $height-1;
803
804 
				while ($top < $bot)
805 
				{
806 
					$ct = imagecolorat($src_img, $i, $top);
807 
					$cb = imagecolorat($src_img, $i, $bot);
808
809 
					imagesetpixel($src_img, $i, $top, $cb);
810 
					imagesetpixel($src_img, $i, $bot, $ct);
811
812 
					$top++;
813 
					$bot--;
814 
				}
815 
			}
816 
		}
817
818 
		//  Show the image
819 
		if ($this->dynamic_output == TRUE)
820 
		{
821 
			$this->image_display_gd($src_img);
822 
		}
823 
		else
824 
		{
825 
			// Or save it
826 
			if ( ! $this->image_save_gd($src_img))
827 
			{
828 
				return FALSE;
829 
			}
830 
		}
831
832 
		//  Kill the file handles
833 
		imagedestroy($src_img);
834
835 
		// Set the file to 777
836 
		@chmod($this->full_dst_path, DIR_WRITE_MODE);
837
838 
		return TRUE;
839 
	}
840
841 
	// --------------------------------------------------------------------
842
843 
	/**
844 
	 * Image Watermark
845 
	 *
846 
	 * This is a wrapper function that chooses the type
847 
	 * of watermarking based on the specified preference.
848 
	 *
849 
	 * @access	public
850 
	 * @param	string
851 
	 * @return	bool
852 
	 */
853 
	function watermark()
854 
	{
855 
		if ($this->wm_type == 'overlay')
856 
		{
857 
			return $this->overlay_watermark();
858 
		}
859 
		else
860 
		{
861 
			return $this->text_watermark();
862 
		}
863 
	}
864
865 
	// --------------------------------------------------------------------
866
867 
	/**
868 
	 * Watermark - Graphic Version
869 
	 *
870 
	 * @access	public
871 
	 * @return	bool
872 
	 */
873 
	function overlay_watermark()
874 
	{
875 
		if ( ! function_exists('imagecolortransparent'))
876 
		{
877 
			$this->set_error('imglib_gd_required');
878 
			return FALSE;
879 
		}
880
881 
		//  Fetch source image properties
882 
		$this->get_image_properties();
883
884 
		//  Fetch watermark image properties
885 
		$props 			= $this->get_image_properties($this->wm_overlay_path, TRUE);
886 
		$wm_img_type	= $props['image_type'];
887 
		$wm_width		= $props['width'];
888 
		$wm_height		= $props['height'];
889
890 
		//  Create two image resources
891 
		$wm_img  = $this->image_create_gd($this->wm_overlay_path, $wm_img_type);
892 
		$src_img = $this->image_create_gd($this->full_src_path);
893
894 
		// Reverse the offset if necessary
895 
		// When the image is positioned at the bottom
896 
		// we don't want the vertical offset to push it
897 
		// further down.  We want the reverse, so we'll
898 
		// invert the offset.  Same with the horizontal
899 
		// offset when the image is at the right
900
901 
		$this->wm_vrt_alignment = strtoupper(substr($this->wm_vrt_alignment, 0, 1));
902 
		$this->wm_hor_alignment = strtoupper(substr($this->wm_hor_alignment, 0, 1));
903
904 
		if ($this->wm_vrt_alignment == 'B')
905 
			$this->wm_vrt_offset = $this->wm_vrt_offset * -1;
906
907 
		if ($this->wm_hor_alignment == 'R')
908 
			$this->wm_hor_offset = $this->wm_hor_offset * -1;
909
910 
		//  Set the base x and y axis values
911 
		$x_axis = $this->wm_hor_offset + $this->wm_padding;
912 
		$y_axis = $this->wm_vrt_offset + $this->wm_padding;
913
914 
		//  Set the vertical position
915 
		switch ($this->wm_vrt_alignment)
916 
		{
917 
			case 'T':
918 
				break;
919 
			case 'M':	$y_axis += ($this->orig_height / 2) - ($wm_height / 2);
920 
				break;
921 
			case 'B':	$y_axis += $this->orig_height - $wm_height;
922 
				break;
923 
		}
924
925 
		//  Set the horizontal position
926 
		switch ($this->wm_hor_alignment)
927 
		{
928 
			case 'L':
929 
				break;
930 
			case 'C':	$x_axis += ($this->orig_width / 2) - ($wm_width / 2);
931 
				break;
932 
			case 'R':	$x_axis += $this->orig_width - $wm_width;
933 
				break;
934 
		}
935
936 
		//  Build the finalized image
937 
		if ($wm_img_type == 3 AND function_exists('imagealphablending'))
938 
		{
939 
			@imagealphablending($src_img, TRUE);
940 
		}
941
942 
		// Set RGB values for text and shadow
943 
		$rgba = imagecolorat($wm_img, $this->wm_x_transp, $this->wm_y_transp);
944 
		$alpha = ($rgba & 0x7F000000) >> 24;
945
946 
		// make a best guess as to whether we're dealing with an image with alpha transparency or no/binary transparency
947 
		if ($alpha > 0)
948 
		{
949 
			// copy the image directly, the image's alpha transparency being the sole determinant of blending
950 
			imagecopy($src_img, $wm_img, $x_axis, $y_axis, 0, 0, $wm_width, $wm_height);
951 
		}
952 
		else
953 
		{
954 
			// set our RGB value from above to be transparent and merge the images with the specified opacity
955 
			imagecolortransparent($wm_img, imagecolorat($wm_img, $this->wm_x_transp, $this->wm_y_transp));
956 
			imagecopymerge($src_img, $wm_img, $x_axis, $y_axis, 0, 0, $wm_width, $wm_height, $this->wm_opacity);
957 
		}
958
959 
		//  Output the image
960 
		if ($this->dynamic_output == TRUE)
961 
		{
962 
			$this->image_display_gd($src_img);
963 
		}
964 
		else
965 
		{
966 
			if ( ! $this->image_save_gd($src_img))
967 
			{
968 
				return FALSE;
969 
			}
970 
		}
971
972 
		imagedestroy($src_img);
973 
		imagedestroy($wm_img);
974
975 
		return TRUE;
976 
	}
977
978 
	// --------------------------------------------------------------------
979
980 
	/**
981 
	 * Watermark - Text Version
982 
	 *
983 
	 * @access	public
984 
	 * @return	bool
985 
	 */
986 
	function text_watermark()
987 
	{
988 
		if ( ! ($src_img = $this->image_create_gd()))
989 
		{
990 
			return FALSE;
991 
		}
992
993 
		if ($this->wm_use_truetype == TRUE AND ! file_exists($this->wm_font_path))
994 
		{
995 
			$this->set_error('imglib_missing_font');
996 
			return FALSE;
997 
		}
998
999 
		//  Fetch source image properties
1000 
		$this->get_image_properties();
1001
1002 
		// Set RGB values for text and shadow
1003 
		$this->wm_font_color	= str_replace('#', '', $this->wm_font_color);
1004 
		$this->wm_shadow_color	= str_replace('#', '', $this->wm_shadow_color);
1005
1006 
		$R1 = hexdec(substr($this->wm_font_color, 0, 2));
1007 
		$G1 = hexdec(substr($this->wm_font_color, 2, 2));
1008 
		$B1 = hexdec(substr($this->wm_font_color, 4, 2));
1009
1010 
		$R2 = hexdec(substr($this->wm_shadow_color, 0, 2));
1011 
		$G2 = hexdec(substr($this->wm_shadow_color, 2, 2));
1012 
		$B2 = hexdec(substr($this->wm_shadow_color, 4, 2));
1013
1014 
		$txt_color	= imagecolorclosest($src_img, $R1, $G1, $B1);
1015 
		$drp_color	= imagecolorclosest($src_img, $R2, $G2, $B2);
1016
1017 
		// Reverse the vertical offset
1018 
		// When the image is positioned at the bottom
1019 
		// we don't want the vertical offset to push it
1020 
		// further down.  We want the reverse, so we'll
1021 
		// invert the offset.  Note: The horizontal
1022 
		// offset flips itself automatically
1023
1024 
		if ($this->wm_vrt_alignment == 'B')
1025 
			$this->wm_vrt_offset = $this->wm_vrt_offset * -1;
1026
1027 
		if ($this->wm_hor_alignment == 'R')
1028 
			$this->wm_hor_offset = $this->wm_hor_offset * -1;
1029
1030 
		// Set font width and height
1031 
		// These are calculated differently depending on
1032 
		// whether we are using the true type font or not
1033 
		if ($this->wm_use_truetype == TRUE)
1034 
		{
1035 
			if ($this->wm_font_size == '')
1036 
				$this->wm_font_size = '17';
1037
1038 
			$fontwidth  = $this->wm_font_size-($this->wm_font_size/4);
1039 
			$fontheight = $this->wm_font_size;
1040 
			$this->wm_vrt_offset += $this->wm_font_size;
1041 
		}
1042 
		else
1043 
		{
1044 
			$fontwidth  = imagefontwidth($this->wm_font_size);
1045 
			$fontheight = imagefontheight($this->wm_font_size);
1046 
		}
1047
1048 
		// Set base X and Y axis values
1049 
		$x_axis = $this->wm_hor_offset + $this->wm_padding;
1050 
		$y_axis = $this->wm_vrt_offset + $this->wm_padding;
1051
1052 
		// Set verticle alignment
1053 
		if ($this->wm_use_drop_shadow == FALSE)
1054 
			$this->wm_shadow_distance = 0;
1055
1056 
		$this->wm_vrt_alignment = strtoupper(substr($this->wm_vrt_alignment, 0, 1));
1057 
		$this->wm_hor_alignment = strtoupper(substr($this->wm_hor_alignment, 0, 1));
1058
1059 
		switch ($this->wm_vrt_alignment)
1060 
		{
1061 
			case	 "T" :
1062 
				break;
1063 
			case "M":	$y_axis += ($this->orig_height/2)+($fontheight/2);
1064 
				break;
1065 
			case "B":	$y_axis += ($this->orig_height - $fontheight - $this->wm_shadow_distance - ($fontheight/2));
1066 
				break;
1067 
		}
1068
1069 
		$x_shad = $x_axis + $this->wm_shadow_distance;
1070 
		$y_shad = $y_axis + $this->wm_shadow_distance;
1071
1072 
		// Set horizontal alignment
1073 
		switch ($this->wm_hor_alignment)
1074 
		{
1075 
			case "L":
1076 
				break;
1077 
			case "R":
1078 
						if ($this->wm_use_drop_shadow)
1079 
							$x_shad += ($this->orig_width - $fontwidth*strlen($this->wm_text));
1080 
							$x_axis += ($this->orig_width - $fontwidth*strlen($this->wm_text));
1081 
				break;
1082 
			case "C":
1083 
						if ($this->wm_use_drop_shadow)
1084 
							$x_shad += floor(($this->orig_width - $fontwidth*strlen($this->wm_text))/2);
1085 
							$x_axis += floor(($this->orig_width  -$fontwidth*strlen($this->wm_text))/2);
1086 
				break;
1087 
		}
1088
1089 
		//  Add the text to the source image
1090 
		if ($this->wm_use_truetype)
1091 
		{
1092 
			if ($this->wm_use_drop_shadow)
1093 
				imagettftext($src_img, $this->wm_font_size, 0, $x_shad, $y_shad, $drp_color, $this->wm_font_path, $this->wm_text);
1094 
				imagettftext($src_img, $this->wm_font_size, 0, $x_axis, $y_axis, $txt_color, $this->wm_font_path, $this->wm_text);
1095 
		}
1096 
		else
1097 
		{
1098 
			if ($this->wm_use_drop_shadow)
1099 
				imagestring($src_img, $this->wm_font_size, $x_shad, $y_shad, $this->wm_text, $drp_color);
1100 
				imagestring($src_img, $this->wm_font_size, $x_axis, $y_axis, $this->wm_text, $txt_color);
1101 
		}
1102
1103 
		//  Output the final image
1104 
		if ($this->dynamic_output == TRUE)
1105 
		{
1106 
			$this->image_display_gd($src_img);
1107 
		}
1108 
		else
1109 
		{
1110 
			$this->image_save_gd($src_img);
1111 
		}
1112
1113 
		imagedestroy($src_img);
1114
1115 
		return TRUE;
1116 
	}
1117
1118 
	// --------------------------------------------------------------------
1119
1120 
	/**
1121 
	 * Create Image - GD
1122 
	 *
1123 
	 * This simply creates an image resource handle
1124 
	 * based on the type of image being processed
1125 
	 *
1126 
	 * @access	public
1127 
	 * @param	string
1128 
	 * @return	resource
1129 
	 */
1130 
	function image_create_gd($path = '', $image_type = '')
1131 
	{
1132 
		if ($path == '')
1133 
			$path = $this->full_src_path;
1134
1135 
		if ($image_type == '')
1136 
			$image_type = $this->image_type;
1137
1138
1139 
		switch ($image_type)
1140 
		{
1141 
			case	 1 :
1142 
						if ( ! function_exists('imagecreatefromgif'))
1143 
						{
1144 
							$this->set_error(array('imglib_unsupported_imagecreate', 'imglib_gif_not_supported'));
1145 
							return FALSE;
1146 
						}
1147
1148 
						return imagecreatefromgif($path);
1149 
				break;
1150 
			case 2 :
1151 
						if ( ! function_exists('imagecreatefromjpeg'))
1152 
						{
1153 
							$this->set_error(array('imglib_unsupported_imagecreate', 'imglib_jpg_not_supported'));
1154 
							return FALSE;
1155 
						}
1156
1157 
						return imagecreatefromjpeg($path);
1158 
				break;
1159 
			case 3 :
1160 
						if ( ! function_exists('imagecreatefrompng'))
1161 
						{
1162 
							$this->set_error(array('imglib_unsupported_imagecreate', 'imglib_png_not_supported'));
1163 
							return FALSE;
1164 
						}
1165
1166 
						return imagecreatefrompng($path);
1167 
				break;
1168
1169 
		}
1170
1171 
		$this->set_error(array('imglib_unsupported_imagecreate'));
1172 
		return FALSE;
1173 
	}
1174
1175 
	// --------------------------------------------------------------------
1176
1177 
	/**
1178 
	 * Write image file to disk - GD
1179 
	 *
1180 
	 * Takes an image resource as input and writes the file
1181 
	 * to the specified destination
1182 
	 *
1183 
	 * @access	public
1184 
	 * @param	resource
1185 
	 * @return	bool
1186 
	 */
1187 
	function image_save_gd($resource)
1188 
	{
1189 
		switch ($this->image_type)
1190 
		{
1191 
			case 1 :
1192 
						if ( ! function_exists('imagegif'))
1193 
						{
1194 
							$this->set_error(array('imglib_unsupported_imagecreate', 'imglib_gif_not_supported'));
1195 
							return FALSE;
1196 
						}
1197
1198 
						@imagegif($resource, $this->full_dst_path);
1199 
				break;
1200 
			case 2	:
1201 
						if ( ! function_exists('imagejpeg'))
1202 
						{
1203 
							$this->set_error(array('imglib_unsupported_imagecreate', 'imglib_jpg_not_supported'));
1204 
							return FALSE;
1205 
						}
1206
1207 
						if (phpversion() == '4.4.1')
1208 
						{
1209 
							@touch($this->full_dst_path); // PHP 4.4.1 bug #35060 - workaround
1210 
						}
1211
1212 
						@imagejpeg($resource, $this->full_dst_path, $this->quality);
1213 
				break;
1214 
			case 3	:
1215 
						if ( ! function_exists('imagepng'))
1216 
						{
1217 
							$this->set_error(array('imglib_unsupported_imagecreate', 'imglib_png_not_supported'));
1218 
							return FALSE;
1219 
						}
1220
1221 
						@imagepng($resource, $this->full_dst_path);
1222 
				break;
1223 
			default		:
1224 
							$this->set_error(array('imglib_unsupported_imagecreate'));
1225 
							return FALSE;
1226 
				break;
1227 
		}
1228
1229 
		return TRUE;
1230 
	}
1231
1232 
	// --------------------------------------------------------------------
1233
1234 
	/**
1235 
	 * Dynamically outputs an image
1236 
	 *
1237 
	 * @access	public
1238 
	 * @param	resource
1239 
	 * @return	void
1240 
	 */
1241 
	function image_display_gd($resource)
1242 
	{
1243 
		header("Content-Disposition: filename={$this->source_image};");
1244 
		header("Content-Type: {$this->mime_type}");
1245 
		header('Content-Transfer-Encoding: binary');
1246 
		header('Last-Modified: '.gmdate('D, d M Y H:i:s', time()).' GMT');
1247
1248 
		switch ($this->image_type)
1249 
		{
1250 
			case 1 		:	imagegif($resource);
1251 
				break;
1252 
			case 2		:	imagejpeg($resource, '', $this->quality);
1253 
				break;
1254 
			case 3		:	imagepng($resource);
1255 
				break;
1256 
			default		:	echo 'Unable to display the image';
1257 
				break;
1258 
		}
1259 
	}
1260
1261 
	// --------------------------------------------------------------------
1262
1263 
	/**
1264 
	 * Re-proportion Image Width/Height
1265 
	 *
1266 
	 * When creating thumbs, the desired width/height
1267 
	 * can end up warping the image due to an incorrect
1268 
	 * ratio between the full-sized image and the thumb.
1269 
	 *
1270 
	 * This function lets us re-proportion the width/height
1271 
	 * if users choose to maintain the aspect ratio when resizing.
1272 
	 *
1273 
	 * @access	public
1274 
	 * @return	void
1275 
	 */
1276 
	function image_reproportion()
1277 
	{
1278 
		if ( ! is_numeric($this->width) OR ! is_numeric($this->height) OR $this->width == 0 OR $this->height == 0)
1279 
			return;
1280
1281 
		if ( ! is_numeric($this->orig_width) OR ! is_numeric($this->orig_height) OR $this->orig_width == 0 OR $this->orig_height == 0)
1282 
			return;
1283
1284 
		$new_width	= ceil($this->orig_width*$this->height/$this->orig_height);
1285 
		$new_height	= ceil($this->width*$this->orig_height/$this->orig_width);
1286
1287 
		$ratio = (($this->orig_height/$this->orig_width) - ($this->height/$this->width));
1288
1289 
		if ($this->master_dim != 'width' AND $this->master_dim != 'height')
1290 
		{
1291 
			$this->master_dim = ($ratio < 0) ? 'width' : 'height';
1292 
		}
1293
1294 
		if (($this->width != $new_width) AND ($this->height != $new_height))
1295 
		{
1296 
			if ($this->master_dim == 'height')
1297 
			{
1298 
				$this->width = $new_width;
1299 
			}
1300 
			else
1301 
			{
1302 
				$this->height = $new_height;
1303 
			}
1304 
		}
1305 
	}
1306
1307 
	// --------------------------------------------------------------------
1308
1309 
	/**
1310 
	 * Get image properties
1311 
	 *
1312 
	 * A helper function that gets info about the file
1313 
	 *
1314 
	 * @access	public
1315 
	 * @param	string
1316 
	 * @return	mixed
1317 
	 */
1318 
	function get_image_properties($path = '', $return = FALSE)
1319 
	{
1320 
		// For now we require GD but we should
1321 
		// find a way to determine this using IM or NetPBM
1322
1323 
		if ($path == '')
1324 
			$path = $this->full_src_path;
1325
1326 
		if ( ! file_exists($path))
1327 
		{
1328 
			$this->set_error('imglib_invalid_path');
1329 
			return FALSE;
1330 
		}
1331
1332 
		$vals = @getimagesize($path);
1333
1334 
		$types = array(1 => 'gif', 2 => 'jpeg', 3 => 'png');
1335
1336 
		$mime = (isset($types[$vals['2']])) ? 'image/'.$types[$vals['2']] : 'image/jpg';
1337
1338 
		if ($return == TRUE)
1339 
		{
1340 
			$v['width']			= $vals['0'];
1341 
			$v['height']		= $vals['1'];
1342 
			$v['image_type']	= $vals['2'];
1343 
			$v['size_str']		= $vals['3'];
1344 
			$v['mime_type']		= $mime;
1345
1346 
			return $v;
1347 
		}
1348
1349 
		$this->orig_width	= $vals['0'];
1350 
		$this->orig_height	= $vals['1'];
1351 
		$this->image_type	= $vals['2'];
1352 
		$this->size_str		= $vals['3'];
1353 
		$this->mime_type	= $mime;
1354
1355 
		return TRUE;
1356 
	}
1357
1358 
	// --------------------------------------------------------------------
1359
1360 
	/**
1361 
	 * Size calculator
1362 
	 *
1363 
	 * This function takes a known width x height and
1364 
	 * recalculates it to a new size.  Only one
1365 
	 * new variable needs to be known
1366 
	 *
1367 
	 *	$props = array(
1368 
	 *					'width' 		=> $width,
1369 
	 *					'height' 		=> $height,
1370 
	 *					'new_width'		=> 40,
1371 
	 *					'new_height'	=> ''
1372 
	 *				  );
1373 
	 *
1374 
	 * @access	public
1375 
	 * @param	array
1376 
	 * @return	array
1377 
	 */
1378 
	function size_calculator($vals)
1379 
	{
1380 
		if ( ! is_array($vals))
1381 
			return;
1382
1383 
		$allowed = array('new_width', 'new_height', 'width', 'height');
1384
1385 
		foreach ($allowed as $item)
1386 
		{
1387 
			if ( ! isset($vals[$item]) OR $vals[$item] == '')
1388 
				$vals[$item] = 0;
1389 
		}
1390
1391 
		if ($vals['width'] == 0 OR $vals['height'] == 0)
1392 
		{
1393 
			return $vals;
1394 
		}
1395
1396 
		if ($vals['new_width'] == 0)
1397 
		{
1398 
			$vals['new_width'] = ceil($vals['width']*$vals['new_height']/$vals['height']);
1399 
		}
1400 
		elseif ($vals['new_height'] == 0)
1401 
		{
1402 
			$vals['new_height'] = ceil($vals['new_width']*$vals['height']/$vals['width']);
1403 
		}
1404
1405 
		return $vals;
1406 
	}
1407
1408 
	// --------------------------------------------------------------------
1409
1410 
	/**
1411 
	 * Explode source_image
1412 
	 *
1413 
	 * This is a helper function that extracts the extension
1414 
	 * from the source_image.  This function lets us deal with
1415 
	 * source_images with multiple periods, like:  my.cool.jpg
1416 
	 * It returns an associative array with two elements:
1417 
	 * $array['ext']  = '.jpg';
1418 
	 * $array['name'] = 'my.cool';
1419 
	 *
1420 
	 * @access	public
1421 
	 * @param	array
1422 
	 * @return	array
1423 
	 */
1424 
	function explode_name($source_image)
1425 
	{
1426 
		$x = explode('.', $source_image);
1427 
		$ret['ext'] = '.'.end($x);
1428
1429 
		$name = '';
1430
1431 
		$ct = count($x)-1;
1432
1433 
		for ($i = 0; $i < $ct; $i++)
1434 
		{
1435 
			$name .= $x[$i];
1436
1437 
			if ($i < ($ct - 1))
1438 
			{
1439 
				$name .= '.';
1440 
			}
1441 
		}
1442
1443 
		$ret['name'] = $name;
1444
1445 
		return $ret;
1446 
	}
1447
1448 
	// --------------------------------------------------------------------
1449
1450 
	/**
1451 
	 * Is GD Installed?
1452 
	 *
1453 
	 * @access	public
1454 
	 * @return	bool
1455 
	 */
1456 
	function gd_loaded()
1457 
	{
1458 
		if ( ! extension_loaded('gd'))
1459 
		{
1460 
			if ( ! dl('gd.so'))
1461 
			{
1462 
				return FALSE;
1463 
			}
1464 
		}
1465
1466 
		return TRUE;
1467 
	}
1468
1469 
	// --------------------------------------------------------------------
1470
1471 
	/**
1472 
	 * Get GD version
1473 
	 *
1474 
	 * @access	public
1475 
	 * @return	mixed
1476 
	 */
1477 
	function gd_version()
1478 
	{
1479 
		if (function_exists('gd_info'))
1480 
		{
1481 
			$gd_version = @gd_info();
1482 
			$gd_version = preg_replace("/\D/", "", $gd_version['GD Version']);
1483
1484 
			return $gd_version;
1485 
		}
1486
1487 
		return FALSE;
1488 
	}
1489
1490 
	// --------------------------------------------------------------------
1491
1492 
	/**
1493 
	 * Set error message
1494 
	 *
1495 
	 * @access	public
1496 
	 * @param	string
1497 
	 * @return	void
1498 
	 */
1499 
	function set_error($msg)
1500 
	{
1501 
		$CI =& get_instance();
1502 
		$CI->lang->load('imglib');
1503
1504 
		if (is_array($msg))
1505 
		{
1506 
			foreach ($msg as $val)
1507 
			{
1508
1509 
				$msg = ($CI->lang->line($val) == FALSE) ? $val : $CI->lang->line($val);
1510 
				$this->error_msg[] = $msg;
1511 
				log_message('error', $msg);
1512 
			}
1513 
		}
1514 
		else
1515 
		{
1516 
			$msg = ($CI->lang->line($msg) == FALSE) ? $msg : $CI->lang->line($msg);
1517 
			$this->error_msg[] = $msg;
1518 
			log_message('error', $msg);
1519 
		}
1520 
	}
1521
1522 
	// --------------------------------------------------------------------
1523
1524 
	/**
1525 
	 * Show error messages
1526 
	 *
1527 
	 * @access	public
1528 
	 * @param	string
1529 
	 * @return	string
1530 
	 */
1531 
	function display_errors($open = '<p>', $close = '</p>')
1532 
	{
1533 
		$str = '';
1534 
		foreach ($this->error_msg as $val)
1535 
		{
1536 
			$str .= $open.$val.$close;
1537 
		}
1538
1539 
		return $str;
1540 
	}
1541
1542 
}
1543 
// END Image_lib Class
1544
1545 
/* End of file Image_lib.php */
1546 
/* Location: ./system/libraries/Image_lib.php */