1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
<?php

/**

* PHP Font Image Generator
*
* Copyright (C) 2006 Matsuda Shota
* http://sgssweb.com/
* admin@sgssweb.com
*
* ------------------------------------------------------------------------
*
* 2006-4-20        First release.
*
*/
/*
    
    Object Constructor:
        {image: <string>}
        {font: <string>, <number>}
        {font: <string>, <number>, <number>}
        {color: <number>}
        {color: <number>, <number> }
        {color: <number>, <number>, <number>}
        {color: <number>, <number>, <number>, <number>}
        {rectangle: <number>, <number>, <number>, <number>}
        {insets: }
        {insets: <number>}
        {insets: <number>, <number>}
        {insets: <number>, <number>, <number>, <number>}
        {point: }
        {point: <number>, <number>}
        {dimension: }
        {dimension: <number>, <number>}
    
    Canvas Setting:
        autoresize <constant>[none | width | height | both]
        padding <insets>
        padding <number>
        padding <number>, <number>
        padding <number>, <number>, <number>, <number>
        size <number>, <number>
        type <constant>[gif | jpeg | png]
        type <constant>[gif | jpeg | png], <number>
        type <constant>[gif | jpeg | png], <color>
        type <constant>[gif | jpeg | png], <number>, <color>
        file <string>
    
    Graphics:
        antialias <number>
        color <color>
        color <number>
        color <number>, <number>
        color <number>, <number>, <number>
        color <number>, <number>, <number>, <number>
        font <font>
        font <string>, <number>
        font <string>, <number>, <number>
        translate <string>, <number>
        fill
        blank
        gradient <color> <constant>[top | left | bottom | right]
        line <number>, <number>, <number>, <number>
        pattern <image>
        pattern <string>
        pattern <image>, <constant>[repeat | repeat-x | repeat-y | no-repeat]
        pattern <string>, <constant>[repeat | repeat-x | repeat-y | no-repeat]
        rect <rectangle>
        rect <number>, <number>, <number>, <number>
        fillrect <rectangle>
        fillrect <number>, <number>, <number>, <number>
        patternrect <image>, <rectangle>
        patternrect <string>, <rectangle>
        patternrect <image>, <rectangle>, <constant>[repeat | repeat-x | repeat-y | no-repeat]
        patternrect <string>, <rectangle>, <constant>[repeat | repeat-x | repeat-y | no-repeat]
        patternrect <image>, <number>, <number>, <number>, <number>
        patternrect <string>, <number>, <number>, <number>, <number>
        patternrect <image>, <number>, <number>, <number>, <number>, <constant>[repeat | repeat-x | repeat-y | no-repeat]
        patternrect <string>, <number>, <number>, <number>, <number>, <constant>[repeat | repeat-x | repeat-y | no-repeat]
        image <image>, <number>, <number>
        image <string>, <number>, <number>
        image <image>, <number>, <number>, <number>, <number>
        image <string>, <number>, <number>, <number>, <number>
        image <image>, <number>, <number>, <number>, <number>, <number>, <number>, <number>, <number>, <number>, <number>
        image <string>, <number>, <number>, <number>, <number>, <number>, <number>, <number>, <number>, <number>, <number>
        string <string>
        string <string>, <number>, <number>
        string <string>, <number>, <number>, <number>
        string <string>, <number>, <number>, <number>, <number>
        string <string>, <number>, <number>,
               <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
        string <string>, <number>, <number>,
               <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust],
               <constant>[top | middle | bottom]
        string <string>, <number>, <number>, <number>,
               <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
        string <string>, <number>, <number>, <number>,
               <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust],
               <constant>[top | middle | bottom]
        string <string>, <number>, <number>, <number>, <number>,
               <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
        string <string>, <number>, <number>, <number>, <number>,
               <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust],
               <constant>[top | middle | bottom]
    
*/




require_once 'package.graphics.php';
require_once 
'package.gmi.php';




class 
FontImageGenerator
    
