<?php

/**
 * JPGraph v4.0.3
 */

namespace Amenadiel\JpGraph\Plot;

use Amenadiel\JpGraph\Graph;
use Amenadiel\JpGraph\Image;
use Amenadiel\JpGraph\Util;

/*
 * File:        JPGRAPH_BAR.PHP
 * // Description: Bar plot extension for JpGraph
 * // Created:     2001-01-08
 * // Ver:         $Id: jpgraph_bar.php 1905 2009-10-06 18:00:21Z ljp $
 * //
 * // Copyright (c) Asial Corporation. All rights reserved.
 */
// Pattern for Bars
define('PATTERN_DIAG1', 1);
define('PATTERN_DIAG2', 2);
define('PATTERN_DIAG3', 3);
define('PATTERN_DIAG4', 4);
define('PATTERN_CROSS1', 5);
define('PATTERN_CROSS2', 6);
define('PATTERN_CROSS3', 7);
define('PATTERN_CROSS4', 8);
define('PATTERN_STRIPE1', 9);
define('PATTERN_STRIPE2', 10);

/**
 * @class BarPlot
 * // Description: Main code to produce a bar plot
 */
class BarPlot extends Plot
{
    public $fill                = false;
    public $fill_color          = 'lightblue'; // Default is to fill with light blue
    public $iPattern            = -1;
    public $iPatternDensity     = 80;
    public $iPatternColor       = 'black';
    public $valuepos            = 'top';
    public $grad                = false;
    public $grad_style          = 1;
    public $grad_fromcolor      = [50, 50, 200];
    public $grad_tocolor        = [255, 255, 255];
    public $ymin                = 0;
    protected $width            = 0.4; // in percent of major ticks
    protected $abswidth         = -1; // Width in absolute pixels
    protected $ybase            = 0; // Bars start at 0
    protected $align            = 'center';
    protected $bar_shadow       = false;
    protected $bar_shadow_color = 'black';
    protected $bar_shadow_hsize = 3;
    protected $bar_shadow_vsize = 3;
    protected $bar_3d           = false;
    protected $bar_3d_hsize     = 3;
    protected $bar_3d_vsize     = 3;

    /**
     * CONSTRUCTOR.
     *
     * @param mixed $datay
     * @param mixed $datax
     */
    public function __construct($datay, $datax = false)
    {
        parent::__construct($datay, $datax);
        ++$this->numpoints;
    }

    /**
     * PUBLIC METHODS.
     *
     * @param mixed $aColor
     * @param mixed $aHSize
     * @param mixed $aVSize
     * @param mixed $aShow
     */
    // Set a drop shadow for the bar (or rather an "up-right" shadow)
    public function SetShadow($aColor = 'black', $aHSize = 3, $aVSize = 3, $aShow = true)
    {
        $this->bar_shadow       = $aShow;
        $this->bar_shadow_color = $aColor;
        $this->bar_shadow_vsize = $aVSize;
        $this->bar_shadow_hsize = $aHSize;

        // Adjust the value margin to compensate for shadow
        $this->value->margin += $aVSize;
    }

    public function Set3D($aHSize = 3, $aVSize = 3, $aShow = true)
    {
        $this->bar_3d       = $aShow;
        $this->bar_3d_vsize = $aVSize;
        $this->bar_3d_hsize = $aHSize;

        $this->value->margin += $aVSize;
    }

    // DEPRECATED use SetYBase instead
    public function SetYMin($aYStartValue)
    {
        //die("JpGraph Error: Deprecated function SetYMin. Use SetYBase() instead.");
        $this->ybase = $aYStartValue;
    }

    // Specify the base value for the bars
    public function SetYBase($aYStartValue)
    {
        $this->ybase = $aYStartValue;
    }

    // The method will take the specified pattern anre
    // return a pattern index that corresponds to the original
    // patterm being rotated 90 degreees. This is needed when plottin
    // Horizontal bars
    public function RotatePattern($aPat, $aRotate = true)
    {
        $rotate = [1 => 2, 2 => 1, 3 => 3, 4 => 5, 5 => 4, 6 => 6, 7 => 7, 8 => 8];
        if ($aRotate) {
            return $rotate[$aPat];
        }

        return $aPat;
    }

