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 $IsReadable = @is_readable($FileName);
696 if ($IsReadable !== TRUE)
697 {
698 # set error status
699 $this->ErrorStatus = AI_FILEUNREADABLE;
700 }
701 else
702 {
703 # if image is invalid or unsupported type
704 $SrcImage = new Image($FileName);
705 $this->Format = $SrcImage->Type();
706 if ($SrcImage->Status() != AI_OKAY)
707 {
708 # set error status
709 $this->ErrorStatus = $SrcImage->Status();
710 }
711 else
712 {
713 # generate new image ID
714 $this->Id = $this->GenerateNewImageId();
715
716 # generate and set file names
717 $this->SetFileNames();
718
719 # if our image file name differs from file name passed in
720 if (realpath($this->FileName) != realpath($FileName))
721 {
722 # create image file
723 $SrcImage->SaveAs($this->FileName);
724
725 # if create failed set error status and bail out
726 if ($SrcImage->Status() != AI_OKAY)
727 {
728 $this->DB->Query("DELETE FROM Images WHERE ImageId = "
729 .intval($this->Id));
730 $this->ErrorStatus = $SrcImage->Status();
731 return;
732 }
733 }
734
735 # scale the original image if necessary
736 $MaxWidth = min($MaxWidth, $SrcImage->XSize());
737 $MaxHeight = min($MaxHeight, $SrcImage->YSize());
738
739 # change the minimum width if the height is the limiting factor
740 if ($SrcImage->YSize() * $MaxWidth / $SrcImage->XSize() > $MaxHeight)
741 {
742 $MaxWidth = round(
743 $SrcImage->XSize() * $MaxHeight / $SrcImage->YSize());
744 }
745
746 # change the minimum height since the width is the limiting factor
747 else
748 {
749 $MaxHeight = round(
750 $SrcImage->YSize() * $MaxWidth / $SrcImage->XSize());
751 }
752
753 # scale the image
754 $SrcImage->ScaleTo($MaxWidth, $MaxHeight, TRUE);
755
756 # save and reload image info
757 $SrcImage->SaveAs($this->FileName);
758 $SrcImage = new Image($this->FileName);
759
760 # retrieve image width and height
761 $this->Height = $SrcImage->YSize();
762 $this->Width = $SrcImage->XSize();
763
764 # create the preview and thumbnail images
765 foreach (array("Preview", "Thumbnail") as $ImageType)
766 {
767 # variable name strings to use in the variable variables below
768 $MaxWidthVar = "Max".$ImageType."Width";
769 $MaxHeightVar = "Max".$ImageType."Height";
770
771 # find the mininum values for the width and height
772 $$MaxWidthVar = min($$MaxWidthVar, $this->Width);
773 $$MaxHeightVar= min($$MaxHeightVar, $this->Height);
774
775 # change the minimum width if the height is the limiting factor
776 if ($this->Height * $$MaxWidthVar / $this->Width > $$MaxHeightVar)
777 {
778 $$MaxWidthVar =
779 round($this->Width * $$MaxHeightVar / $this->Height);
780 }
781
782 # change the minimum height since the width is the limiting factor
783 else
784 {
785 $$MaxHeightVar =
786 round($this->Height * $$MaxWidthVar / $this->Width);
787 }
788
789 # scale the image and save it to a new file
790 $SrcImage->ScaleTo($$MaxWidthVar, $$MaxHeightVar, TRUE);
791 $SrcImage->SaveAs($this->{$ImageType."FileName"});
792
793 # scaling/saving failed
794 if ($SrcImage->Status() != AI_OKAY)
795 {
796 $this->DB->Query("DELETE FROM Images WHERE ImageId = "
797 .intval($this->Id));
798 $this->ErrorStatus = $SrcImage->Status();
799 return;
800 }
801
802 # save the dimensions
803 $this->{$ImageType."Width"} = $$MaxWidthVar;
804 $this->{$ImageType."Height"} = $$MaxHeightVar;
805 }
806
807 # save image attributes to database
808 $this->SaveImageInfo();
809 }
810 }
811 }
812
817 private function LoadImageInfo($ImageId)
818 {
819 # save image ID
820 $this->Id = $ImageId;
821
822 # load image record from database
823 $this->DB->Query("SELECT * FROM Images WHERE ImageId = ".$ImageId);
824
825 # if the ID is invalid
826 if (!$this->DB->NumRowsSelected())
827 {
828 $this->ErrorStatus = AI_INTERNALERROR;
829 return;
830 }
831
832 $Record = $this->DB->FetchRow();
833
834 # load in values from record
835 $this->Format = $Record["Format"];
836 $this->AltText = $Record["AltText"];
837 $this->LinkTarget = $Record["LinkTarget"];
838 $this->Height = $Record["Height"];
839 $this->Width = $Record["Width"];
840 $this->PreviewHeight = $Record["PreviewHeight"];
841 $this->PreviewWidth = $Record["PreviewWidth"];
842 $this->ThumbnailHeight = $Record["ThumbnailHeight"];
843 $this->ThumbnailWidth = $Record["ThumbnailWidth"];
844
845 # generate file names
846 $this->SetFileNames();
847 }
848
853 private function CreateCopyOfImage($SrcImage)
854 {
855 $Image = new Image($SrcImage->Url());
856 if ($Image->Status() != AI_OKAY)
857 {
858 # set error status
859 $this->ErrorStatus = $Image->Status();
860 return;
861 }
862
863 # generate new image ID
864 $this->Id = $this->GenerateNewImageId();
865
866 # generate file names
867 $this->SetFileNames();
868
869 # copy attributes from source image
870 $this->Format = $SrcImage->Format();
871 $this->AltText = $SrcImage->AltText();
872 $this->Width = $SrcImage->Width();
873 $this->Height = $SrcImage->Height();
874 $this->PreviewWidth = $SrcImage->PreviewWidth();
875 $this->PreviewHeight = $SrcImage->PreviewHeight();
876 $this->ThumbnailWidth = $SrcImage->ThumbnailWidth();
877 $this->ThumbnailHeight = $SrcImage->ThumbnailHeight();
878
879 # copy source image files
880 copy($SrcImage->Url(), $this->FileName);
881 copy($SrcImage->PreviewUrl(), $this->PreviewFileName);
882 copy($SrcImage->ThumbnailUrl(), $this->ThumbnailFileName);
883
884 # save image attributes to database
885 $this->SaveImageInfo();
886 }
887
892 private function SetFileNames()
893 {
894 if (Image::Extension($this->Format))
895 {
896 $FileExtension = Image::Extension($this->Format);
897 }
898 else
899 {
900 $FileExtension = "";
901 }
902
903 $this->FileName = $this->DetermineFileName(
904 self::$ImageStorageLocations, "Img--", $FileExtension);
905 $this->PreviewFileName = $this->DetermineFileName(
906 self::$PreviewStorageLocations, "Preview--", $FileExtension);
907 $this->ThumbnailFileName = $this->DetermineFileName(
908 self::$ThumbnailStorageLocations, "Thumb--", $FileExtension);
909 }
910
920 private function DetermineFileName($Locations, $Prefix, $Extension)
921 {
922 # build base name for file
923 $BaseName = $Prefix.sprintf("%08d.", $this->Id).$Extension;
924
925 # for each possible location
926 foreach ($Locations as $Dir)
927 {
928 # build full file name for location
929 $FileName = $Dir."/".$BaseName;
930
931 # if file exists in location return full file name
932 if (file_exists($FileName)) { return $FileName; }
933 }
934
935 # for each possible location
936 foreach ($Locations as $Dir)
937 {
938 # build full file name for location
939 $FileName = $Dir."/".$BaseName;
940
941 # if location is writable return full file name
942 if (is_dir($Dir) && is_writable($Dir)) { return $FileName; }
943 }
944
945 # return full file name for default location
946 return $Locations[0]."/".$BaseName;
947 }
948
953 private function GenerateNewImageId()
954 {
955 # add new entry to database
956 $this->DB->Query("INSERT INTO Images (AltText) VALUES ('')");
957
958 # return ID of inserted image
959 return $this->DB->LastInsertId();
960 }
961
965 private function SaveImageInfo()
966 {
967 # update existing image record
968 $this->DB->Query("UPDATE Images SET"
969 ." Format = '" .$this->Format."',"
970 ." AltText = '" .addslashes($this->AltText)."',"
971 ." Height = '" .$this->Height."',"
972 ." Width = '" .$this->Width."',"
973 ." PreviewHeight = '" .$this->PreviewHeight."',"
974 ." PreviewWidth = '" .$this->PreviewWidth."',"
975 ." ThumbnailHeight = '".$this->ThumbnailHeight."',"
976 ." ThumbnailWidth = '" .$this->ThumbnailWidth."'"
977 ." WHERE ImageId = ".$this->Id);
978 }
979 }
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