extends GMIExecution
{
    var 
$canvas// Canvas
    
var $g// Graphics
    
    
function FontImageGenerator() {
        
parent::GMIExecution();
        
        
$this->canvas = new Canvas();
        
$this->=& $this->canvas->getGraphics();
    }
    
    
    
// void execute()
    
function execute() {
        
parent::execute();
        
        if (
$this->isDebugMode) {
            
$this->debug();
        }
        else {
            
$this->canvas->complete();
            
$this->canvas->output();
        }
    }
    
    
    
// void command(string name, array args)
    
function command($name, &$args) {
    
        switch (
strToLower($name)) {
            case 
"autoresize":
                
// autoresize <constant>[none | width | height | both]
                
if ($this->validateArguments(array(array('none''width''height''both')), $args)) {
                    
$this->canvas->setAutoResizeMode($args[0]->getValue());
                    break;
                }
                break;
                
            case 
"padding":
                
// padding <insets>
                
if ($this->validateArguments(array('insets'), $args)) {
                    
$this->canvas->setPadding($args[0]->getValue());
                    break;
                }
                
                
// padding <number>
                // padding <number> <number>
                // padding <number> <number> <number> <number>
                
else {
                    
$insets $this->construct("insets"$args);
                    
                    if (
$insets != null) {
                        
$this->canvas->setPadding($insets);
                        break;
                    }
                }
                break;
            
            case 
"size":
                
// size <dimension>
                
if ($this->validateArguments(array('dimension'), $args)) {
                    
$this->canvas->setSize($args[0]->getValue());
                    break;
                }
                
// size <number> <number>
                
if ($this->validateArguments(array('number''number'), $args)) {
                    
$this->canvas->setSize($args[0]->getValue(), $args[1]->getValue());
                    break;
                }
                break;
            
            case 
"antialias":
                
// antialias <number>
                
if ($this->validateArguments(array('number'), $args)) {
                    
$this->g->setTextAntialias($args[0]->getValue());
                    break;
                }
                break;
                
            case 
"color":
                
// color <color>
                
if ($this->validateArguments(array('color'), $args)) {
                    
$this->g->setColor($args[0]->getValue());
                    break;
                }
                
// color <number>
                // color <number> <number>
                // color <number> <number> <number>
                // color <number> <number> <number> <number>
                
else {
                    
$color $this->construct("color"$args);
                    
                    if (
$color != null) {
                        
$this->g->setColor($color);
                        break;
                    }
                }
                break;
                
            case 
"font":
                
// font <font>
                
if ($this->validateArguments(array('font'), $args)) {
                    
$this->g->setFont($args[0]->getValue());
                    break;
                }
                
// font <string> <number>
                // font <string> <number> <number>
                
$font $this->construct("font"$args);
                
                if (
$font != null) {
                    
$this->g->setFont($font);
                    break;
                }
                break;
                
            case 
"translate":
                
// translate <number> <number>
                
if ($this->validateArguments(array('number''number'), $args)) {
                    
$this->g->translate($args[0]->getValue(), $args[1]->getValue());
                    break;
                }
                break;
                
            case 
"fill":
                
// fill
                
$this->g->fill();
                break;
                
            case 
"blank":
                
// blank
                
$this->g->blank();
                break;
                
            case 
"gradient":
                
// gradient <color>
                
if ($this->validateArguments(array('color'), $args)) {
                    
$this->g->pattern($args[0]->getValue());
                    break;
                }
                
// gradient <color> <constant>[top | left | bottom | right]
                
if ($this->validateArguments(array('color', array('top''left''bottom''right')), $args)) {
                    
$this->g->gradient($args[0]->getValue(), $args[1]->getValue());
                    break;
                }
                break;
                
            case 
"line":
                
// line <number> <number> <number> <number>
                
if ($this->validateArguments(array('number''number''number''number'), $args)) {
                    
$this->g->drawLine($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue());
                    break;
                }
                break;
                
            case 
"pattern":
                
// pattern <image>
                
if ($this->validateArguments(array('image'), $args)) {
                    
$this->g->pattern($args[0]->getValue());
                    break;
                }
                
// pattern <image> <constant>[repeat | repeat-x | repeat-y | no-repeat]
                
if ($this->validateArguments(array('image', array('repeat','repeat-x','repeat-y','no-repeat')), $args)) {
                    
$this->g->pattern($args[0]->getValue(), $args[1]->getValue());
                    break;
                }
                
                
$image $this->construct("image"$this->extractArguments(00$args));
                
                if (
$image != null) {
                    
// pattern <string>
                    
if ($this->validateArguments(array(null), $args)) {
                        
$this->g->pattern($image);
                        break;
                    }
                    
// pattern <string> <constant>[repeat | repeat-x | repeat-y | no-repeat]
                    
if ($this->validateArguments(array(null, array('repeat','repeat-x','repeat-y','no-repeat')), $args)) {
                        
$this->g->pattern($image$args[1]->getValue());
                        break;
                    }
                }
                break;
                
            case 
"rect":
                
// rect <rectangle>
                
if ($this->validateArguments(array('rectangle'), $args)) {
                    
$this->g->drawRect($args[0]->getValue());
                    break;
                }
                
// rect <number> <number> <number> <number>
                
if ($this->validateArguments(array('number''number''number''number'), $args)) {
                    
$this->g->drawRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue());
                    break;
                }
                break;
                
            case 
"fillrect":
                
// fillrect <rectangle>
                
if ($this->validateArguments(array('rectangle'), $args)) {
                    
$this->g->fillRect($args[0]->getValue());
                    break;
                }
                
// fillrect <number> <number> <number> <number>
                
if ($this->validateArguments(array('number''number''number''number'), $args)) {
                    
$this->g->fillRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue());
                    break;
                }
                break;
                
            case 
"gradientrect":
                
// gradientrect <color> <rectangle>
                
if ($this->validateArguments(array('color''rectangle'), $args)) {
                    
$this->g->gradientRect($args[0]->getValue(), $args[1]->getValue());
                    break;
                }
                
// gradientrect <color> <number> <number> <number> <number>
                
if ($this->validateArguments(array('color''number''number''number''number'), $args)) {
                    
$this->g->gradientRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue());
                    break;
                }
                
