Rewrite continued:
[core.git] / framework / main / classes / images / class_BaseImage.php
1 <?php
2 // Own namespace
3 namespace CoreFramework\Image;
4
5 // Import framework stuff
6 use CoreFramework\Object\BaseFrameworkSystem;
7 use CoreFramework\Registry\Registerable;
8
9 /**
10  * A general image class
11  *
12  * @author              Roland Haeder <webmaster@shipsimu.org>
13  * @version             0.0.0
14  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2017 Core Developer Team
15  * @license             GNU GPL 3.0 or any newer version
16  * @link                http://www.shipsimu.org
17  *
18  * This program is free software: you can redistribute it and/or modify
19  * it under the terms of the GNU General Public License as published by
20  * the Free Software Foundation, either version 3 of the License, or
21  * (at your option) any later version.
22  *
23  * This program is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  * GNU General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program. If not, see <http://www.gnu.org/licenses/>.
30  */
31 class BaseImage extends BaseFrameworkSystem implements Registerable {
32         /**
33          * Image type
34          */
35         private $imageType = '';
36
37         /**
38          * Width of the image
39          */
40         private $width = '';
41
42         /**
43          * Height of the image
44          */
45         private $height = '';
46
47         /**
48          * X/Y
49          */
50         private $x = '';
51         private $y = '';
52
53         /**
54          * Font size
55          */
56         private $fontSize = '';
57
58         /**
59          * Image string
60          */
61         private $imageString = '';
62
63         /**
64          * Background color in RGB
65          */
66         private $backgroundColor = array(
67                 'red'   => '',
68                 'green' => '',
69                 'blue'  => ''
70         );
71
72         /**
73          * Foreground color in RGB
74          */
75         private $foregroundColor = array(
76                 'red'   => '',
77                 'green' => '',
78                 'blue'  => ''
79         );
80
81         /**
82          * Current choosen color array
83          */
84         private $colorMode = '';
85
86         /**
87          * Image resource
88          */
89         private $imageResource = NULL;
90
91         /**
92          * Image name
93          */
94         private $imageName = '';
95
96         /**
97          * String name
98          */
99         private $stringName = '';
100
101         /**
102          * Groupable image strings?
103          */
104         private $groupable = 'single';
105
106         /**
107          * Protected constructor
108          *
109          * @param       $className      Name of the class
110          * @return      void
111          */
112         protected function __construct ($className) {
113                 // Call parent constructor
114                 parent::__construct($className);
115         }
116
117         /**
118          * Private setter for all colors
119          *
120          * @param       $colorMode              Whether background or foreground color
121          * @param       $colorChannel   Red, green or blue channel?
122          * @param       $colorValue             Value to set
123          */
124         private final function setColor ($colorMode, $colorChannel, $colorValue) {
125                 // Construct the eval() command
126                 $eval = sprintf("\$this->%s['%s'] = \"%s\";",
127                         $colorMode,
128                         $colorChannel,
129                         $colorValue
130                 );
131
132                 // Run the command
133                 //* DEBUG: */ echo "mode={$colorMode}, channel={$colorChannel}, value={$colorValue}<br />\n";
134                 eval($eval);
135         }
136
137         /**
138          * Setter for image width
139          *
140          * @param       $width  Width of the image
141          * @return      void
142          */
143         public final function setWidth ($width) {
144                 $this->width = $width;
145         }
146
147         /**
148          * Getter for image width
149          *
150          * @return      $width  Width of the image
151          */
152         public final function getWidth () {
153                 return $this->width;
154         }
155
156         /**
157          * Setter for image height
158          *
159          * @param       $height Height of the image
160          * @return      void
161          */
162         public final function setHeight ($height) {
163                 $this->height = $height;
164         }
165
166         /**
167          * Getter for image height
168          *
169          * @return      $height Height of the image
170          */
171         public final function getHeight () {
172                 return $this->height;
173         }
174
175         /**
176          * Finish the type handling (unused at the moment)
177          *
178          * @return      void
179          * @todo        Find something usefull for this method.
180          */
181         public function finishType () {
182                 // Empty at the momemt
183         }
184
185         /**
186          * Prepares the class for resolution (unused at the moment)
187          *
188          * @return      void
189          * @todo        Find something usefull for this method.
190          */
191         public function initResolution () {
192                 // Empty at the momemt
193         }
194
195         /**
196          * Finish resolution handling (unused at the moment)
197          *
198          * @return      void
199          * @todo        Find something usefull for this method.
200          */
201         public function finishResolution () {
202                 // Empty at the momemt
203         }
204
205         /**
206          * Prepares the class for base (unused at the moment)
207          *
208          * @return      void
209          * @todo        Find something usefull for this method.
210          */
211         public function initBase () {
212                 // Empty at the momemt
213         }
214
215         /**
216          * Finish base handling (unused at the moment)
217          *
218          * @return      void
219          * @todo        Find something usefull for this method.
220          */
221         public function finishBase () {
222                 // Empty at the momemt
223         }
224
225         /**
226          * Prepares the class for background color
227          *
228          * @return      void
229          */
230         public function initBackgroundColor () {
231                 $this->colorMode = 'backgroundColor';
232         }
233
234         /**
235          * Finish background color handling
236          *
237          * @return      void
238          * @todo        Find something usefull for this method.
239          */
240         public function finishBackgroundColor () {
241                 // Empty at the moment
242         }
243
244         /**
245          * Prepares the class for foreground color
246          *
247          * @return      void
248          */
249         public function initForegroundColor () {
250                 $this->colorMode = 'foregroundColor';
251         }
252
253         /**
254          * Finish foreground color handling
255          *
256          * @return      void
257          * @todo        Find something usefull for this method.
258          */
259         public function finishForegroundColor () {
260                 // Empty at the moment
261         }
262
263         /**
264          * Prepares the class for string (unused at the moment)
265          *
266          * @param       $groupable      Whether this image string is groupable or single
267          * @return      void
268          * @todo        Find something usefull for this method.
269          */
270         public function initImageString ($groupable = 'single') {
271                 $this->groupable = $groupable;
272         }
273
274         /**
275          * Finish string handling (unused at the moment)
276          *
277          * @return      void
278          * @todo        Find something usefull for this method.
279          */
280         public function finishImageString () {
281                 // Empty at the momemt
282         }
283
284         /**
285          * Setter for red color
286          *
287          * @param       $red    Red color value
288          * @return      void
289          */
290         public final function setRed ($red) {
291                 // Get array name
292                 $arrayName = $this->colorMode;
293
294                 // Set image color
295                 $this->setColor($arrayName, 'red', $red);
296         }
297
298         /**
299          * Setter for green color
300          *
301          * @param       $green  Green color value
302          * @return      void
303          */
304         public final function setGreen ($green) {
305                 // Get array name
306                 $arrayName = $this->colorMode;
307
308                 // Set image color
309                 $this->setColor($arrayName, 'green', $green);
310         }
311
312         /**
313          * Setter for blue color
314          *
315          * @param       $blue   Blue color value
316          * @return      void
317          */
318         public final function setBlue ($blue) {
319                 // Get array name
320                 $arrayName = $this->colorMode;
321
322                 // Set image color
323                 $this->setColor($arrayName, 'blue', $blue);
324         }
325
326         /**
327          * Setter for image string
328          *
329          * @param       $string         String to set in image
330          * @return      void
331          */
332         public final function setString ($string) {
333                 $this->imageString = (string) $string;
334         }
335
336         /**
337          * Getter for image string
338          *
339          * @return      $string         String to set in image
340          */
341         public final function getString () {
342                 return $this->imageString;
343         }
344
345         /**
346          * Setter for image type
347          *
348          * @param       $imageType              Type to set in image
349          * @return      void
350          */
351         protected final function setImageType ($imageType) {
352                 $this->imageType = (string) $imageType;
353         }
354
355         /**
356          * Getter for image type
357          *
358          * @return      $imageType              Type to set in image
359          */
360         public final function getImageType () {
361                 return $this->imageType;
362         }
363
364         /**
365          * Setter for image name
366          *
367          * @param       $name   Name of the image
368          * @return      void
369          */
370         public final function setImageName ($name) {
371                 $this->imageName = (string) $name;
372         }
373
374         /**
375          * Getter for image name
376          *
377          * @return      $name   Name of the image
378          */
379         public final function getImageName () {
380                 return $this->imageName;
381         }
382
383         /**
384          * Getter for image resource
385          *
386          * @return      $imageResource  An image resource from imagecreatetruecolor() function
387          */
388         public final function getImageResource() {
389                 return $this->imageResource;
390         }
391
392         /**
393          * Setter for X coordinate
394          *
395          * @param       $x      X coordinate
396          * @return      void
397          */
398         public final function setX ($x) {
399                 $this->x = $x;
400         }
401
402         /**
403          * Getter for X coordinate
404          *
405          * @return      $x      X coordinate
406          */
407         public final function getX () {
408                 return $this->x;
409         }
410
411         /**
412          * Setter for Y coordinate
413          *
414          * @param       $y      Y coordinate
415          * @return      void
416          */
417         public final function setY ($y) {
418                 $this->y = $y;
419         }
420
421         /**
422          * Getter for Y coordinate
423          *
424          * @return      $y      Y coordinate
425          */
426         public final function getY () {
427                 return $this->y;
428         }
429
430         /**
431          * Setter for font size
432          *
433          * @param       $fontSize       Font size for strings
434          * @return      void
435          */
436         public final function setFontSize ($fontSize) {
437                 $this->fontSize = $fontSize;
438         }
439
440         /**
441          * Getter for font size
442          *
443          * @return      $fontSize       Font size for strings
444          */
445         public final function getFontSize () {
446                 return $this->fontSize;
447         }
448
449         /**
450          * Setter for string name
451          *
452          * @param       $stringName             String name to set
453          * @return      void
454          */
455         public final function setStringName($stringName) {
456                 $this->stringName = $stringName;
457         }
458
459         /**
460          * Finish this image by producing it
461          *
462          * @return      void
463          */
464         public function finishImage () {
465                 // Get template instance
466                 $templateInstance = $this->getTemplateInstance();
467
468                 // Compile width and height
469                 $width = $templateInstance->compileRawCode($this->getWidth());
470                 $height = $templateInstance->compileRawCode($this->getHeight());
471
472                 // Set both again
473                 $this->setWidth($width);
474                 $this->setHeight($height);
475
476                 // Get a image resource
477                 $this->imageResource = imagecreatetruecolor($width, $height);
478
479                 // Compile background colors
480                 $red   = $templateInstance->compileRawCode($this->backgroundColor['red']);
481                 $green = $templateInstance->compileRawCode($this->backgroundColor['green']);
482                 $blue  = $templateInstance->compileRawCode($this->backgroundColor['blue']);
483
484                 // Set all back
485                 $this->initBackgroundColor();
486                 $this->setRed($red);
487                 $this->setGreen($green);
488                 $this->setBlue($blue);
489
490                 // Get a pointer for background color
491                 $backColor = imagecolorallocate($this->getImageResource(), $red, $green, $blue);
492
493                 // Fill the image
494                 imagefill($this->getImageResource(), 0, 0, $backColor);
495
496                 // Compile foreground colors
497                 $red   = $templateInstance->compileRawCode($this->foregroundColor['red']);
498                 $green = $templateInstance->compileRawCode($this->foregroundColor['green']);
499                 $blue  = $templateInstance->compileRawCode($this->foregroundColor['blue']);
500
501                 // Set all fore
502                 $this->initForegroundColor();
503                 $this->setRed($red);
504                 $this->setGreen($green);
505                 $this->setBlue($blue);
506
507                 // Get a pointer for foreground color
508                 $foreColor = imagecolorallocate($this->getImageResource(), $red, $green, $blue);
509
510                 switch ($this->groupable) {
511                         case 'single': // Single image string
512                                 // Compile image string
513                                 $imageString = $templateInstance->compileRawCode($this->getString());
514
515                                 // Set it back
516                                 $this->setString($imageString);
517
518                                 // Compile X/Y coordinates and font size
519                                 $x    = $templateInstance->compileRawCode($this->getX());
520                                 $y    = $templateInstance->compileRawCode($this->getY());
521                                 $size = $templateInstance->compileRawCode($this->getFontSize());
522
523                                 // Set the image string
524                                 imagestring($this->getImageResource(), $size, $x, $y, $imageString, $foreColor);
525                                 break;
526
527                         case 'groupable': // More than one string allowed
528                                 // Walk through all groups
529                                 foreach ($templateInstance->getVariableGroups() as $group => $set) {
530                                         // Set the group
531                                         $templateInstance->setVariableGroup($group, false);
532
533                                         // Compile image string
534                                         $imageString = $templateInstance->compileRawCode($this->getString());
535
536                                         // Compile X/Y coordinates and font size
537                                         $x    = $templateInstance->compileRawCode($this->getX());
538                                         $y    = $templateInstance->compileRawCode($this->getY());
539                                         $size = $templateInstance->compileRawCode($this->getFontSize());
540
541                                         // Set the image string
542                                         //* DEBUG: */ print __METHOD__.": size={$size}, x={$x}, y={$y}, string={$imageString}<br />\n";
543                                         imagestring($this->getImageResource(), $size, $x, $y, $imageString, $foreColor);
544                                 } // END - foreach
545                                 break;
546                 }
547
548                 // You need finishing in your image class!
549         }
550
551         /**
552          * Getter for full created image content
553          *
554          * @return      $imageContent   The raw image content
555          */
556         public function getContent () {
557                 // Get cache file name
558                 $cacheFile = $this->getTemplateInstance()->getImageCacheFqfn();
559
560                 // Load the content
561                 $imageContent = file_get_contents($cacheFile);
562
563                 // And return it
564                 return $imageContent;
565         }
566
567 }