|
|
|
|
<?php
|
|
|
|
|
/***************************************************************************
|
|
|
|
|
* Original floIcon copyright (C) 2007 by Joshua Hatfield. *
|
|
|
|
|
* *
|
|
|
|
|
* In order to use any part of this floIcon Class, you must comply with *
|
|
|
|
|
* the license in 'license.doc'. In particular, you may not remove this *
|
|
|
|
|
* copyright notice. *
|
|
|
|
|
* *
|
|
|
|
|
* Much time and thought has gone into this software and you are *
|
|
|
|
|
* benefitting. We hope that you share your changes too. What goes *
|
|
|
|
|
* around, comes around. *
|
|
|
|
|
***************************************************************************
|
|
|
|
|
|
|
|
|
|
Version 1.1.1:
|
|
|
|
|
Date: 2009-03-16
|
|
|
|
|
|
|
|
|
|
Changes:
|
|
|
|
|
I was a little hasty on that last update. A couple new bugs from 1.1.0 have
|
|
|
|
|
been fixed.
|
|
|
|
|
|
|
|
|
|
Version 1.1.0:
|
|
|
|
|
Date: 2009-03-16
|
|
|
|
|
|
|
|
|
|
Changes:
|
|
|
|
|
Added Vista support.
|
|
|
|
|
Fixed a number of minor bugs. Many thanks to Dvir Berebi for pointing
|
|
|
|
|
them out.
|
|
|
|
|
|
|
|
|
|
Version 1.0.5:
|
|
|
|
|
Date: 2009-03-15
|
|
|
|
|
|
|
|
|
|
Changes:
|
|
|
|
|
Fixed bug when operating on low bit count images (1 or 4) with odd dimensions.
|
|
|
|
|
|
|
|
|
|
Version 1.0.4:
|
|
|
|
|
Date: 2007-05-25
|
|
|
|
|
|
|
|
|
|
Changes:
|
|
|
|
|
Made function not break quite so bad when reading a PNG file on a Vista icon.
|
|
|
|
|
Now, you shouldn't be loading Vista icons anyways, but since I'm trying to
|
|
|
|
|
upgrade to Vista compatible and I need a comparison, I've got to.
|
|
|
|
|
|
|
|
|
|
Version 1.0.3:
|
|
|
|
|
Date: 2007-05-25
|
|
|
|
|
|
|
|
|
|
Changes:
|
|
|
|
|
Okay, this one was just stupid. When adding large image support, I messed up
|
|
|
|
|
and when reading, it doubled the image size. Now, it's fixed.
|
|
|
|
|
I took the opportunity to also add a dummy AND map for 32 images on those
|
|
|
|
|
readers who might be looking for it (though it's not supposed to be used.)
|
|
|
|
|
|
|
|
|
|
Version 1.0.2:
|
|
|
|
|
Date: 2007-05-24
|
|
|
|
|
|
|
|
|
|
Sorry about two versions so quickly back to back, but something needed to be
|
|
|
|
|
done with speed...things were getting too slow. I'm sure you'll be okay.
|
|
|
|
|
|
|
|
|
|
Changes:
|
|
|
|
|
Told palette determination to stop at 257 colors or is 32 bit because the
|
|
|
|
|
palette is not used at that point and gets really slow when it starts
|
|
|
|
|
getting into the high numbers, for instance, in photographs or gradient
|
|
|
|
|
truecolor images with lots of unique colors.
|
|
|
|
|
After experimenting, it appears that Windows XP does in fact support 256x256
|
|
|
|
|
images and larger by setting the entry value to 0 in the 1 byte that holds
|
|
|
|
|
that value and storing the true dimentions in the image header later. Of
|
|
|
|
|
course, it still doesn't use these images in normal operation. XP will
|
|
|
|
|
resize these and use them if no other images are available.
|
|
|
|
|
Wrapped main documentation (this) to the 80th column for easier reading.
|
|
|
|
|
|
|
|
|
|
Version 1.0.1:
|
|
|
|
|
Date: 2007-05-23
|
|
|
|
|
|
|
|
|
|
Thank you everyone for actively using the implementation on my site and
|
|
|
|
|
illuminating me very quickly to a number of glaring bugs in this class.
|
|
|
|
|
|
|
|
|
|
Changes:
|
|
|
|
|
Added version history.
|
|
|
|
|
Fixed bug with non-standard sizes in AND map reading AND writing.
|
|
|
|
|
Fixed bug with palette images using non-black color in backgrounds.
|
|
|
|
|
Fixed bug with height/width reversal reading files.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Version 1.0.0:
|
|
|
|
|
Date: 2007-05-17
|
|
|
|
|
Original release date.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Foreword:
|
|
|
|
|
If you are simply in the effort of making an ICO file, may I recommend visiting
|
|
|
|
|
my site, http://www.flobi.com/ , and clicking on floIcon. I have a fully
|
|
|
|
|
functional implementation (on which the sample.php is based) where you can also
|
|
|
|
|
see recent icons submitted by other visitors. No registration required, no
|
|
|
|
|
intrusive ads. (As of this writing, there aren't actually any ads at all, I
|
|
|
|
|
might add google ads at some point.)
|
|
|
|
|
|
|
|
|
|
If you are trying to get an idea of how ICO files, work, may I recommend the
|
|
|
|
|
page I used, http://www.daubnet.com/formats/ICO.html . It does not fully cover
|
|
|
|
|
icon files, but it does a very good job of what it does. Any additional
|
|
|
|
|
information, I will try to post at
|
|
|
|
|
http://www.flobi.com/test/floIcon/more_on_icons.php for your convenience.
|
|
|
|
|
|
|
|
|
|
If you are trying to get an idea of how image resource files work, I recommend
|
|
|
|
|
ANY other class that deals with images. This class essentially plots points on
|
|
|
|
|
the image, and that's not perticularly advanced.
|
|
|
|
|
|
|
|
|
|
For any purpose, I wish you luck and feel free to contact me with any bugs,
|
|
|
|
|
comments, questions, etc. - Flobi
|
|
|
|
|
|
|
|
|
|
Summary:
|
|
|
|
|
This class parses ICO files. It reads directly from the ICO file, headers
|
|
|
|
|
first, so that if you are only retrieving 1 image, the entire ICO file need not
|
|
|
|
|
be parsed. It supports merging ICO files. It supports adding PHP image
|
|
|
|
|
resources as new images to the file. It has an export capability that can
|
|
|
|
|
easily be written to a new (or the same) ICO file for saving ICO files. All
|
|
|
|
|
sizes from 1x1 to 255x255 pixels and 1, 4, 8, 24 (plus transparency) and 32 bit
|
|
|
|
|
images are supported. Image retrieval by size is supported.
|
|
|
|
|
|
|
|
|
|
Included is a fully functional sample that allows users to upload ICO, GIF,
|
|
|
|
|
JPEG and PNG files into a session icon file as well as remove images from the
|
|
|
|
|
file and download the completed file (sample.php).
|
|
|
|
|
|
|
|
|
|
Known Limitations: Does not support Vista icons. Does not support inversion
|
|
|
|
|
palette method (because of the limitations of the PHP image resource).
|
|
|
|
|
|
|
|
|
|
Addendum on Limitations:
|
|
|
|
|
Windows Vista has added support for 256x256 size icons and now stores files as
|
|
|
|
|
PNG's. This class is for older ICO files. A new class is currently under
|
|
|
|
|
development that supports the new Windows Vista format.
|
|
|
|
|
|
|
|
|
|
Palette inversion (my name for this technique) is the technique of using a black
|
|
|
|
|
pixel (0, 0, 0) with a 1 "AND" pixel. White pixels with a 1 "AND" show
|
|
|
|
|
transparent (or "don't" show). Black pixels with a 1 "AND" show inverted
|
|
|
|
|
(sometimes). Because this method isn't uniformly supported or documented and
|
|
|
|
|
the PHP image resource doesn't support it, I have decided to not as well. This
|
|
|
|
|
does not apply to 32 bit images which include alpha transparency and no AND map.
|
|
|
|
|
|
|
|
|
|
Though other functions exist, these are the only ones I believe offer usefulness
|
|
|
|
|
to be public.
|
|
|
|
|
floIcon public functions:
|
|
|
|
|
readICO($file, $offset = 0)
|
|
|
|
|
Loads the icon from the specified filepath ($file) starting at the
|
|
|
|
|
specified file offset ($offset). This function MERGES the loaded icon
|
|
|
|
|
images into the floIcon object.
|
|
|
|
|
|
|
|
|
|
formatICO($offset = 0)
|
|
|
|
|
Returns the current floIcon object formatted as an .ICO file with the
|
|
|
|
|
file offset altered by $offset. If there are too many or too large
|
|
|
|
|
images, causing any images saved past the 4,294,967,296th byte, this
|
|
|
|
|
will return false. (This is well outside PHP's default memory
|
|
|
|
|
allocation.)
|
|
|
|
|
|
|
|
|
|
addImage($imageResource, $desiredBitCount = 1, $pngIfWidthExceeds = 48)
|
|
|
|
|
Adds an icon image to the icon file based on the passed image resource
|
|
|
|
|
($imageResource). It will automatically determine the bit count, but
|
|
|
|
|
can be persuaded to increase that to $desiredBitCount if that value is
|
|
|
|
|
greater than the determined bit count.
|
|
|
|
|
|
|
|
|
|
NOTE: The image resource is saved by REFERRENCE. So, if you edit it
|
|
|
|
|
then call getImage, the resource returned will be the same, editions and
|
|
|
|
|
all. Destruction of the resource will cause a new resource to be
|
|
|
|
|
created in getImage().
|
|
|
|
|
|
|
|
|
|
getImage($offset)
|
|
|
|
|
Returns the php image resource either assigned by addImage or created
|
|
|
|
|
dynamically at calltime by the data loaded with readICO(). The offset
|
|
|
|
|
specified here ($offset) is the array offset starting at 0 and ending
|
|
|
|
|
at countImages().
|
|
|
|
|
|
|
|
|
|
getBestImage($height = 32, $width = 32)
|
|
|
|
|
Returns the php images resource of the highest quality image closest to
|
|
|
|
|
the size specified. This could be useful when you only want to display
|
|
|
|
|
the icon in an icon list with a single representative icon. A resized
|
|
|
|
|
copy of the highest quality available image will be returned if there is
|
|
|
|
|
no 32 or 24 bit icon present at the speficied dimentions.
|
|
|
|
|
|
|
|
|
|
sortImagesBySize()
|
|
|
|
|
Sorts the $this->images array by order of size, smallest to largest.
|
|
|
|
|
This is the optimal sorting for icon files.
|
|
|
|
|
|
|
|
|
|
countImages()
|
|
|
|
|
Returns a count of how many images are present in the current floIcon
|
|
|
|
|
object.
|
|
|
|
|
|
|
|
|
|
floIcon public variables:
|
|
|
|
|
$images
|
|
|
|
|
Contains a numerically indexed array of floIconImage objects.
|
|
|
|
|
$updated
|
|
|
|
|
True if an image has been added since load or last formatICO, otherwise
|
|
|
|
|
false.
|
|
|
|
|
|
|
|
|
|
floIconImage public functions:
|
|
|
|
|
getHeader()
|
|
|
|
|
Returns an associative array containing the information from the ICO
|
|
|
|
|
image header.
|
|
|
|
|
|
|
|
|
|
getEntry()
|
|
|
|
|
Returns an associative array containing the information from the ICO
|
|
|
|
|
entry header.
|
|
|
|
|
|
|
|
|
|
NOTE: If this icon image was created by php image resource, this may not
|
|
|
|
|
have accurate information until saving from floIcon with the formatICO()
|
|
|
|
|
function. Specifically, offset information will be inaccurate.
|
|
|
|
|
|
|
|
|
|
getImageResource()
|
|
|
|
|
Returns a php image resource. Same as floIcon's getImage() function.
|
|
|
|
|
|
|
|
|
|
setImageResource($imageResource, $desiredBitCount = 1, $pngIfWidthExceeds = 48)
|
|
|
|
|
Changes this icon image based on the passed image resource
|
|
|
|
|
($imageResource). It will automatically determine the bit count, but can
|
|
|
|
|
be persuaded to increase that to $desiredBitCount if that value is
|
|
|
|
|
greater than the determined bit count.
|
|
|
|
|
|
|
|
|
|
NOTE: The image resource is saved by REFERRENCE. So, if you edit it
|
|
|
|
|
then call getImageResource, the resource returned will be the same,
|
|
|
|
|
editions and all. Destruction of the resource will cause a new resource
|
|
|
|
|
to be created in getImageResource().
|
|
|
|
|
|
|
|
|
|
dealocateResource()
|
|
|
|
|
This destroys the image resource variable, freeing up memory. The image
|
|
|
|
|
will automatically be recreated when getImageResource is executed.
|
|
|
|
|
*/
|
|
|
|
|
class floIcon {
|
|
|
|
|
/*
|
|
|
|
|
* $images is an associative array of offset integer => floIconImage object
|
|
|
|
|
*/
|
|
|
|
|
var $images; // Array of floIconImage objects.
|
|
|
|
|
var $updated = false;
|
|
|
|
|
function floIcon() {
|
|
|
|
|
$this->images = array();
|
|
|
|
|
}
|
|
|
|
|
function countImages() {
|
|
|
|
|
return count($this->images);
|
|
|
|
|
}
|
|
|
|
|
function getBestImage($height = 32, $width = 32) {
|
|
|
|
|
$best = false;
|
|
|
|
|
$bestEntry = array();
|
|
|
|
|
$secondBest = false;
|
|
|
|
|
$secondBestEntry = array();
|
|
|
|
|
foreach ($this->images as $key => $image) {
|
|
|
|
|
$entry = $image->getEntry();
|
|
|
|
|
$header = $image->getHeader();
|
|
|
|
|
if (!@$entry["BitCount"]) {
|
|
|
|
|
$entry["BitCount"] = $header["BitCount"];
|
|
|
|
|
}
|
|
|
|
|
if ($entry["Height"] == $height && $entry["Width"] == $width && $entry["BitCount"] == 32) {
|
|
|
|
|
return $image->getImageResource();
|
|
|
|
|
} elseif ($entry["Height"] == $height && $entry["Width"] == $width && $entry["BitCount"] > min(4, @$bestEntry["BitCount"])) {
|
|
|
|
|
$best = $image;
|
|
|
|
|
$bestEntry = $entry;
|
|
|
|
|
} elseif (
|
|
|
|
|
!$secondBest or
|
|
|
|
|
$entry["Height"] >= $secondBestEntry["Height"] &&
|
|
|
|
|
$entry["Width"] >= $secondBestEntry["Width"] &&
|
|
|
|
|
$secondBestEntry["BitCount"] >= $secondBestEntry["BitCount"] and
|
|
|
|
|
(
|
|
|
|
|
$entry["Height"] <= 64 && $entry["Height"] > $secondBestEntry["Height"] and
|
|
|
|
|
$entry["Height"] > 64 && $entry["Height"] < $secondBestEntry["Height"]
|
|
|
|
|
) ||
|
|
|
|
|
(
|
|
|
|
|
$entry["Width"] <= 64 && $entry["Width"] > $secondBestEntry["Width"] and
|
|
|
|
|
$entry["Width"] > 64 && $entry["Width"] < $secondBestEntry["Width"]
|
|
|
|
|
) ||
|
|
|
|
|
$secondBestEntry["BitCount"] > $secondBestEntry["BitCount"]
|
|
|
|
|
) {
|
|
|
|
|
$secondBest = $image;
|
|
|
|
|
$secondBestEntry = $entry;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ($best) {
|
|
|
|
|
return $best->getImageResource();
|
|
|
|
|
} elseif ($secondBest) {
|
|
|
|
|
if ($secondBestEntry["Width"] != $width || $secondBestEntry["Height"] != $height) {
|
|
|
|
|
$imageResource = $secondBest->getImageResource();
|
|
|
|
|
$newImageResource = imagecreatetruecolor($width, $height);
|
|
|
|
|
imagesavealpha($newImageResource, true);
|
|
|
|
|
imagealphablending($newImageResource, false);
|
|
|
|
|
imagecopyresampled($newImageResource, $imageResource, 0, 0, 0, 0, $width, $height, $secondBestEntry["Width"], $secondBestEntry["Height"]);
|
|
|
|
|
$this->addImage($newImageResource, 32);
|
|
|
|
|
return $newImageResource;
|
|
|
|
|
} else {
|
|
|
|
|
return $secondBest->getImageResource();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* readICO merges the icon images from the file to the current list
|
|
|
|
|
*/
|
|
|
|
|
function readICO($file, $offset = 0) {
|
|
|
|
|
if (file_exists($file) && filesize($file) > 0 && $filePointer = fopen($file, "r")) {
|
|
|
|
|
fseek($filePointer, $offset);
|
|
|
|
|
$header = unpack("SReserved/SType/SCount", fread($filePointer, 6));
|
|
|
|
|
for ($t = 0; $t < $header["Count"]; $t++) {
|
|
|
|
|
$newImage = new floIconImage();
|
|
|
|
|
if ($newImage->readImageFromICO($filePointer, 6 + ($t * 16))) {
|
|
|
|
|
$this->images[] = $newImage;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
fclose($filePointer);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
function sortImagesBySize() {
|
|
|
|
|
usort($this->images, array("floIcon", "_cmpObj"));
|
|
|
|
|
}
|
|
|
|
|
function formatICO($offset = 0) {
|
|
|
|
|
$this->updated = false;
|
|
|
|
|
$output = "";
|
|
|
|
|
$output .= pack("SSS", 0, 1, count($this->images));
|
|
|
|
|
$output_images = "";
|
|
|
|
|
foreach ($this->images as $image) {
|
|
|
|
|
$newImageOffset = $offset + // Whatever offset we've been given.
|
|
|
|
|
6 // Header.
|
|
|
|
|
+ (count($this->images) * 16) // Entries.
|
|
|
|
|
+ strlen($output_images);
|
|
|
|
|
if ($newImageOffset > pow(256, 4) /* 4 bytes available for position */ ) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
$output .= $image->formatEntryForIco($newImageOffset); // The images already in there.
|
|
|
|
|
$output_images .= $image->formatImageForIco();
|
|
|
|
|
}
|
|
|
|
|
return $output.$output_images;
|
|
|
|
|
}
|
|
|
|
|
function _cmpObj($a, $b) {
|
|
|
|
|
$aSize = $a->getSize();
|
|
|
|
|
$bSize = $b->getSize();
|
|
|
|
|
if ($aSize == $bSize) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return ($aSize > $bSize)?1:-1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function addImage($imageResource, $desiredBitCount = 1, $pngIfWidthExceeds = 48) {
|
|
|
|
|
$this->updated = true;
|
|
|
|
|
$newImage = new floIconImage();
|
|
|
|
|
$newImage->setImageResource($imageResource, $desiredBitCount, $pngIfWidthExceeds);
|
|
|
|
|
$this->images[] = $newImage;
|
|
|
|
|
}
|
|
|
|
|
function getImage($offset) {
|
|
|
|
|
if (isset($this->images[$offset])) {
|
|
|
|
|
return $this->images[$offset]->getImageResource();
|
|
|
|
|
} else {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* getSize computes the
|
|
|
|
|
*/
|
|
|
|
|
function getSize() {
|
|
|
|
|
// Compute headers.
|
|
|
|
|
$computedSize = 6; // Always 6 bytes.
|
|
|
|
|
// Add image entry headers
|
|
|
|
|
$computedSize += count($this->images) * 16; // Entry headers are always 16 bytes.
|
|
|
|
|
foreach ($this->images as $image) {
|
|
|
|
|
$computedSize += $image->getSize() + $image->getHeaderSize(); // getSize does not include the header.
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
class floIconImage {
|
|
|
|
|
var $_imageResource = null;
|
|
|
|
|
var $_entry = "";
|
|
|
|
|
var $_entryIconFormat = "";
|
|
|
|
|
var $_header = "";
|
|
|
|
|
var $_headerIconFormat = "";
|
|
|
|
|
var $_imageIconFormat = ""; // Includes palette and mask.
|
|
|
|
|
function formatEntryForIco($offset) {
|
|
|
|
|
// Format the entry, this has to be done here because we need the offset to get the full information.
|
|
|
|
|
$this->_entry["FileOffset"] = $offset;
|
|
|
|
|
$this->_entryIconFormat = pack("CCCCSSLL",
|
|
|
|
|
$this->_entry["Width"]>=256?0:$this->_entry["Width"],
|
|
|
|
|
$this->_entry["Height"]>=256?0:$this->_entry["Height"],
|
|
|
|
|
$this->_entry["ColorCount"],
|
|
|
|
|
$this->_entry["Reserved"],
|
|
|
|
|
$this->_entry["Planes"],
|
|
|
|
|
$this->_entry["BitCount"],
|
|
|
|
|
$this->_entry["SizeInBytes"],
|
|
|
|
|
$this->_entry["FileOffset"]
|
|
|
|
|
);
|
|
|
|
|
return $this->_entryIconFormat;
|
|
|
|
|
}
|
|
|
|
|
function formatImageForIco() {
|
|
|
|
|
// Format the entry, this has to be done here because we need the offset to get the full information.
|
|
|
|
|
return ($this->_headerIconFormat.$this->_imageIconFormat);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Will move $bitCount UP to $desiredBitCount if $bitCount is found to be less than it.
|
|
|
|
|
function setImageResource($imageResource, $desiredBitCount = 1, $pngIfWidthExceeds = 48) {
|
|
|
|
|
imagesavealpha($imageResource, true);
|
|
|
|
|
imagealphablending($imageResource, false);
|
|
|
|
|
$height = imagesy($imageResource);
|
|
|
|
|
$width = imagesx($imageResource);
|
|
|
|
|
|
|
|
|
|
// Parse resource to determine header and icon format
|
|
|
|
|
|
|
|
|
|
// Find Palette information
|
|
|
|
|
$is_32bit = false; // Start with an assumption and get proven wrong.
|
|
|
|
|
$hasTransparency = 0;
|
|
|
|
|
$blackColor = false;
|
|
|
|
|
$bitCount = 0;
|
|
|
|
|
$realPalette = array();
|
|
|
|
|
$realIndexPalette = array();
|
|
|
|
|
for ($x = 0; $x < $width && !$is_32bit; $x++) {
|
|
|
|
|
for ($y = 0; $y < $height && !$is_32bit; $y++) {
|
|
|
|
|
$colorIndex = imagecolorat($imageResource, $x, $y);
|
|
|
|
|
$color = imagecolorsforindex($imageResource, $colorIndex);
|
|
|
|
|
if ($color["alpha"] == 0) {
|
|
|
|
|
// No point continuing if there's more than 256 colors or it's 32bit.
|
|
|
|
|
if (count($realPalette) < 257 && !$is_32bit) {
|
|
|
|
|
$inRealPalette = false;
|
|
|
|
|
foreach($realPalette as $realPaletteKey => $realPaletteColor) {
|
|
|
|
|
if (
|
|
|
|
|
$color["red"] == $realPaletteColor["red"] and
|
|
|
|
|
$color["green"] == $realPaletteColor["green"] and
|
|
|
|
|
$color["blue"] == $realPaletteColor["blue"]
|
|
|
|
|
) {
|
|
|
|
|
$inRealPalette = $realPaletteKey;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ($inRealPalette === false) {
|
|
|
|
|
$realIndexPalette[$colorIndex] = count($realPalette);
|
|
|
|
|
if (
|
|
|
|
|
$blackColor === false and
|
|
|
|
|
$color["red"] == 0 and
|
|
|
|
|
$color["green"] == 0 and
|
|
|
|
|
$color["blue"] == 0
|
|
|
|
|
) {
|
|
|
|
|
$blackColor = count($realPalette);
|
|
|
|
|
}
|
|
|
|
|
$realPalette[] = $color;
|
|
|
|
|
} else {
|
|
|
|
|
$realIndexPalette[$colorIndex] = $inRealPalette;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
$hasTransparency = 1;
|
|
|
|
|
}
|
|
|
|
|
if ($color["alpha"] != 0 && $color["alpha"] != 127) {
|
|
|
|
|
$is_32bit = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ($is_32bit) {
|
|
|
|
|
$colorCount = 0;
|
|
|
|
|
$bitCount = 32;
|
|
|
|
|
} else {
|
|
|
|
|
if ($hasTransparency && $blackColor === false) {
|
|
|
|
|
// We need a black color to facilitate transparency. Unfortunately, this can
|
|
|
|
|
// increase the palette size by 1 if there's no other black color.
|
|
|
|
|
$blackColor = count($realPalette);
|
|
|
|
|
$color = array(
|
|
|
|
|
"red" => 0,
|
|
|
|
|
"blue" => 0,
|
|
|
|
|
"green" => 0,
|
|
|
|
|
"alpha" => 0
|
|
|
|
|
);
|
|
|
|
|
$realPalette[] = $color;
|
|
|
|
|
}
|
|
|
|
|
$colorCount = count($realPalette);
|
|
|
|
|
if ($colorCount > 256 || $colorCount == 0) {
|
|
|
|
|
$bitCount = 24;
|
|
|
|
|
} elseif ($colorCount > 16) {
|
|
|
|
|
$bitCount = 8;
|
|
|
|
|
// 8 bit
|
|
|
|
|
} elseif ($colorCount > 2) {
|
|
|
|
|
$bitCount = 4;
|
|
|
|
|
// 4 bit
|
|
|
|
|
} else {
|
|
|
|
|
$bitCount = 1;
|
|
|
|
|
// 1 bit
|
|
|
|
|
}
|
|
|
|
|
if ($desiredBitCount > $bitCount) {
|
|
|
|
|
$bitCount = $desiredBitCount;
|
|
|
|
|
}
|
|
|
|
|
switch ($bitCount) {
|
|
|
|
|
case 24:
|
|
|
|
|
$colorCount = 0;
|
|
|
|
|
break;
|
|
|
|
|
case 8:
|
|
|
|
|
$colorCount = 256;
|
|
|
|
|
break;
|
|
|
|
|
case 4:
|
|
|
|
|
$colorCount = 16;
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
$colorCount = 2;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// Create $this->_imageIconFormat...
|
|
|
|
|
$this->_imageIconFormat = "";
|
|
|
|
|
if ($bitCount < 24) {
|
|
|
|
|
$iconPalette = array();
|
|
|
|
|
// Save Palette
|
|
|
|
|
foreach ($realIndexPalette as $colorIndex => $paletteIndex) {
|
|
|
|
|
$color = $realPalette[$paletteIndex];
|
|
|
|
|
$this->_imageIconFormat .= pack("CCCC", $color["blue"], $color["green"], $color["red"], 0);
|
|
|
|
|
}
|
|
|
|
|
while (strlen($this->_imageIconFormat) < $colorCount * 4) {
|
|
|
|
|
$this->_imageIconFormat .= pack("CCCC", 0, 0, 0, 0);
|
|
|
|
|
}
|
|
|
|
|
// Save Each Pixel as Palette Entry
|
|
|
|
|
$byte = 0; // For $bitCount < 8 math
|
|
|
|
|
$bitPosition = 0; // For $bitCount < 8 math
|
|
|
|
|
for ($y = 0; $y < $height; $y++) {
|
|
|
|
|
for ($x = 0; $x < $width; $x++) {
|
|
|
|
|
$color = imagecolorat($imageResource, $x, $height-$y-1);
|
|
|
|
|
if (isset($realIndexPalette[$color])) {
|
|
|
|
|
$color = $realIndexPalette[$color];
|
|
|
|
|
} else {
|
|
|
|
|
$color = $blackColor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ($bitCount < 8) {
|
|
|
|
|
$bitPosition += $bitCount;
|
|
|
|
|
$colorAdjusted = $color * pow(2, 8 - $bitPosition);
|
|
|
|
|
$byte += $colorAdjusted;
|
|
|
|
|
if ($bitPosition == 8) {
|
|
|
|
|
$this->_imageIconFormat .= chr($byte);
|
|
|
|
|
$bitPosition = 0;
|
|
|
|
|
$byte = 0;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
$this->_imageIconFormat .= chr($color);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// Each row ends with dumping the remaining bits and filling up to the 32bit line with 0's.
|
|
|
|
|
if ($bitPosition) {
|
|
|
|
|
$this->_imageIconFormat .= chr($byte);
|
|
|
|
|
$bitPosition = 0;
|
|
|
|
|
$byte = 0;
|
|
|
|
|
}
|
|
|
|
|
if (strlen($this->_imageIconFormat)%4) $this->_imageIconFormat .= str_repeat(chr(0), 4-(strlen($this->_imageIconFormat)%4));
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// Save each pixel.
|
|
|
|
|
for ($y = 0; $y < $height; $y++) {
|
|
|
|
|
for ($x = 0; $x < $width; $x++) {
|
|
|
|
|
$color = imagecolorat($imageResource, $x, $height-$y-1);
|
|
|
|
|
$color = imagecolorsforindex($imageResource, $color);
|
|
|
|
|
if ($bitCount == 24) {
|
|
|
|
|
if ($color["alpha"]) {
|
|
|
|
|
$this->_imageIconFormat .= pack("CCC", 0, 0, 0);
|
|
|
|
|
} else {
|
|
|
|
|
$this->_imageIconFormat .= pack("CCC", $color["blue"], $color["green"], $color["red"]);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
$color["alpha"] = round((127-$color["alpha"]) / 127 * 255);
|
|
|
|
|
$this->_imageIconFormat .= pack("CCCC", $color["blue"], $color["green"], $color["red"], $color["alpha"]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (strlen($this->_imageIconFormat)%4) $this->_imageIconFormat .= str_repeat(chr(0), 4-(strlen($this->_imageIconFormat)%4));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// save AND map (transparency)
|
|
|
|
|
$byte = 0; // For $bitCount < 8 math
|
|
|
|
|
$bitPosition = 0; // For $bitCount < 8 math
|
|
|
|
|
for ($y = 0; $y < $height; $y++) {
|
|
|
|
|
for ($x = 0; $x < $width; $x++) {
|
|
|
|
|
if ($bitCount < 32) {
|
|
|
|
|
$color = imagecolorat($imageResource, $x, $height-$y-1);
|
|
|
|
|
$color = imagecolorsforindex($imageResource, $color);
|
|
|
|
|
$color = $color["alpha"] == 127?1:0;
|
|
|
|
|
} else {
|
|
|
|
|
$color = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$bitPosition += 1;
|
|
|
|
|
$colorAdjusted = $color * pow(2, 8 - $bitPosition);
|
|
|
|
|
$byte += $colorAdjusted;
|
|
|
|
|
if ($bitPosition == 8) {
|
|
|
|
|
$this->_imageIconFormat .= chr($byte);
|
|
|
|
|
$bitPosition = 0;
|
|
|
|
|
$byte = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// Each row ends with dumping the remaining bits and filling up to the 32bit line with 0's.
|
|
|
|
|
if ($bitPosition) {
|
|
|
|
|
$this->_imageIconFormat .= chr($byte);
|
|
|
|
|
$bitPosition = 0; // For $bitCount < 8 math
|
|
|
|
|
$byte = 0;
|
|
|
|
|
}
|
|
|
|
|
while (strlen($this->_imageIconFormat)%4) {
|
|
|
|
|
$this->_imageIconFormat .= chr(0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ($colorCount >= 256) {
|
|
|
|
|
$colorCount = 0;
|
|
|
|
|
}
|
|
|
|
|
// Create header information...
|
|
|
|
|
$this->_header = array(
|
|
|
|
|
"Size" => 40,
|
|
|
|
|
"Width" => $width,
|
|
|
|
|
"Height" => $height*2,
|
|
|
|
|
"Planes" => 1,
|
|
|
|
|
"BitCount" => $bitCount,
|
|
|
|
|
"Compression" => 0,
|
|
|
|
|
"ImageSize" => strlen($this->_imageIconFormat),
|
|
|
|
|
"XpixelsPerM" => 0,
|
|
|
|
|
"YpixelsPerM" => 0,
|
|
|
|
|
"ColorsUsed" => $colorCount,
|
|
|
|
|
"ColorsImportant" => 0,
|
|
|
|
|
);
|
|
|
|
|
$this->_headerIconFormat = pack("LLLSSLLLLLL",
|
|
|
|
|
$this->_header["Size"],
|
|
|
|
|
$this->_header["Width"],
|
|
|
|
|
$this->_header["Height"],
|
|
|
|
|
|
|
|
|
|
$this->_header["Planes"],
|
|
|
|
|
$this->_header["BitCount"],
|
|
|
|
|
|
|
|
|
|
$this->_header["Compression"],
|
|
|
|
|
$this->_header["ImageSize"],
|
|
|
|
|
$this->_header["XpixelsPerM"],
|
|
|
|
|
$this->_header["YpixelsPerM"],
|
|
|
|
|
$this->_header["ColorsUsed"],
|
|
|
|
|
$this->_header["ColorsImportant"]
|
|
|
|
|
);
|
|
|
|
|
$this->_entry = array(
|
|
|
|
|
"Width" => $width,
|
|
|
|
|
"Height" => $height,
|
|
|
|
|
"ColorCount" => $colorCount,
|
|
|
|
|
"Reserved" => 0,
|
|
|
|
|
"Planes" => 1,
|
|
|
|
|
"BitCount" => $bitCount,
|
|
|
|
|
"SizeInBytes" => $this->_header["Size"] + $this->_header["ImageSize"],
|
|
|
|
|
"FileOffset" => -1,
|
|
|
|
|
);
|
|
|
|
|
$this->_entryIconFormat = ""; // This won't get set until it's needed with the offset.
|
|
|
|
|
$this->_imageResource = $imageResource;
|
|
|
|
|
|
|
|
|
|
// Make png if width exceeds limit for old ico style
|
|
|
|
|
if ($width > $pngIfWidthExceeds) {
|
|
|
|
|
// I wish there were a better way to get the info than this. If anyone needs a version that doesn't use OB, I can have one that creates a TMP file.
|
|
|
|
|
ob_start();
|
|
|
|
|
imagepng($imageResource);
|
|
|
|
|
$imageAsPng = ob_get_contents();
|
|
|
|
|
ob_end_clean();
|
|
|
|
|
$this->_headerIconFormat = "";
|
|
|
|
|
$this->_imageIconFormat = $imageAsPng;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
function _createImageResource() {
|
|
|
|
|
if ($newImage = @imagecreatefromstring($this->_headerIconFormat.$this->_imageIconFormat)) {
|
|
|
|
|
// Vista supports PNG.
|
|
|
|
|
$this->_headerIconFormat = "";
|
|
|
|
|
$this->_imageIconFormat = $this->_headerIconFormat.$this->_imageIconFormat;
|
|
|
|
|
imagesavealpha($newImage, true);
|
|
|
|
|
imagealphablending($newImage, false);
|
|
|
|
|
$this->_imageResource = $newImage;
|
|
|
|
|
} elseif ($this->_entry["Height"] <= 1024 && $this->_entry["Width"] <= 1024) {
|
|
|
|
|
$newImage = imagecreatetruecolor($this->_entry["Width"], $this->_entry["Height"]);
|
|
|
|
|
imagesavealpha($newImage, true);
|
|
|
|
|
imagealphablending($newImage, false);
|
|
|
|
|
$readPosition = 0;
|
|
|
|
|
$palette = array();
|
|
|
|
|
if ($this->_header["BitCount"] < 24) {
|
|
|
|
|
// Read Palette for low bitcounts
|
|
|
|
|
$colorsInPalette = $this->_header["ColorsUsed"]?$this->_header["ColorsUsed"]:$this->_entry["ColorCount"];
|
|
|
|
|
for ($t = 0; $t < pow(2, $this->_header["BitCount"]); $t++) {
|
|
|
|
|
$blue = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$green = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$red = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$readPosition++; // Unused "Reserved" value.
|
|
|
|
|
$existingPaletteEntry = imagecolorexactalpha($newImage, $red, $green, $blue, 0);
|
|
|
|
|
if ($existingPaletteEntry >= 0) {
|
|
|
|
|
$palette[] = $existingPaletteEntry;
|
|
|
|
|
} else {
|
|
|
|
|
$palette[] = imagecolorallocatealpha($newImage, $red, $green, $blue, 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// XOR
|
|
|
|
|
for ($y = 0; $y < $this->_entry["Height"]; $y++) {
|
|
|
|
|
$colors = array();
|
|
|
|
|
for ($x = 0; $x < $this->_entry["Width"]; $x++) {
|
|
|
|
|
if ($this->_header["BitCount"] < 8) {
|
|
|
|
|
$color = array_shift($colors);
|
|
|
|
|
if (is_null($color)) {
|
|
|
|
|
$byte = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$tmp_color = 0;
|
|
|
|
|
for ($t = 7; $t >= 0; $t--) {
|
|
|
|
|
$bit_value = pow(2, $t);
|
|
|
|
|
$bit = floor($byte / $bit_value);
|
|
|
|
|
$byte = $byte - ($bit * $bit_value);
|
|
|
|
|
$tmp_color += $bit * pow(2, $t%$this->_header["BitCount"]);
|
|
|
|
|
if ($t%$this->_header["BitCount"] == 0) {
|
|
|
|
|
array_push($colors, $tmp_color);
|
|
|
|
|
$tmp_color = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
$color = array_shift($colors);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
$color = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
}
|
|
|
|
|
imagesetpixel($newImage, $x, $this->_entry["Height"]-$y-1, $palette[$color]) or die("can't set pixel");
|
|
|
|
|
}
|
|
|
|
|
// All rows end on the 32 bit
|
|
|
|
|
if ($readPosition%4) $readPosition += 4-($readPosition%4);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// BitCount >= 24, No Palette.
|
|
|
|
|
// marking position because some icons mark all pixels transparent when using an AND map.
|
|
|
|
|
$markPosition = $readPosition;
|
|
|
|
|
$retry = true;
|
|
|
|
|
$ignoreAlpha = false;
|
|
|
|
|
while ($retry) {
|
|
|
|
|
$alphas = array();
|
|
|
|
|
$retry = false;
|
|
|
|
|
for ($y = 0; $y < $this->_entry["Height"] and !$retry; $y++) {
|
|
|
|
|
for ($x = 0; $x < $this->_entry["Width"] and !$retry; $x++) {
|
|
|
|
|
$blue = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$green = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$red = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
if ($this->_header["BitCount"] < 32) {
|
|
|
|
|
$alpha = 0;
|
|
|
|
|
} elseif($ignoreAlpha) {
|
|
|
|
|
$alpha = 0;
|
|
|
|
|
$readPosition++;
|
|
|
|
|
} else {
|
|
|
|
|
$alpha = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$alphas[$alpha] = $alpha;
|
|
|
|
|
$alpha = 127-round($alpha/255*127);
|
|
|
|
|
}
|
|
|
|
|
$paletteEntry = imagecolorexactalpha($newImage, $red, $green, $blue, $alpha);
|
|
|
|
|
if ($paletteEntry < 0) {
|
|
|
|
|
$paletteEntry = imagecolorallocatealpha($newImage, $red, $green, $blue, $alpha);
|
|
|
|
|
}
|
|
|
|
|
imagesetpixel($newImage, $x, $this->_entry["Height"]-$y-1, $paletteEntry) or die("can't set pixel");
|
|
|
|
|
}
|
|
|
|
|
if ($readPosition%4) $readPosition += 4-($readPosition%4);
|
|
|
|
|
}
|
|
|
|
|
if ($this->_header["BitCount"] == 32 && isset($alphas[0]) && count($alphas) == 1) {
|
|
|
|
|
$retry = true;
|
|
|
|
|
$readPosition = $markPosition;
|
|
|
|
|
$ignoreAlpha = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
// AND map
|
|
|
|
|
if ($this->_header["BitCount"] < 32 || $ignoreAlpha) {
|
|
|
|
|
// Bitcount == 32, No AND (if using alpha).
|
|
|
|
|
$palette[-1] = imagecolorallocatealpha($newImage, 0, 0, 0, 127);
|
|
|
|
|
imagecolortransparent($newImage, $palette[-1]);
|
|
|
|
|
for ($y = 0; $y < $this->_entry["Height"]; $y++) {
|
|
|
|
|
$colors = array();
|
|
|
|
|
for ($x = 0; $x < $this->_entry["Width"]; $x++) {
|
|
|
|
|
$color = array_shift($colors);
|
|
|
|
|
if (is_null($color)) {
|
|
|
|
|
$byte = ord($this->_imageIconFormat[$readPosition++]);
|
|
|
|
|
$tmp_color = 0;
|
|
|
|
|
for ($t = 7; $t >= 0; $t--) {
|
|
|
|
|
$bit_value = pow(2, $t);
|
|
|
|
|
$bit = floor($byte / $bit_value);
|
|
|
|
|
$byte = $byte - ($bit * $bit_value);
|
|
|
|
|
array_push($colors, $bit);
|
|
|
|
|
}
|
|
|
|
|
$color = array_shift($colors);
|
|
|
|
|
}
|
|
|
|
|
if ($color) {
|
|
|
|
|
imagesetpixel($newImage, $x, $this->_entry["Height"]-$y-1, $palette[-1]) or die("can't set pixel");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// All rows end on the 32 bit.
|
|
|
|
|
if ($readPosition%4) $readPosition += 4-($readPosition%4);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ($this->_header["BitCount"] < 24) {
|
|
|
|
|
imagetruecolortopalette($newImage, true, pow(2, $this->_header["BitCount"]));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
$this->_imageResource = $newImage;
|
|
|
|
|
}
|
|
|
|
|
// this function expects that $_entry, $_header and $_imageIconFormat have already been read, specifically from readImageFromICO.
|
|
|
|
|
// Don't call this function except from there.
|
|
|
|
|
function readImageFromICO($filePointer, $entryOffset) {
|
|
|
|
|
$tmpPosition = ftell($filePointer); // So any other applications won't loose their position.
|
|
|
|
|
// Get the entry.
|
|
|
|
|
fseek($filePointer, $entryOffset);
|
|
|
|
|
$this->_entryIconFormat = fread($filePointer, 16);
|
|
|
|
|
$this->_entry = unpack("CWidth/CHeight/CColorCount/CReserved/SPlanes/SBitCount/LSizeInBytes/LFileOffset", $this->_entryIconFormat);
|
|
|
|
|
|
|
|
|
|
if ($this->_entry["SizeInBytes"] > 16384)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
// Position the file pointer.
|
|
|
|
|
fseek($filePointer, $this->_entry["FileOffset"]);
|
|
|
|
|
|
|
|
|
|
// Get the header.
|
|
|
|
|
$this->_headerIconFormat = fread($filePointer, 40);
|
|
|
|
|
$this->_header = unpack("LSize/LWidth/LHeight/SPlanes/SBitCount/LCompression/LImageSize/LXpixelsPerM/LYpixelsPerM/LColorsUsed/LColorsImportant", $this->_headerIconFormat);
|
|
|
|
|
|
|
|
|
|
// Get the image.
|
|
|
|
|
$this->_imageIconFormat = @fread($filePointer, $this->_entry["SizeInBytes"] - strlen($this->_headerIconFormat));
|
|
|
|
|
fseek($filePointer, $tmpPosition); // So any other applications won't loose their position.
|
|
|
|
|
|
|
|
|
|
if ($newImage = @imagecreatefromstring($this->_headerIconFormat.$this->_imageIconFormat)) {
|
|
|
|
|
// This is a PNG, the supposed header information is useless.
|
|
|
|
|
$this->_header = array (
|
|
|
|
|
"Size" => 0,
|
|
|
|
|
"Width" => imagesx($newImage),
|
|
|
|
|
"Height" => imagesy($newImage) * 2,
|
|
|
|
|
"Planes" => 0,
|
|
|
|
|
"BitCount" => 32,
|
|
|
|
|
"Compression" => 0,
|
|
|
|
|
"ImageSize" => strlen($this->_imageIconFormat),
|
|
|
|
|
"XpixelsPerM" => 0,
|
|
|
|
|
"YpixelsPerM" => 0,
|
|
|
|
|
"ColorsUsed" => 0,
|
|
|
|
|
"ColorsImportant" => 0,
|
|
|
|
|
);
|
|
|
|
|
imagedestroy($newImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Support for larger images requires entry marked as 0.
|
|
|
|
|
if ($this->_entry["Width"] == 0) {
|
|
|
|
|
$this->_entry["Width"] = $this->_header["Width"];
|
|
|
|
|
}
|
|
|
|
|
if ($this->_entry["Height"] == 0) {
|
|
|
|
|
$this->_entry["Height"] = $this->_header["Height"]/2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
function getHeader() {
|
|
|
|
|
return $this->_header;
|
|
|
|
|
}
|
|
|
|
|
function getEntry() {
|
|
|
|
|
return $this->_entry;
|
|
|
|
|
}
|
|
|
|
|
function floIconImage() {
|
|
|
|
|
}
|
|
|
|
|
function getHeaderSize() {
|
|
|
|
|
return strlen($this->_headerIconFormat);
|
|
|
|
|
}
|
|
|
|
|
function getSize() {
|
|
|
|
|
return strlen($this->_imageIconFormat);
|
|
|
|
|
}
|
|
|
|
|
function getImageResource() {
|
|
|
|
|
if (!$this->_imageResource) $this->_createImageResource();
|
|
|
|
|
return $this->_imageResource;
|
|
|
|
|
}
|
|
|
|
|
function dealocateResource() {
|
|
|
|
|
@imagedestroy($this->_imageResource);
|
|
|
|
|
$this->_imageResource = null;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
?>
|