// gradientrect <color> <rectangle> <constant>[top | left | bottom | right]
                
if ($this->validateArguments(array('color''rectangle', array('top''left''bottom''right')), $args)) {
                    
$this->g->gradientRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue());
                    break;
                }
                
// gradientrect <color> <number> <number> <number> <number> <constant>[top | left | bottom | right]
                
if ($this->validateArguments(array('color''number''number''number''number', array('top''left''bottom''right')), $args)) {
                    
$this->g->gradientRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue(), $args[5]->getValue());
                    break;
                }
                break;
                
            case 
"patternrect":
                
// patternrect <image> <rectangle>
                
if ($this->validateArguments(array('image''rectangle'), $args)) {
                    
$this->g->patternRect($args[0]->getValue(), $args[1]->getValue());
                    break;
                }
                
// patternrect <image> <number> <number> <number> <number>
                
if ($this->validateArguments(array('image''number''number''number''number'), $args)) {
                    
$this->g->patternRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue());
                    break;
                }
                
// patternrect <image> <rectangle> <constant>[repeat | repeat-x | repeat-y | no-repeat]
                
if ($this->validateArguments(array('image''rectangle', array('repeat','repeat-x','repeat-y','no-repeat')), $args)) {
                    
$this->g->patternRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue());
                    break;
                }
                
// patternrect <image> <number> <number> <number> <number> <constant>[repeat | repeat-x | repeat-y | no-repeat]
                
if ($this->validateArguments(array('image''number''number''number''number', array('repeat','repeat-x','repeat-y','no-repeat')), $args)) {
                    
$this->g->patternRect($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue(), $args[5]->getValue());
                    break;
                }
                
                