    public function Legend($graph)
    {
        if ($this->grad && $this->legend != '' && !$this->fill) {
            $color = [$this->grad_fromcolor, $this->grad_tocolor];
            // In order to differentiate between gradients and cooors specified as an Image\RGB triple
            $graph->legend->Add(
                $this->legend,
                $color,
                '',
                -$this->grad_style,
                $this->legendcsimtarget,
                $this->legendcsimalt,
                $this->legendcsimwintarget
            );
        } elseif ($this->legend != '' && ($this->iPattern > -1 || is_array($this->iPattern))) {
            if (is_array($this->iPattern)) {
                $p1 = $this->RotatePattern($this->iPattern[0], $graph->img->a == 90);
                $p2 = $this->iPatternColor[0];
                $p3 = $this->iPatternDensity[0];
            } else {
                $p1 = $this->RotatePattern($this->iPattern, $graph->img->a == 90);
                $p2 = $this->iPatternColor;
                $p3 = $this->iPatternDensity;
            }
            if ($p3 < 90) {
                $p3 += 5;
            }

            $color = [$p1, $p2, $p3, $this->fill_color];
            // A kludge: Too mark that we add a pattern we use a type value of < 100
            $graph->legend->Add(
                $this->legend,
                $color,
                '',
                -101,
                $this->legendcsimtarget,
                $this->legendcsimalt,
                $this->legendcsimwintarget
            );
        } elseif ($this->fill_color && $this->legend != '') {
            if (is_array($this->fill_color)) {
                $graph->legend->Add(
                    $this->legend,
                    $this->fill_color[0],
                    '',
                    0,
                    $this->legendcsimtarget,
                    $this->legendcsimalt,
                    $this->legendcsimwintarget
                );
            } else {
                $graph->legend->Add(
                    $this->legend,
                    $this->fill_color,
                    '',
                    0,
                    $this->legendcsimtarget,
                    $this->legendcsimalt,
                    $this->legendcsimwintarget
                );
            }
        }
    }

    // Gets called before any axis are stroked
    public function PreStrokeAdjust($graph)
    {
        parent::PreStrokeAdjust($graph);

        // If we are using a log Y-scale we want the base to be at the
        // minimum Y-value unless the user have specifically set some other
        // value than the default.
        if (substr($graph->axtype, -3, 3) == 'log' && $this->ybase == 0) {
            $this->ybase = $graph->yaxis->scale->GetMinVal();
        }

        // For a "text" X-axis scale we will adjust the
        // display of the bars a little bit.
        if (substr($graph->axtype, 0, 3) == 'tex') {
            // Position the ticks between the bars
            $graph->xaxis->scale->ticks->SetXLabelOffset(0.5, 0);

            // Center the bars
            if ($this->abswidth > -1) {
                $graph->SetTextScaleAbsCenterOff($this->abswidth);
            } else {
                if ($this->align == 'center') {
                    $graph->SetTextScaleOff(0.5 - $this->width / 2);
                } elseif ($this->align == 'right') {
                    $graph->SetTextScaleOff(1 - $this->width);
                }
            }
        } elseif (($this instanceof AccBarPlot) || ($this instanceof GroupBarPlot)) {
            // We only set an absolute width for linear and int scale
            // for text scale the width will be set to a fraction of
            // the majstep width.
            if ($this->abswidth == -1) {
                // Not set
                // set width to a visuable sensible default
                $this->abswidth = $graph->img->plotwidth / (2 * $this->numpoints);
            }
        }
    }

    public function Min()
    {
        $m = parent::Min();
        if ($m[1] >= $this->ybase) {
            $m[1] = $this->ybase;
        }

        return $m;
    }

    public function Max()
    {
        $m = parent::Max();
        if ($m[1] <= $this->ybase) {
            $m[1] = $this->ybase;
        }

        return $m;
    }

    // Specify width as fractions of the major stepo size
    public function SetWidth($aWidth)
    {
        if ($aWidth > 1) {
            // Interpret this as absolute width
            $this->abswidth = $aWidth;
        } else {
            $this->width = $aWidth;
        }
    }

    // Specify width in absolute pixels. If specified this
    // overrides SetWidth()
    public function SetAbsWidth($aWidth)
    {
        $this->abswidth = $aWidth;
    }

    public function SetAlign($aAlign)
    {
        $this->align = $aAlign;
    }

    public function SetNoFill()
    {
        $this->grad       = false;
        $this->fill_color = false;
        $this->fill       = false;
    }

