CWIS Developer Documentation

- Home
- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

SPTImage.php
Go to the documentation of this file.
1 <?PHP
2 #
3 # FILE: SPTImage.php
4 #
5 # Part of the Collection Workflow Integration System (CWIS)
6 # Copyright 2002-2013 Edward Almasy and Internet Scout Research Group
7 # http://scout.wisc.edu/cwis/
8 #
9
13 class SPTImage
14 {
15
16 # ---- PUBLIC INTERFACE --------------------------------------------------
17
19 const CACHE_PATH = "local/data/caches/ImageLinks";
20
21 const SIZE_FULL = 3;
22 const SIZE_PREVIEW = 2;
23 const SIZE_THUMBNAIL = 1;
24
37 public function __construct($ImageIdOrFileNameOrImageObj,
38 $MaxWidth = NULL, $MaxHeight = NULL,
39 $MaxPreviewWidth = NULL, $MaxPreviewHeight = NULL,
40 $MaxThumbnailWidth = NULL, $MaxThumbnailHeight = NULL)
41 {
42 # clear error status (0 = AI_OKAY)
43 $this->ErrorStatus = 0;
44
45 # trigger the Image class file to be autoloaded since some parts of this
46 # class (SPTImage) use constants defined in it but don't construct Image
47 # objects
48 new Image(NULL);
49
50 # create and save a database handle for our use
51 $this->DB = new Database();
52
53 # if image object was passed in
54 if (is_object($ImageIdOrFileNameOrImageObj)
55 && method_exists($ImageIdOrFileNameOrImageObj, "SPTImage"))
56 {
57 # create copy of image passed in
58 $this->CreateCopyOfImage($ImageIdOrFileNameOrImageObj);
59 }
60 # else if image ID was passed in
61 elseif (($ImageIdOrFileNameOrImageObj > 0)
62 && preg_match("/[0-9]+/", $ImageIdOrFileNameOrImageObj))
63 {
64 # load info on existing image
65 $this->LoadImageInfo($ImageIdOrFileNameOrImageObj);
66 }
67 # else assume that value passed in is file name
68 else
69 {
70 # create new image from named file
71 $this->CreateNewImage($ImageIdOrFileNameOrImageObj,
72 $MaxWidth, $MaxHeight,
73 $MaxPreviewWidth, $MaxPreviewHeight,
74 $MaxThumbnailWidth, $MaxThumbnailHeight);
75 }
76 }
77
82 public function Id()
83 {
84 return $this->Id;
85 }
86
91 public function Url()
92 {
93 $Url = $this->FileName;
94 $SignalResult = $GLOBALS["AF"]->SignalEvent(
95 "EVENT_IMAGE_URL_FILTER", array(
96 "Url" => $Url,
97 "ImageSize" => "Full"));
98 $Url = $SignalResult["Url"];
99 return $Url;
100 }
101
106 public function PreviewUrl()
107 {
108 $Url = $this->PreviewFileName;
109 $SignalResult = $GLOBALS["AF"]->SignalEvent(
110 "EVENT_IMAGE_URL_FILTER", array(
111 "Url" => $Url,
112 "ImageSize" => "Preview"));
113 $Url = $SignalResult["Url"];
114 return $Url;
115 }
116
121 public function ThumbnailUrl()
122 {
123 $Url = $this->ThumbnailFileName;
124 $SignalResult = $GLOBALS["AF"]->SignalEvent(
125 "EVENT_IMAGE_URL_FILTER", array(
126 "Url" => $Url,
127 "ImageSize" => "Thumbnail"));
128 $Url = $SignalResult["Url"];
129 return $Url;
130 }
131
137 public function Format()
138 {
139 return $this->Format;
140 }
141
146 public function Mimetype()
147 {
148 $Image = new Image($this->FileName);
149 return $Image->Mimetype();
150 }
151
156 public function Height()
157 {
158 return $this->Height;
159 }
160
165 public function Width()
166 {
167 return $this->Width;
168 }
169
174 public function PreviewHeight()
175 {
176 return $this->PreviewHeight;
177 }
178
183 public function PreviewWidth()
184 {
185 return $this->PreviewWidth;
186 }
187
192 public function ThumbnailHeight()
193 {
194 return $this->ThumbnailHeight;
195 }
196
201 public function ThumbnailWidth()
202 {
203 return $this->ThumbnailWidth;
204 }
205
210 public static function ImageStorageDirectory()
211 {
212 # for each possible storage location
213 foreach (self::$ImageStorageLocations as $Dir)
214 {
215 # if location exists
216 if (is_dir($Dir))
217 {
218 # return location to caller
219 return $Dir;
220 }
221 }
222
223 # return default (most preferred) location to caller
224 return self::$ImageStorageLocations[0];
225 }
226
231 public static function PreviewStorageDirectory()
232 {
233 # for each possible storage location
234 foreach (self::$PreviewStorageLocations as $Dir)
235 {
236 # if location exists
237 if (is_dir($Dir))
238 {
239 # return location to caller
240 return $Dir;
241 }
242 }
243
244 # return default (most preferred) location to caller
245 return self::$PreviewStorageLocations[0];
246 }
247
252 public static function ThumbnailStorageDirectory()
253 {
254 # for each possible storage location
255 foreach (self::$ThumbnailStorageLocations as $Dir)
256 {
257 # if location exists
258 if (is_dir($Dir))
259 {
260 # return location to caller
261 return $Dir;
262 }
263 }
264
265 # return default (most preferred) location to caller
266 return self::$ThumbnailStorageLocations[0];
267 }
268
273 public function GetLink()
274 {
275 return $this->FileName;
276 }
277
284 public function AltText($NewValue = NULL)
285 {
286 # if new value supplied and new value differs from existing value
287 if (($NewValue !== NULL) && ($NewValue != $this->AltText))
288 {
289 # save new value to database
290 $this->DB->Query("UPDATE Images SET"
291 ." AltText = '".addslashes($NewValue)."'"
292 ." WHERE ImageId = ".$this->Id);
293
294 # save new value locally
295 $this->AltText = $NewValue;
296 }
297
298 # return attribute value to caller
299 return $this->AltText;
300 }
301
307 public function LinkTarget($NewValue = NULL)
308 {
309 if (($NewValue !== NULL) && ($NewValue != $this->LinkTarget))
310 {
311 $this->DB->Query("UPDATE Images SET"
312 ." LinkTarget = '".addslashes($NewValue)."'"
313 ." WHERE ImageId = ".$this->Id);
314 $this->LinkTarget = $NewValue;
315 }
316
317 return $this->LinkTarget;
318 }
319
324 public function Delete()
325 {
326 # delete base image file
327 if (file_exists($this->FileName)) { unlink($this->FileName); }
328
329 # delete preview image file
330 if (file_exists($this->PreviewFileName)) { unlink($this->PreviewFileName); }
331
332 # delete thumbnail image file
333 if (file_exists($this->ThumbnailFileName)) { unlink($this->ThumbnailFileName); }
334
335 # delete image info record in database
336 $this->DB->Query("DELETE FROM Images WHERE ImageId = ".$this->Id);
337 }
338
343 public function Status()
344 {
345 return $this->ErrorStatus;
346 }
347
353 public static function CheckDirectories()
354 {
355 # determine paths
356 $ImagePath = self::ImageStorageDirectory();
357 $PreviewPath = self::PreviewStorageDirectory();
358 $ThumbnailPath = self::ThumbnailStorageDirectory();
359
360 # assume everything will be okay
361 $ErrorsFound = NULL;
362
363 # check base image directory
364 if (!is_dir($ImagePath) || !is_writable($ImagePath))
365 {
366 if (!is_dir($ImagePath))
367 {
368 @mkdir($ImagePath, 0755);
369 }
370 else
371 {
372 @chmod($ImagePath, 0755);
373 }
374 if (!is_dir($ImagePath))
375 {
376 $ErrorsFound[] = "Image Storage Directory Not Found";
377 }
378 elseif (!is_writable($ImagePath))
379 {
380 $ErrorsFound[] = "Image Storage Directory Not Writable";
381 }
382 }
383
384 # check preview directory
385 if (!is_dir($PreviewPath) || !is_writable($PreviewPath))
386 {
387 if (!is_dir($PreviewPath))
388 {
389 @mkdir($PreviewPath, 0755);
390 }
391 else
392 {
393 @chmod($PreviewPath, 0755);
394 }
395 if (!is_dir($PreviewPath))
396 {
397 $ErrorsFound[] = "Preview Storage Directory Not Found";
398 }
399 elseif (!is_writable($PreviewPath))
400 {
401 $ErrorsFound[] = "Preview Storage Directory Not Writable";
402 }
403 }
404
405 # check thumbnail directory
406 if (!is_dir($ThumbnailPath) || !is_writable($ThumbnailPath))
407 {
408 if (!is_dir($ThumbnailPath))
409 {
410 @mkdir($ThumbnailPath, 0755);
411 }
412 else
413 {
414 @chmod($ThumbnailPath, 0755);
415 }
416 if (!is_dir($ThumbnailPath))
417 {
418 $ErrorsFound[] = "Thumbnail Storage Directory Not Found";
419 }
420 elseif (!is_writable($ThumbnailPath))
421 {
422 $ErrorsFound[] = "Thumbnail Storage Directory Not Writable";
423 }
424 }
425
426 # return any errors found to caller
427 return $ErrorsFound;
428 }
429
440 public function Resize($MaxWidth, $MaxHeight,
441 $MaxPreviewWidth, $MaxPreviewHeight,
442 $MaxThumbnailWidth, $MaxThumbnailHeight)
443 {
444 $SrcImage = new Image($this->FileName);
445
446 # scale the original image if necessary
447 $MaxWidth = min($MaxWidth, $SrcImage->XSize());
448 $MaxHeight = min($MaxHeight, $SrcImage->YSize());
449 $SrcImage->ScaleTo($MaxWidth, $MaxHeight, TRUE);
450
451 # save and reload image info
452 $SrcImage->SaveAs($this->FileName);
453 $SrcImage = new Image($this->FileName);
454
455 # retrieve image width and height
456 $this->Height = $SrcImage->YSize();
457 $this->Width = $SrcImage->XSize();
458
459 # generate preview image and calculate width and height
460 $MaxPreviewWidth = min($MaxPreviewWidth, $this->Width);
461 $MaxPreviewHeight = min($MaxPreviewHeight, $this->Height);
462 $SrcImage->ScaleTo($MaxPreviewWidth, $MaxPreviewHeight, TRUE);
463 $SrcImage->SaveAs($this->PreviewFileName);
464 if (($this->Width * $MaxPreviewHeight)
465 > ($this->Height * $MaxPreviewWidth))
466 {
467 $this->PreviewWidth = $MaxPreviewWidth;
468 $this->PreviewHeight =
469 ($MaxPreviewWidth * $SrcImage->YSize()) / $SrcImage->XSize();
470 }
471 else
472 {
473 $this->PreviewWidth =
474 ($MaxPreviewHeight * $SrcImage->XSize()) / $SrcImage->YSize();
475 $this->PreviewHeight = $MaxPreviewHeight;
476 }
477
478 # generate thumbnail image and calculate width and height
479 $MaxThumbnailWidth = min($MaxThumbnailWidth, $this->Width);
480 $MaxThumbnailHeight = min($MaxThumbnailHeight, $this->Height);
481 $SrcImage->ScaleTo($MaxThumbnailWidth, $MaxThumbnailHeight, TRUE);
482 $SrcImage->SaveAs($this->ThumbnailFileName);
483 if (($this->Width * $MaxThumbnailHeight)
484 > ($this->Height * $MaxThumbnailWidth))
485 {
486 $this->ThumbnailWidth = $MaxThumbnailWidth;
487 $this->ThumbnailHeight =
488 ($MaxThumbnailWidth * $SrcImage->YSize()) / $SrcImage->XSize();
489 }
490 else
491 {
492 $this->ThumbnailWidth =
493 ($MaxThumbnailHeight * $SrcImage->XSize()) / $SrcImage->YSize();
494 $this->ThumbnailHeight = $MaxThumbnailHeight;
495 }
496
497 # save image attributes to database
498 $this->SaveImageInfo();
499 }
500
508 public function GetImageUrlForResource($ResourceId, $FieldId, $Index, $Size)
509 {
510 StdLib::CheckMyCaller(
511 "Resource",
512 "Attempt to get ImageLinks at %FILE%:%LINE%."
513 ." (ImageLinks many only be fetched by Resource.)");
514
515 switch ($Size)
516 {
517 case self::SIZE_FULL:
518 $Suffix = "f";
519 break;
520 case self::SIZE_PREVIEW:
521 $Suffix = "p";
522 break;
523 case self::SIZE_THUMBNAIL:
524 $Suffix = "t";
525 break;
526 default:
527 throw new Exception("Unknown image size requested");
528 }
529
530 $Files = array(
531 "t" => $this->ThumbnailFileName,
532 "p" => $this->PreviewFileName,
533 "f" => $this->FileName);
534
535 # default to returning the path to the file
536 $ReturnValue = $Files[$Suffix];
537
538 # but if we have CleanURL support
539 if ($GLOBALS["AF"]->HtaccessSupport())
540 {
541 # make sure our ImageLinks dir exists
542 if (!is_dir(self::CACHE_PATH))
543 {
544 mkdir(self::CACHE_PATH);
545 }
546
547 # create symlinks for this field if they don't already exist
548 $BaseDir = dirname(__DIR__)."/";
549 foreach ($Files as $FileSuffix => $SrcFile)
550 {
551 $LinkName =
552 implode("_", array($ResourceId, $FieldId, $Index, $FileSuffix))
553 .".".Image::Extension($this->Format());
554
555 if (!file_exists(self::CACHE_PATH."/".$LinkName))
556 {
557 symlink($BaseDir.$SrcFile, self::CACHE_PATH."/".$LinkName);
558 }
559
560 # if this is the requested symlink, generate a url to return
561 if ($Suffix == $FileSuffix)
562 {
563 $ReturnValue = OurBaseUrl()."viewimage/".$LinkName;
564 }
565 }
566 }
567
568 return $ReturnValue;
569 }
570
576 public static function ClearImageSymlinksForResource($ResourceId, $FieldId)
577 {
578 StdLib::CheckMyCaller(
579 "Resource",
580 "Attempt to delete ImageLinks of a resource at %FILE%:%LINE%."
581 ." (ImageLinks many only be cleared by Resource.)");
582
583 if (!is_dir(self::CACHE_PATH))
584 {
585 return;
586 }
587
588 $Files = glob(self::CACHE_PATH."/".$ResourceId."_".$FieldId."_*");
589 foreach ($Files as $file)
590 {
591 if (file_exists($File) && is_link($File))
592 {
593 unlink($File);
594 }
595 }
596 }
597
601 public static function ClearImageSymlinks()
602 {
603 if (!is_dir(self::CACHE_PATH))
604 {
605 return;
606 }
607
608 foreach (scandir(self::CACHE_PATH) as $Entry)
609 {
610 $Link = self::CACHE_PATH."/".$Entry;
611 if (is_link($Link))
612 {
613 unlink($Link);
614 }
615 }
616 }
617
621 public static function ExpireImageSymlinks()
622 {
623 if (!is_dir(self::CACHE_PATH))
624 {
625 return;
626 }
627
628 foreach (scandir(self::CACHE_PATH) as $Entry)
629 {
630 $Link = self::CACHE_PATH."/".$Entry;
631 if (is_link($Link))
632 {
633 $link_info = lstat($Link);
634
635 if (time() - $link_info['ctime'] > self::$SymlinkExpirationTime)
636 {
637 unlink($Link);
638 }
639 }
640 }
641 }
642
643 # ---- PRIVATE INTERFACE -------------------------------------------------
644
645 private $Id;
646 private $FileName;
647 private $PreviewFileName;
648 private $ThumbnailFileName;
649 private $Format;
650 private $AltText;
651 private $LinkTarget;
652 private $Url;
653 private $PreviewUrl;
654 private $ThumbnailUrl;
655 private $Height;
656 private $Width;
657 private $PreviewHeight;
658 private $PreviewWidth;
659 private $ThumbnailHeight;
660 private $ThumbnailWidth;
661 private $DB;
662 private $ErrorStatus;
663
664 static private $SymlinkExpirationTime = 86400;
665
667 static private $ImageStorageLocations = array(
668 "local/data/images",
669 "ImageStorage",
670 );
671 static private $PreviewStorageLocations = array(
672 "local/data/images/previews",
673 "ImageStorage/Previews",
674 );
675 static private $ThumbnailStorageLocations = array(
676 "local/data/images/thumbnails",
677 "ImageStorage/Thumbnails",
678 );
679
691 private function CreateNewImage($FileName, $MaxWidth, $MaxHeight,
692 $MaxPreviewWidth, $MaxPreviewHeight, $MaxThumbnailWidth, $MaxThumbnailHeight)
693 {
694 # if file does not exist or is not readable
695 if (!is_readable($FileName))
696 {
697 # set error status
698 $this->ErrorStatus = AI_FILEUNREADABLE;
699 }
700 else
701 {
702 # if image is invalid or unsupported type
703 $SrcImage = new Image($FileName);
704 $this->Format = $SrcImage->Type();
705 if ($SrcImage->Status() != AI_OKAY)
706 {
707 # set error status
708 $this->ErrorStatus = $SrcImage->Status();
709 }
710 else
711 {
712 # generate new image ID
713 $this->Id = $this->GenerateNewImageId();
714
715 # generate and set file names
716 $this->SetFileNames();
717
718 # if our image file name differs from file name passed in
719 if (realpath($this->FileName) != realpath($FileName))
720 {
721 # create image file
722 $SrcImage->SaveAs($this->FileName);
723
724 # if create failed set error status and bail out
725 if ($SrcImage->Status() != AI_OKAY)
726 {
727 $this->DB->Query("DELETE FROM Images WHERE ImageId = "
728 .intval($this->Id));
729 $this->ErrorStatus = $SrcImage->Status();
730 return;
731 }
732 }
733
734 # scale the original image if necessary
735 $MaxWidth = min($MaxWidth, $SrcImage->XSize());
736 $MaxHeight = min($MaxHeight, $SrcImage->YSize());
737
738 # change the minimum width if the height is the limiting factor
739 if ($SrcImage->YSize() * $MaxWidth / $SrcImage->XSize() > $MaxHeight)
740 {
741 $MaxWidth = round(
742 $SrcImage->XSize() * $MaxHeight / $SrcImage->YSize());
743 }
744
745 # change the minimum height since the width is the limiting factor
746 else
747 {
748 $MaxHeight = round(
749 $SrcImage->YSize() * $MaxWidth / $SrcImage->XSize());
750 }
751
752 # scale the image
753 $SrcImage->ScaleTo($MaxWidth, $MaxHeight, TRUE);
754
755 # save and reload image info
756 $SrcImage->SaveAs($this->FileName);
757 $SrcImage = new Image($this->FileName);
758
759 # retrieve image width and height
760 $this->Height = $SrcImage->YSize();
761 $this->Width = $SrcImage->XSize();
762
763 # create the preview and thumbnail images
764 foreach (array("Preview", "Thumbnail") as $ImageType)
765 {
766 # variable name strings to use in the variable variables below
767 $MaxWidthVar = "Max".$ImageType."Width";
768 $MaxHeightVar = "Max".$ImageType."Height";
769
770 # find the mininum values for the width and height
771 $$MaxWidthVar = min($$MaxWidthVar, $this->Width);
772 $$MaxHeightVar= min($$MaxHeightVar, $this->Height);
773
774 # change the minimum width if the height is the limiting factor
775 if ($this->Height * $$MaxWidthVar / $this->Width > $$MaxHeightVar)
776 {
777 $$MaxWidthVar =
778 round($this->Width * $$MaxHeightVar / $this->Height);
779 }
780
781 # change the minimum height since the width is the limiting factor
782 else
783 {
784 $$MaxHeightVar =
785 round($this->Height * $$MaxWidthVar / $this->Width);
786 }
787
788 # scale the image and save it to a new file
789 $SrcImage->ScaleTo($$MaxWidthVar, $$MaxHeightVar, TRUE);
790 $SrcImage->SaveAs($this->{$ImageType."FileName"});
791
792 # scaling/saving failed
793 if ($SrcImage->Status() != AI_OKAY)
794 {
795 $this->DB->Query("DELETE FROM Images WHERE ImageId = "
796 .intval($this->Id));
797 $this->ErrorStatus = $SrcImage->Status();
798 return;
799 }
800
801 # save the dimensions
802 $this->{$ImageType."Width"} = $$MaxWidthVar;
803 $this->{$ImageType."Height"} = $$MaxHeightVar;
804 }
805
806 # save image attributes to database
807 $this->SaveImageInfo();
808 }
809 }
810 }
811
816 private function LoadImageInfo($ImageId)
817 {
818 # save image ID
819 $this->Id = $ImageId;
820
821 # load image record from database
822 $this->DB->Query("SELECT * FROM Images WHERE ImageId = ".$ImageId);
823
824 # if the ID is invalid
825 if (!$this->DB->NumRowsSelected())
826 {
827 $this->ErrorStatus = AI_INTERNALERROR;
828 return;
829 }
830
831 $Record = $this->DB->FetchRow();
832
833 # load in values from record
834 $this->Format = $Record["Format"];
835 $this->AltText = $Record["AltText"];
836 $this->LinkTarget = $Record["LinkTarget"];
837 $this->Height = $Record["Height"];
838 $this->Width = $Record["Width"];
839 $this->PreviewHeight = $Record["PreviewHeight"];
840 $this->PreviewWidth = $Record["PreviewWidth"];
841 $this->ThumbnailHeight = $Record["ThumbnailHeight"];
842 $this->ThumbnailWidth = $Record["ThumbnailWidth"];
843
844 # generate file names
845 $this->SetFileNames();
846 }
847
852 private function CreateCopyOfImage($SrcImage)
853 {
854 $Image = new Image($SrcImage->Url());
855 if ($Image->Status() != AI_OKAY)
856 {
857 # set error status
858 $this->ErrorStatus = $Image->Status();
859 return;
860 }
861
862 # generate new image ID
863 $this->Id = $this->GenerateNewImageId();
864
865 # generate file names
866 $this->SetFileNames();
867
868 # copy attributes from source image
869 $this->Format = $SrcImage->Format();
870 $this->AltText = $SrcImage->AltText();
871 $this->Width = $SrcImage->Width();
872 $this->Height = $SrcImage->Height();
873 $this->PreviewWidth = $SrcImage->PreviewWidth();
874 $this->PreviewHeight = $SrcImage->PreviewHeight();
875 $this->ThumbnailWidth = $SrcImage->ThumbnailWidth();
876 $this->ThumbnailHeight = $SrcImage->ThumbnailHeight();
877
878 # copy source image files
879 copy($SrcImage->Url(), $this->FileName);
880 copy($SrcImage->PreviewUrl(), $this->PreviewFileName);
881 copy($SrcImage->ThumbnailUrl(), $this->ThumbnailFileName);
882
883 # save image attributes to database
884 $this->SaveImageInfo();
885 }
886
891 private function SetFileNames()
892 {
893 if (Image::Extension($this->Format))
894 {
895 $FileExtension = Image::Extension($this->Format);
896 }
897 else
898 {
899 $FileExtension = "";
900 }
901
902 $this->FileName = $this->DetermineFileName(
903 self::$ImageStorageLocations, "Img--", $FileExtension);
904 $this->PreviewFileName = $this->DetermineFileName(
905 self::$PreviewStorageLocations, "Preview--", $FileExtension);
906 $this->ThumbnailFileName = $this->DetermineFileName(
907 self::$ThumbnailStorageLocations, "Thumb--", $FileExtension);
908 }
909
919 private function DetermineFileName($Locations, $Prefix, $Extension)
920 {
921 # build base name for file
922 $BaseName = $Prefix.sprintf("%08d.", $this->Id).$Extension;
923
924 # for each possible location
925 foreach ($Locations as $Dir)
926 {
927 # build full file name for location
928 $FileName = $Dir."/".$BaseName;
929
930 # if file exists in location return full file name
931 if (file_exists($FileName)) { return $FileName; }
932 }
933
934 # for each possible location
935 foreach ($Locations as $Dir)
936 {
937 # build full file name for location
938 $FileName = $Dir."/".$BaseName;
939
940 # if location is writable return full file name
941 if (is_dir($Dir) && is_writable($Dir)) { return $FileName; }
942 }
943
944 # return full file name for default location
945 return $Locations[0]."/".$BaseName;
946 }
947
952 private function GenerateNewImageId()
953 {
954 # add new entry to database
955 $this->DB->Query("INSERT INTO Images (AltText) VALUES ('')");
956
957 # return ID of inserted image
958 return $this->DB->LastInsertId();
959 }
960
964 private function SaveImageInfo()
965 {
966 # update existing image record
967 $this->DB->Query("UPDATE Images SET"
968 ." Format = '" .$this->Format."',"
969 ." AltText = '" .addslashes($this->AltText)."',"
970 ." Height = '" .$this->Height."',"
971 ." Width = '" .$this->Width."',"
972 ." PreviewHeight = '" .$this->PreviewHeight."',"
973 ." PreviewWidth = '" .$this->PreviewWidth."',"
974 ." ThumbnailHeight = '".$this->ThumbnailHeight."',"
975 ." ThumbnailWidth = '" .$this->ThumbnailWidth."'"
976 ." WHERE ImageId = ".$this->Id);
977 }
978 }
SPTImage\SIZE_PREVIEW
const SIZE_PREVIEW
Definition: SPTImage.php:22
SPTImage\Mimetype
Mimetype()
Get the MIME type for the image.
Definition: SPTImage.php:146
SPTImage\__construct
__construct($ImageIdOrFileNameOrImageObj, $MaxWidth=NULL, $MaxHeight=NULL, $MaxPreviewWidth=NULL, $MaxPreviewHeight=NULL, $MaxThumbnailWidth=NULL, $MaxThumbnailHeight=NULL)
Object constructor.
Definition: SPTImage.php:37
SPTImage\LinkTarget
LinkTarget($NewValue=NULL)
Get or set the link target value for the image.
Definition: SPTImage.php:307
StdLib\CheckMyCaller
static CheckMyCaller($DesiredCaller, $ExceptionMsg=NULL)
Check the caller of the current function.
Definition: StdLib.php:47
SPTImage\ThumbnailWidth
ThumbnailWidth()
Get the width of the thumbnail image for this image.
Definition: SPTImage.php:201
Database
SQL database abstraction object with smart query caching.
Definition: Database.php:22
AI_OKAY
const AI_OKAY
Definition: Image.php:550
SPTImage\Delete
Delete()
Delete the image, that is, remove its record from the database and delete the associated image files ...
Definition: SPTImage.php:324
SPTImage\PreviewHeight
PreviewHeight()
Get the height of the preview image for this image.
Definition: SPTImage.php:174
SPTImage\PreviewWidth
PreviewWidth()
Get the width of the preview image for this image.
Definition: SPTImage.php:183
SPTImage\SIZE_THUMBNAIL
const SIZE_THUMBNAIL
Definition: SPTImage.php:23
SPTImage\Status
Status()
Get the error status set by the constructor.
Definition: SPTImage.php:343
SPTImage\CheckDirectories
static CheckDirectories()
Check that the image storage directories are available, creating them and attempting to change their ...
Definition: SPTImage.php:353
PHP
PHP
Definition: RSSClient--Test.php:12
SPTImage\CACHE_PATH
const CACHE_PATH
path containg the symlinks mapping images/fields to resources
Definition: SPTImage.php:19
SPTImage\ThumbnailHeight
ThumbnailHeight()
Get the height of the thumbnail image for this image.
Definition: SPTImage.php:192
SPTImage\Width
Width()
Get the width of the image.
Definition: SPTImage.php:165
SPTImage
Encapsulates a full-size, preview, and thumbnail image.
Definition: SPTImage.php:13
SPTImage\Url
Url()
Get the path to the image.
Definition: SPTImage.php:91
SPTImage\PreviewStorageDirectory
static PreviewStorageDirectory()
Get the path to the preview image storage directory.
Definition: SPTImage.php:231
SPTImage\PreviewUrl
PreviewUrl()
Get the path to the preview image for this image.
Definition: SPTImage.php:106
SPTImage\Format
Format()
Get the format of the image.
Definition: SPTImage.php:137
AI_FILEUNREADABLE
const AI_FILEUNREADABLE
Definition: Image.php:551
SPTImage\GetLink
GetLink()
Get the path to the full-size image.
Definition: SPTImage.php:273
SPTImage\Id
Id()
Get the ID of the image in the database.
Definition: SPTImage.php:82
Image\Status
Status()
Definition: Image.php:460
SPTImage\Height
Height()
Get the height of the image.
Definition: SPTImage.php:156
SPTImage\Resize
Resize($MaxWidth, $MaxHeight, $MaxPreviewWidth, $MaxPreviewHeight, $MaxThumbnailWidth, $MaxThumbnailHeight)
Resize the full-size, preview, and thumbnail images based on the given dimension restrictions.
Definition: SPTImage.php:440
Image
Definition: Image.php:15
SPTImage\GetImageUrlForResource
GetImageUrlForResource($ResourceId, $FieldId, $Index, $Size)
Get the URL pointing to an image.
Definition: SPTImage.php:508
SPTImage\ExpireImageSymlinks
static ExpireImageSymlinks()
Expire old symlinks used for cached image mappings.
Definition: SPTImage.php:621
SPTImage\SIZE_FULL
const SIZE_FULL
Definition: SPTImage.php:21
SPTImage\ClearImageSymlinksForResource
static ClearImageSymlinksForResource($ResourceId, $FieldId)
Remove symlinks used for to cache image mappings.
Definition: SPTImage.php:576
SPTImage\ClearImageSymlinks
static ClearImageSymlinks()
Remove all symlinks used for a cached image mapping.
Definition: SPTImage.php:601
SPTImage\AltText
AltText($NewValue=NULL)
Get or set the alternate text value for the image.
Definition: SPTImage.php:284
SPTImage\ThumbnailStorageDirectory
static ThumbnailStorageDirectory()
Get the path to the thumbnail image storage directory.
Definition: SPTImage.php:252
SPTImage\ImageStorageDirectory
static ImageStorageDirectory()
Get the path to the (full-size) image storage directory.
Definition: SPTImage.php:210
SPTImage\ThumbnailUrl
ThumbnailUrl()
Get the path to the thumbnail image for this image.
Definition: SPTImage.php:121
AI_INTERNALERROR
const AI_INTERNALERROR
Definition: Image.php:554
Image\Extension
static Extension($Type=NULL)
Definition: Image.php:375