$image $this->construct("image"$this->extractArguments(00$args));
                
                if (
$image != null) {
                    
// patternrect <string> <rectangle>
                    
if ($this->validateArguments(array(null'rectangle'), $args)) {
                        
$this->g->patternRect($image$args[1]->getValue());
                        break;
                    }
                    
// patternrect <string> <number> <number> <number> <number>
                    
if ($this->validateArguments(array(null'number''number''number''number'), $args)) {
                        
$this->g->patternRect($image$args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue());
                        break;
                    }
                    
// patternrect <string> <rectangle> <constant>[repeat | repeat-x | repeat-y | no-repeat]
                    
if ($this->validateArguments(array(null'rectangle', array('repeat','repeat-x','repeat-y','no-repeat')), $args)) {
                        
$this->g->patternRect($image$args[1]->getValue(), $args[2]->getValue());
                        break;
                    }
                    
// patternrect <string> <number> <number> <number> <number> <constant>[repeat | repeat-x | repeat-y | no-repeat]
                    
if ($this->validateArguments(array(null'number''number''number''number', array('repeat','repeat-x','repeat-y','no-repeat')), $args)) {
                        
$this->g->patternRect($image$args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue(), $args[5]->getValue());
                        break;
                    }
                }
                break;
                
            case 
"image":
                
// image <image> <number> <number>
                
if ($this->validateArguments(array('image''number''number'), $args)) {
                    
$this->g->drawImage($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue());
                    break;
                }
                
// image <image> <number> <number> <number> <number>
                
if ($this->validateArguments(array('image''number''number''number''number'), $args)) {
                    
$this->g->drawImage($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue());
                    break;
                }
                
// image <image> <number> <number> <number> <number> <number> <number> <number> <number>
                
if ($this->validateArguments(array('image''number''number''number''number''number''number''number''number'), $args)) {
                    
$this->g->drawImage($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue(), $args[5]->getValue(), $args[6]->getValue(), $args[7]->getValue(), $args[8]->getValue());
                    break;
                }
                
                
$image $this->construct("image"$this->extractArguments(00$args));
                
                if (
$image != null) {
                    
// image <string> <number> <number>
                    
if ($this->validateArguments(array(null'number''number'), $args)) {
                        
$this->g->drawImage($image$args[1]->getValue(), $args[2]->getValue());
                        break;
                    }
// image <image> <number> <number> <number> <number>
                    
if ($this->validateArguments(array(null'number''number''number''number'), $args)) {
                        
$this->g->drawImage($image$args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue());
                        break;
                    }
                    
// image <image> <number> <number> <number> <number> <number> <number> <number> <number>
                    
if ($this->validateArguments(array(null'number''number''number''number''number''number''number''number'), $args)) {
                        
$this->g->drawImage($image$args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue(), $args[5]->getValue(), $args[6]->getValue(), $args[7]->getValue(), $args[8]->getValue());
                        break;
                    }
                }
                break;
                
            case 
"string":
                
// string <string>
                
if ($this->validateArguments(array('string'), $args)) {
                    
$this->g->drawString($args[0]->getValue());
                    break;
                }
                
// string <string> <number> <number>
                
if ($this->validateArguments(array('string''number''number'), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue());
                    break;
                }
                
// string <string> <number> <number>
                //          <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
                
if ($this->validateArguments(array('string''number''number', array('left','center','right','left-adjust','center-adjust','right-adjust','adjust')), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue());
                    break;
                }
                
// string <string> <number> <number>
                //          <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
                //          <constant>[top | middle | bottom]
                
if ($this->validateArguments(array('string''number''number', array('left','center','right','left-adjust','center-adjust','right-adjust','adjust'), array('top','middle','bottom')), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), nullnull$args[3]->getValue(), $args[4]->getValue());
                    break;
                }
                
// string <string> <number> <number> <number>
                
if ($this->validateArguments(array('string''number''number''number'), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), null);
                    break;
                }
                
// string <string> <number> <number> <number> 
                //          <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
                
if ($this->validateArguments(array('string''number''number''number', array('left','center','right','left-adjust','center-adjust','right-adjust','adjust')), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), null$args[4]->getValue(), 'top');
                    break;
                }
                
// string <string> <number> <number> <number> 
                //          <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
                //          <constant>[top | middle | bottom]
                
if ($this->validateArguments(array('string''number''number''number', array('left','center','right','left-adjust','center-adjust','right-adjust','adjust'), array('top','middle','bottom')), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), null$args[4]->getValue(), $args[5]->getValue());
                    break;
                }
                
// string <string> <number> <number> <number> <number>
                
if ($this->validateArguments(array('string''number''number''number''number'), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue());
                    break;
                }
                