    public function SetFillColor($aColor)
    {
        // Do an extra error check if the color is specified as an Image\RGB array triple
        // In that case convert it to a hex string since it will otherwise be
        // interpretated as an array of colors for each individual bar.

        $aColor           = Image\RGB::tryHexConversion($aColor);
        $this->fill       = true;
        $this->fill_color = $aColor;
    }

    public function SetFillGradient($aFromColor, $aToColor = null, $aStyle = null)
    {
        $this->grad           = true;
        $this->grad_fromcolor = $aFromColor;
        $this->grad_tocolor   = $aToColor;
        $this->grad_style     = $aStyle;
    }

    public function SetValuePos($aPos)
    {
        $this->valuepos = $aPos;
    }

    public function SetPattern($aPattern, $aColor = 'black')
    {
        if (is_array($aPattern)) {
            $n                     = safe_count($aPattern);
            $this->iPattern        = [];
            $this->iPatternDensity = [];
            if (is_array($aColor)) {
                $this->iPatternColor = [];
                if (safe_count($aColor) != $n) {
                    Util\JpGraphError::RaiseL(2001); //('NUmber of colors is not the same as the number of patterns in BarPlot::SetPattern()');
                }
            } else {
                $this->iPatternColor = $aColor;
            }
            for ($i = 0; $i < $n; ++$i) {
                $this->_SetPatternHelper($aPattern[$i], $this->iPattern[$i], $this->iPatternDensity[$i]);
                if (is_array($aColor)) {
                    $this->iPatternColor[$i] = $aColor[$i];
                }
            }
        } else {
            $this->_SetPatternHelper($aPattern, $this->iPattern, $this->iPatternDensity);
            $this->iPatternColor = $aColor;
        }
    }

    public function _SetPatternHelper($aPattern, &$aPatternValue, &$aDensity)
    {
        switch ($aPattern) {
            case PATTERN_DIAG1:
                $aPatternValue = 1;
                $aDensity      = 92;

                break;
            case PATTERN_DIAG2:
                $aPatternValue = 1;
                $aDensity      = 78;

                break;
            case PATTERN_DIAG3:
                $aPatternValue = 2;
                $aDensity      = 92;

                break;
            case PATTERN_DIAG4:
                $aPatternValue = 2;
                $aDensity      = 78;

                break;
            case PATTERN_CROSS1:
                $aPatternValue = 8;
                $aDensity      = 90;

                break;
            case PATTERN_CROSS2:
                $aPatternValue = 8;
                $aDensity      = 78;

                break;
            case PATTERN_CROSS3:
                $aPatternValue = 8;
                $aDensity      = 65;

                break;
            case PATTERN_CROSS4:
                $aPatternValue = 7;
                $aDensity      = 90;

                break;
            case PATTERN_STRIPE1:
                $aPatternValue = 5;
                $aDensity      = 94;

                break;
            case PATTERN_STRIPE2:
                $aPatternValue = 5;
                $aDensity      = 85;

                break;
            default:
                Util\JpGraphError::RaiseL(2002);
                //('Unknown pattern specified in call to BarPlot::SetPattern()');
        }
    }