// string <string> <number> <number> <number> <number> 
                //          <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
                
if ($this->validateArguments(array('string''number''number''number''number', array('left','center','right','left-adjust','center-adjust','right-adjust','adjust')), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue(), $args[5]->getValue(), 'top');
                    break;
                }
                
// string <string> <number> <number> <number> <number> 
                //          <constant>[left | center | right | left-adjust | center-adjust | right-adjust | adjust]
                //          <constant>[top | middle | bottom]
                
if ($this->validateArguments(array('string''number''number''number''number', array('left','center','right','left-adjust','center-adjust','right-adjust','adjust'), array('top','middle','bottom')), $args)) {
                    
$this->g->drawString($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue(), $args[4]->getValue(), $args[5]->getValue(), $args[6]->getValue());
                    break;
                }
                break;
                
            case 
"type":
                
// type <constant>[jpeg | gif | png]
                
if ($this->validateArguments(array(array('jpeg','gif','png')), $args)) {
                    
$this->canvas->setOutputType($args[0]->getValue());
                    break;
                }
                
// type <constant>[jpeg | gif | png] <number>
                
if ($this->validateArguments(array(array('jpeg','gif','png'), 'number'), $args)) {
                    
$this->canvas->setOutputType($args[0]->getValue(), $args[1]->getValue());
                    break;
                }
                
// type <constant>[jpeg | gif | png] <color>
                
if ($this->validateArguments(array(array('jpeg','gif','png'), 'color'), $args)) {
                    
$this->canvas->setOutputType($args[0]->getValue(), null$args[1]->getValue());
                    break;
                }
                
// type <constant>[jpeg | gif | png] <number> <color>
                
if ($this->validateArguments(array(array('jpeg','gif','png'), 'number''color'), $args)) {
                    
$this->canvas->setOutputType($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue());
                    break;
                }
                break;
                
            case 
"file":
                
// file <string>
                
if ($this->validateArguments(array('string'), $args)) {
                    
$this->canvas->setOutputFile($args[0]->getValue());
                    break;
                }
                break;
        }
        
        
parent::command($name$args);
    }
    
    
    
    
// mixed construct(string class, array args)
    
function construct($class, &$args) {
        
        switch (
strToLower($class)) {
            case 
"image":
                
// {image: <string>}
                
if ($this->validateArguments(array('string'), $args)) {
                    return 
$this->canvas->getImage($args[0]->getValue());
                }
                break;
            
            case 
"font":
                
// {font: <string> <number>}
                
if ($this->validateArguments(array('string''number'), $args)) {
                    return new 
Font($args[0]->getValue(), $args[1]->getValue());
                }
                
// {font: <string> <number> <number>}
                
if ($this->validateArguments(array('string''number''number'), $args)) {
                    
$value =& new Font($args[0]->getValue(), $args[1]->getValue());
                    
$value->metrics->setLineHeight($args[2]->getValue());
                    return 
$value;
                }
                break;
            
            case 
"color":
                
// {color: <number>}
                
if ($this->validateArguments(array('number'), $args)) {
                    return new 
Color($args[0]->getValue());
                }
                
// {color: <number> <number>}
                
if ($this->validateArguments(array('number''number'), $args)) {
                    return new 
Color($args[0]->getValue(), $args[1]->getValue());
                }
                
// {color: <number> <number> <number>}
                
if ($this->validateArguments(array('number''number''number'), $args)) {
                    return new 
Color($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue());
                }
                
// {color: <number> <number> <number> <number>}
                
if ($this->validateArguments(array('number''number''number''number'), $args)) {
                    return new 
Color($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue());
                }
                break;
            
            case 
"rectangle":
                
// {rectangle: <number> <number> <number> <number>}
                
if ($this->validateArguments(array('number''number''number''number'), $args)) {
                    return new 
Rectangle($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue());
                }
                break;
            
            case 
"insets":
                
// {insets: }
                
if ($this->validateArguments(array(), $args)) {
                    return new 
Insets();
                }
                
// {insets: <number>}
                
if ($this->validateArguments(array('number'), $args)) {
                    return new 
Insets($args[0]->getValue(), $args[0]->getValue(), $args[0]->getValue(), $args[0]->getValue());
                }
                
// {insets: <number> <number>}
                
if ($this->validateArguments(array('number''number'), $args)) {
                    return new 
Insets($args[0]->getValue(), $args[1]->getValue(), $args[0]->getValue(), $args[1]->getValue());
                }
                
// {insets: <number> <number> <number> <number>}
                
if ($this->validateArguments(array('number''number''number''number'), $args)) {
                    return new 
Insets($args[0]->getValue(), $args[1]->getValue(), $args[2]->getValue(), $args[3]->getValue());
                }
                break;
                
            case 
"dimension":
                
// {dimension: }
                
if ($this->validateArguments(array(), $args)) {
                    return new 
Dimension();
                }
                
// {dimension: <number> <number>}
                
if ($this->validateArguments(array('number''number'), $args)) {
                    return new 
Dimension($args[0]->getValue(), $args[1]->getValue());
                }
                break;
                
            case 
"point":
                
// {point: }
                
if ($this->validateArguments(array(), $args)) {
                    return new 
Point();
                }
                
// {point: <number> <number>}
                
if ($this->validateArguments(array('number''number'), $args)) {
                    return new 
Point($args[0]->getValue(), $args[1]->getValue());
                }
                break;
        }
        
        return 
parent::construct($class$args);
    }
    
    
    