    public function Stroke($img, $xscale, $yscale)
    {
        $numpoints = safe_count($this->coords[0]);
        if (isset($this->coords[1])) {
            if (safe_count($this->coords[1]) != $numpoints) {
                Util\JpGraphError::RaiseL(2003, safe_count($this->coords[1]), $numpoints);
            //"Number of X and Y points are not equal. Number of X-points:". safe_count($this->coords[1])."Number of Y-points:$numpoints");
            } else {
                $exist_x = true;
            }
        } else {
            $exist_x = false;
        }

        $numbars = safe_count($this->coords[0]);

        // Use GetMinVal() instead of scale[0] directly since in the case
        // of log scale we get a correct value. Log scales will have negative
        // values for values < 1 while still not representing negative numbers.
        if ($yscale->GetMinVal() >= 0) {
            $zp = $yscale->scale_abs[0];
        } else {
            $zp = $yscale->Translate(0);
        }

        if ($this->abswidth > -1) {
            $abswidth = $this->abswidth;
        } else {
            $abswidth = round($this->width * $xscale->scale_factor, 0);
        }

        // Count pontetial pattern array to avoid doing the count for each iteration
        if (is_array($this->iPattern)) {
            $np = safe_count($this->iPattern);
        }

        $grad = null;
        for ($i = 0; $i < $numbars; ++$i) {
            // If value is NULL, or 0 then don't draw a bar at all
            if ($this->coords[0][$i] === null || $this->coords[0][$i] === '') {
                continue;
            }

            if ($exist_x) {
                $x = $this->coords[1][$i];
            } else {
                $x = $i;
            }

            $x = $xscale->Translate($x);

            // Comment Note: This confuses the positioning when using acc together with
            // grouped bars. Workaround for fixing #191
            /*
            if( !$xscale->textscale ) {
            if($this->align=="center")
            $x -= $abswidth/2;
            elseif($this->align=="right")
            $x -= $abswidth;
            }
             */
            // Stroke fill color and fill gradient
            $pts = [
                $x, $zp,
                $x, $yscale->Translate($this->coords[0][$i]),
                $x + $abswidth, $yscale->Translate($this->coords[0][$i]),
                $x + $abswidth, $zp, ];
            if ($this->grad) {
                if ($grad === null) {
                    $grad = new Gradient($img);
                }
                if (is_array($this->grad_fromcolor)) {
                    // The first argument (grad_fromcolor) can be either an array or a single color. If it is an array
                    // then we have two choices. It can either a) be a single color specified as an Image\RGB triple or it can be
                    // an array to specify both (from, to style) for each individual bar. The way to know the difference is
                    // to investgate the first element. If this element is an integer [0,255] then we assume it is an Image\RGB
                    // triple.
                    $ng = safe_count($this->grad_fromcolor);
                    if ($ng === 3) {
                        if (is_numeric($this->grad_fromcolor[0]) && $this->grad_fromcolor[0] > 0 && $this->grad_fromcolor[0] < 256) {
                            // Image\RGB Triple
                            $fromcolor = $this->grad_fromcolor;
                            $tocolor   = $this->grad_tocolor;
                            $style     = $this->grad_style;
                        } else {
                            $fromcolor = $this->grad_fromcolor[$i % $ng][0];
                            $tocolor   = $this->grad_fromcolor[$i % $ng][1];
                            $style     = $this->grad_fromcolor[$i % $ng][2];
                        }
                    } else {
                        $fromcolor = $this->grad_fromcolor[$i % $ng][0];
                        $tocolor   = $this->grad_fromcolor[$i % $ng][1];
                        $style     = $this->grad_fromcolor[$i % $ng][2];
                    }
                    $grad->FilledRectangle(
                        $pts[2],
                        $pts[3],
                        $pts[6],
                        $pts[7],
                        $fromcolor,
                        $tocolor,
                        $style
                    );
                } else {
                    $grad->FilledRectangle(
                        $pts[2],
                        $pts[3],
                        $pts[6],
                        $pts[7],
                        $this->grad_fromcolor,
                        $this->grad_tocolor,
                        $this->grad_style
                    );
                }
            } elseif (!empty($this->fill_color)) {
                if (is_array($this->fill_color)) {
                    $img->PushColor($this->fill_color[$i % safe_count($this->fill_color)]);
                } else {
                    $img->PushColor($this->fill_color);
                }
                $img->FilledPolygon($pts);
                $img->PopColor();
            }

            /////////////////////////kokorahen rectangle polygon//////////////////////

            // Remember value of this bar
            $val = $this->coords[0][$i];

            if (!empty($val) && !is_numeric($val)) {
                Util\JpGraphError::RaiseL(2004, $i, $val);
                //'All values for a barplot must be numeric. You have specified value['.$i.'] == \''.$val.'\'');
            }

            // Determine the shadow
            if ($this->bar_shadow && $val != 0) {
                $ssh = $this->bar_shadow_hsize;
                $ssv = $this->bar_shadow_vsize;
                // Create points to create a "upper-right" shadow
                if ($val > 0) {
                    $sp[0]  = $pts[6];
                    $sp[1]  = $pts[7];
                    $sp[2]  = $pts[4];
                    $sp[3]  = $pts[5];
                    $sp[4]  = $pts[2];
                    $sp[5]  = $pts[3];
                    $sp[6]  = $pts[2] + $ssh;
                    $sp[7]  = $pts[3] - $ssv;
                    $sp[8]  = $pts[4] + $ssh;
                    $sp[9]  = $pts[5] - $ssv;
                    $sp[10] = $pts[6] + $ssh;
                    $sp[11] = $pts[7] - $ssv;
                } elseif ($val < 0) {
                    $sp[0]  = $pts[4];
                    $sp[1]  = $pts[5];
                    $sp[2]  = $pts[6];
                    $sp[3]  = $pts[7];
                    $sp[4]  = $pts[0];
                    $sp[5]  = $pts[1];
                    $sp[6]  = $pts[0] + $ssh;
                    $sp[7]  = $pts[1] - $ssv;
                    $sp[8]  = $pts[6] + $ssh;
                    $sp[9]  = $pts[7] - $ssv;
                    $sp[10] = $pts[4] + $ssh;
                    $sp[11] = $pts[5] - $ssv;
                }
                if (is_array($this->bar_shadow_color)) {
                    $numcolors = safe_count($this->bar_shadow_color);
                    if ($numcolors == 0) {
                        Util\JpGraphError::RaiseL(2005); //('You have specified an empty array for shadow colors in the bar plot.');
                    }
                    $img->PushColor($this->bar_shadow_color[$i % $numcolors]);
                } else {
                    $img->PushColor($this->bar_shadow_color);
                }
                $img->FilledPolygon($sp);
                $img->PopColor();
            } elseif ($this->bar_3d && $val != 0) {
                // Determine the 3D

                $ssh = $this->bar_3d_hsize;
                $ssv = $this->bar_3d_vsize;

                // Create points to create a "upper-right" shadow
                if ($val > 0) {
                    $sp1[0] = $pts[6];
                    $sp1[1] = $pts[7];
                    $sp1[2] = $pts[4];
                    $sp1[3] = $pts[5];
                    $sp1[4] = $pts[4] + $ssh;
                    $sp1[5] = $pts[5] - $ssv;
                    $sp1[6] = $pts[6] + $ssh;
                    $sp1[7] = $pts[7] - $ssv;

                    $sp2[0] = $pts[4];
                    $sp2[1] = $pts[5];
                    $sp2[2] = $pts[2];
                    $sp2[3] = $pts[3];
                    $sp2[4] = $pts[2] + $ssh;
                    $sp2[5] = $pts[3] - $ssv;
                    $sp2[6] = $pts[4] + $ssh;
                    $sp2[7] = $pts[5] - $ssv;
                } elseif ($val < 0) {
                    $sp1[0] = $pts[4];
                    $sp1[1] = $pts[5];
                    $sp1[2] = $pts[6];
                    $sp1[3] = $pts[7];
                    $sp1[4] = $pts[6] + $ssh;
                    $sp1[5] = $pts[7] - $ssv;
                    $sp1[6] = $pts[4] + $ssh;
                    $sp1[7] = $pts[5] - $ssv;

                    $sp2[0] = $pts[6];
                    $sp2[1] = $pts[7];
                    $sp2[2] = $pts[0];
                    $sp2[3] = $pts[1];
                    $sp2[4] = $pts[0] + $ssh;
                    $sp2[5] = $pts[1] - $ssv;
                    $sp2[6] = $pts[6] + $ssh;
                    $sp2[7] = $pts[7] - $ssv;
                }

                $base_color = $this->fill_color;

                $img->PushColor($base_color . ':0.7');
                $img->FilledPolygon($sp1);
                $img->PopColor();

                $img->PushColor($base_color . ':1.1');
                $img->FilledPolygon($sp2);
                $img->PopColor();
            }

            // Stroke the pattern
            if (is_array($this->iPattern)) {
                $f = new Graph\RectPatternFactory();
                if (is_array($this->iPatternColor)) {
                    $pcolor = $this->iPatternColor[$i % $np];
                } else {
                    $pcolor = $this->iPatternColor;
                }
                $prect = $f->Create($this->iPattern[$i % $np], $pcolor, 1);
                $prect->SetDensity($this->iPatternDensity[$i % $np]);

                if ($val < 0) {
                    $rx = $pts[0];
                    $ry = $pts[1];
                } else {
                    $rx = $pts[2];
                    $ry = $pts[3];
                }
                $width  = abs($pts[4] - $pts[0]) + 1;
                $height = abs($pts[1] - $pts[3]) + 1;
                $prect->SetPos(new Util\Rectangle($rx, $ry, $width, $height));
                $prect->Stroke($img);
            } else {
                if ($this->iPattern > -1) {
                    $f     = new Graph\RectPatternFactory();
                    $prect = $f->Create($this->iPattern, $this->iPatternColor, 1);
                    $prect->SetDensity($this->iPatternDensity);
                    if ($val < 0) {
                        $rx = $pts[0];
                        $ry = $pts[1];
                    } else {
                        $rx = $pts[2];
                        $ry = $pts[3];
                    }
                    $width  = abs($pts[4] - $pts[0]) + 1;
                    $height = abs($pts[1] - $pts[3]) + 1;
                    $prect->SetPos(new Util\Rectangle($rx, $ry, $width, $height));
                    $prect->Stroke($img);
                }
            }

            // Stroke the outline of the bar
            if (is_array($this->color)) {
                $img->SetColor($this->color[$i % safe_count($this->color)]);
            } else {
                $img->SetColor($this->color);
            }

            $pts[] = $pts[0];
            $pts[] = $pts[1];

            if ($this->weight > 0) {
                $img->SetLineWeight($this->weight);
                $img->Polygon($pts);
            }

            // Determine how to best position the values of the individual bars
            $x = $pts[2] + ($pts[4] - $pts[2]) / 2;
            $this->value->SetMargin(5);

            if ($this->valuepos == 'top') {
                $y = $pts[3];
                if ($img->a === 90) {
                    if ($val < 0) {
                        $this->value->SetAlign('right', 'center');
                    } else {
                        $this->value->SetAlign('left', 'center');
                    }
                } else {
                    if ($val < 0) {
                        $this->value->SetMargin(-5);
                        $y = $pts[1];
                        $this->value->SetAlign('center', 'bottom');
                    } else {
                        $this->value->SetAlign('center', 'bottom');
                    }
                }
                $this->value->Stroke($img, $val, $x, $y);
            } elseif ($this->valuepos == 'max') {
                $y = $pts[3];
                if ($img->a === 90) {
                    if ($val < 0) {
                        $this->value->SetAlign('left', 'center');
                    } else {
                        $this->value->SetAlign('right', 'center');
                    }
                } else {
                    if ($val < 0) {
                        $this->value->SetAlign('center', 'bottom');
                    } else {
                        $this->value->SetAlign('center', 'top');
                    }
                }
                $this->value->SetMargin(-5);
                $this->value->Stroke($img, $val, $x, $y);
            } elseif ($this->valuepos == 'center') {
                $y = ($pts[3] + $pts[1]) / 2;
                $this->value->SetAlign('center', 'center');
                $this->value->SetMargin(0);
                $this->value->Stroke($img, $val, $x, $y);
            } elseif ($this->valuepos == 'bottom' || $this->valuepos == 'min') {
                $y = $pts[1];
                if ($img->a === 90) {
                    if ($val < 0) {
                        $this->value->SetAlign('right', 'center');
                    } else {
                        $this->value->SetAlign('left', 'center');
                    }
                }
                $this->value->SetMargin(3);
                $this->value->Stroke($img, $val, $x, $y);
            } else {
                Util\JpGraphError::RaiseL(2006, $this->valuepos);
                //'Unknown position for values on bars :'.$this->valuepos);
            }
            // Create the client side image map
            $rpts      = $img->ArrRotate($pts);
            $csimcoord = round($rpts[0]) . ', ' . round($rpts[1]);
            for ($j = 1; $j < 4; ++$j) {
                $csimcoord .= ', ' . round($rpts[2 * $j]) . ', ' . round($rpts[2 * $j + 1]);
            }
            if (!empty($this->csimtargets[$i])) {
                $this->csimareas .= '<area shape="poly" coords="' . $csimcoord . '" ';
                $this->csimareas .= ' href="' . htmlentities($this->csimtargets[$i]) . '"';

                if (!empty($this->csimwintargets[$i])) {
                    $this->csimareas .= ' target="' . $this->csimwintargets[$i] . '" ';
                }

                $sval = '';
                if (!empty($this->csimalts[$i])) {
                    $sval = sprintf($this->csimalts[$i], $this->coords[0][$i]);
                    $this->csimareas .= " title=\"${sval}\" alt=\"${sval}\" ";
                }
                $this->csimareas .= " />\n";
            }
        }

        return true;
    }
} // @class

/* EOF */