// GMIValue createValue(string exp)
    
function createValue($exp) {
        
$value null;
        
        if (
preg_match('/^\{\s*WIDTH\s*\}$/'$exp)) {
            
$value = new GMINumber($this$this->canvas->getWidth());
        }
        else if (
preg_match('/^\{\s*HEIGHT\s*\}$/'$exp)) {
            
$value = new GMINumber($this$this->canvas->getHeight());
        }
        
        return (
$value !== null)? $value
                                
parent::createValue($exp);
    }
    
    
    
// GMIValue getProperty(GMIVariable variable, string property)
    
function getProperty(&$variable$property) {
        
$type $variable->getType();
        
$value $variable->getValue();
        
        switch (
$type) {
            case 
"image":
                switch(
$property) {
                    case 
"width":
                        return 
$this->createValue($value->getWidth());
                    case 
"height":
                        return 
$this->createValue($value->getHeight());
                }
                break;
                
            case 
"font":
                switch(
$property) {
                    case 
"name":
                        return 
$this->createValue($value->getFontName());
                    case 
"size":
                        return 
$this->createValue($value->getSize());
                    case 
"leading":
                        unset(
$metrics);
                        
$metrics =& $value->getMetrics();
                        return 
$this->createValue($metrics->getLeading());
                }
                break;
                
            case 
"color":
                switch(
$property) {
                    case 
"r":
                        return 
$this->createValue($value->getRed());
                    case 
"g":
                        return 
$this->createValue($value->getGreen());
                    case 
"b":
                        return 
$this->createValue($value->getGreen());
                    case 
"a":
                        return 
$this->createValue($value->getAlpha());
                }
                break;
            
            case 
"rectangle":
                switch(
$property) {
                    case 
"x":
                        return 
$this->createValue($value->getX());
                    case 
"y":
                        return 
$this->createValue($value->getY());
                    case 
"width":
                        return 
$this->createValue($value->getWidth());
                    case 
"height":
                        return 
$this->createValue($value->getHeight());
                }
                break;
            
            case 
"insets":
                switch(
$property) {
                    case 
"t":
                        return 
$this->createValue($value->top);
                    case 
"l":
                        return 
$this->createValue($value->left);
                    case 
"b":
                        return 
$this->createValue($value->bottom);
                    case 
"r":
                        return 
$this->createValue($value->right);
                }
                break;
            
            case 
"dimension":
                switch(
$property) {
                    case 
"width":
                        return 
$this->createValue($value->getWidth());
                    case 
"height":
                        return 
$this->createValue($value->getHeight());
                }
                break;
            
            case 
"point":
                switch(
$property) {
                    case 
"x":
                        return 
$this->createValue($value->getX());
                    case 
"y":
                        return 
$this->createValue($value->getY());
                }
                break;
        }
        
        return 
parent::getProperty($variable$property);
    }
}



?>