vendor/amenadiel/jpgraph/src/graph/Legend.php line 228

  1. <?php
  3. /**
  4.  * JPGraph v4.0.3
  5.  */
  7. namespace Amenadiel\JpGraph\Graph;
  9. use Amenadiel\JpGraph\Plot;
  10. use Amenadiel\JpGraph\Util;
  12. /*
  13.  * File:        JPGRAPH_LEGEND.INC.PHP
  14.  * // Description: Class to handle the legend box in the graph that gives
  15.  * //              names on the data series. The number of rows and columns
  16.  * //              in the legend are user specifyable.
  17.  * // Created:     2001-01-08 (Refactored to separate file 2008-08-01)
  18.  * // Ver:         $Id: jpgraph_legend.inc.php 1926 2010-01-11 16:33:07Z ljp $
  19.  * //
  20.  * // Copyright (c) Asial Corporation. All rights reserved.
  21.  */
  22. defined('_DEFAULT_LPM_SIZE') || define('_DEFAULT_LPM_SIZE', 8); // Default Legend Plot Mark size
  24. /**
  25.  * @class Legend
  26.  * // Description: Responsible for drawing the box containing
  27.  * // all the legend text for the graph
  28.  */
  29. class Legend
  30. {
  31.     public $txtcol          = [];
  32.     public $font_family     = FF_DEFAULT;
  33.     public $font_style      = FS_NORMAL;
  34.     public $font_size       = 8; // old. 12
  35.     private $color          = [120, 120, 120]; // Default frame color
  36.     private $fill_color     = [245, 245, 245]; // Default fill color
  37.     private $shadow         = false; // Shadow around legend "box"
  38.     private $shadow_color   = 'darkgray';
  39.     private $mark_abs_hsize = _DEFAULT_LPM_SIZE;
  40.     private $mark_abs_vsize = _DEFAULT_LPM_SIZE;
  41.     private $xmargin        = 10;
  42.     private $ymargin        = 0;
  43.     private $shadow_width   = 2;
  44.     private $xlmargin       = 4;
  45.     private $ylinespacing   = 5;
  47.     // We need a separate margin since the baseline of the last text would coincide with the bottom otherwise
  48.     private $ybottom_margin = 8;
  50.     private $xpos         = 0.05;
  51.     private $ypos         = 0.15;
  52.     private $xabspos      = -1;
  53.     private $yabspos      = -1;
  54.     private $halign       = 'right';
  55.     private $valign       = 'top';
  56.     private $font_color   = 'black';
  57.     private $hide         = false;
  58.     private $layout_n     = 1;
  59.     private $weight       = 1;
  60.     private $frameweight  = 1;
  61.     private $csimareas    = '';
  62.     private $reverse      = false;
  63.     private $bkg_gradtype = -1;
  64.     private $bkg_gradfrom = 'lightgray';
  65.     private $bkg_gradto   = 'gray';
  67.     /**
  68.      * CONSTRUCTOR.
  69.      */
  70.     public function __construct()
  71.     {
  72.         // Empty
  73.     }
  75.     /**
  76.      * PUBLIC METHODS.
  77.      *
  78.      * @param mixed $aHide
  79.      */
  80.     public function Hide($aHide = true)
  81.     {
  82.         $this->hide = $aHide;
  83.     }
  85.     public function SetHColMargin($aXMarg)
  86.     {
  87.         $this->xmargin = $aXMarg;
  88.     }
  90.     public function SetVColMargin($aSpacing)
  91.     {
  92.         $this->ylinespacing = $aSpacing;
  93.     }
  95.     public function SetLeftMargin($aXMarg)
  96.     {
  97.         $this->xlmargin = $aXMarg;
  98.     }
  100.     // Synonym
  101.     public function SetLineSpacing($aSpacing)
  102.     {
  103.         $this->ylinespacing = $aSpacing;
  104.     }
  106.     public function SetShadow($aShow = 'gray', $aWidth = 4)
  107.     {
  108.         if (is_string($aShow)) {
  109.             $this->shadow_color = $aShow;
  110.             $this->shadow       = true;
  111.         } else {
  112.             $this->shadow = $aShow;
  113.         }
  114.         $this->shadow_width = $aWidth;
  115.     }
  117.     public function SetMarkAbsSize($aSize)
  118.     {
  119.         $this->mark_abs_vsize = $aSize;
  120.         $this->mark_abs_hsize = $aSize;
  121.     }
  123.     public function SetMarkAbsVSize($aSize)
  124.     {
  125.         $this->mark_abs_vsize = $aSize;
  126.     }
  128.     public function SetMarkAbsHSize($aSize)
  129.     {
  130.         $this->mark_abs_hsize = $aSize;
  131.     }
  133.     public function SetLineWeight($aWeight)
  134.     {
  135.         $this->weight = $aWeight;
  136.     }
  138.     public function SetFrameWeight($aWeight)
  139.     {
  140.         $this->frameweight = $aWeight;
  141.     }
  143.     public function SetLayout($aDirection = LEGEND_VERT)
  144.     {
  145.         $this->layout_n = $aDirection == LEGEND_VERT ? 1 : 99;
  146.     }
  148.     public function SetColumns($aCols)
  149.     {
  150.         $this->layout_n = $aCols;
  151.     }
  153.     public function SetReverse($f = true)
  154.     {
  155.         $this->reverse = $f;
  156.     }
  158.     // Set color on frame around box
  159.     public function SetColor($aFontColor, $aColor = 'black')
  160.     {
  161.         $this->font_color = $aFontColor;
  162.         $this->color      = $aColor;
  163.     }
  165.     public function SetFont($aFamily, $aStyle = FS_NORMAL, $aSize = 10)
  166.     {
  167.         $this->font_family = $aFamily;
  168.         $this->font_style  = $aStyle;
  169.         $this->font_size   = $aSize;
  170.     }
  172.     public function SetPos($aX, $aY, $aHAlign = 'right', $aVAlign = 'top')
  173.     {
  174.         $this->Pos($aX, $aY, $aHAlign, $aVAlign);
  175.     }
  177.     public function SetAbsPos($aX, $aY, $aHAlign = 'right', $aVAlign = 'top')
  178.     {
  179.         $this->xabspos = $aX;
  180.         $this->yabspos = $aY;
  181.         $this->halign  = $aHAlign;
  182.         $this->valign  = $aVAlign;
  183.     }
  185.     public function Pos($aX, $aY, $aHAlign = 'right', $aVAlign = 'top')
  186.     {
  187.         if (!($aX < 1 && $aY < 1)) {
  188.             Util\JpGraphError::RaiseL(25120); //(" Position for legend must be given as percentage in range 0-1");
  189.         }
  190.         $this->xpos   = $aX;
  191.         $this->ypos   = $aY;
  192.         $this->halign = $aHAlign;
  193.         $this->valign = $aVAlign;
  194.     }
  196.     public function SetFillColor($aColor)
  197.     {
  198.         $this->fill_color = $aColor;
  199.     }
  201.     public function Clear()
  202.     {
  203.         $this->txtcol = [];
  204.     }
  206.     public function Add($aTxt, $aColor, $aPlotmark = '', $aLinestyle = 0, $csimtarget = '', $csimalt = '', $csimwintarget = '')
  207.     {
  208.         $this->txtcol[] = [$aTxt, $aColor, $aPlotmark, $aLinestyle, $csimtarget, $csimalt, $csimwintarget];
  209.     }
  211.     public function GetCSIMAreas()
  212.     {
  213.         return $this->csimareas;
  214.     }
  216.     public function SetBackgroundGradient($aFrom = 'navy', $aTo = 'silver', $aGradType = 2)
  217.     {
  218.         $this->bkg_gradtype = $aGradType;
  219.         $this->bkg_gradfrom = $aFrom;
  220.         $this->bkg_gradto   = $aTo;
  221.     }
  223.     public function HasItems()
  224.     {
  225.         return (bool) (safe_count($this->txtcol));
  226.     }
  228.     public function Stroke($aImg)
  229.     {
  230.         // Constant
  231.         $fillBoxFrameWeight = 1;
  233.         if ($this->hide) {
  234.             return;
  235.         }
  237.         $aImg->SetFont($this->font_family, $this->font_style, $this->font_size);
  239.         if ($this->reverse) {
  240.             $this->txtcol = array_reverse($this->txtcol);
  241.         }
  243.         $n = safe_count($this->txtcol);
  244.         if ($n == 0) {
  245.             return;
  246.         }
  248.         // Find out the max width and height of each column to be able
  249.         // to size the legend box.
  250.         $numcolumns = ($n > $this->layout_n ? $this->layout_n : $n);
  251.         for ($i = 0; $i < $numcolumns; ++$i) {
  252.             $colwidth[$i] = $aImg->GetTextWidth($this->txtcol[$i][0]) +
  253.             2 * $this->xmargin + 2 * $this->mark_abs_hsize;
  254.             $colheight[$i] = 0;
  255.         }
  257.         // Find our maximum height in each row
  258.         $rows         = 0;
  259.         $rowheight[0] = 0;
  260.         for ($i = 0; $i < $n; ++$i) {
  261.             $h = max($this->mark_abs_vsize, $aImg->GetTextHeight($this->txtcol[$i][0])) + $this->ylinespacing;
  263.             // Makes sure we always have a minimum of 1/4 (1/2 on each side) of the mark as space
  264.             // between two vertical legend entries
  265.             //$h = round(max($h,$this->mark_abs_vsize+$this->ymargin));
  266.             //echo "Textheight #$i: tetxheight=".$aImg->GetTextHeight($this->txtcol[$i][0]).', ';
  267.             //echo "h=$h ({$this->mark_abs_vsize},{$this->ymargin})<br>";
  268.             if ($i % $numcolumns == 0) {
  269.                 ++$rows;
  270.                 $rowheight[$rows - 1] = 0;
  271.             }
  272.             $rowheight[$rows - 1] = max($rowheight[$rows - 1], $h) + 1;
  273.         }
  275.         $abs_height = 0;
  276.         for ($i = 0; $i < $rows; ++$i) {
  277.             $abs_height += $rowheight[$i];
  278.         }
  280.         // Make sure that the height is at least as high as mark size + ymargin
  281.         $abs_height = max($abs_height, $this->mark_abs_vsize);
  282.         $abs_height += $this->ybottom_margin;
  284.         // Find out the maximum width in each column
  285.         for ($i = $numcolumns; $i < $n; ++$i) {
  286.             $colwidth[$i % $numcolumns] = max(
  287.                 $aImg->GetTextWidth($this->txtcol[$i][0]) + 2 * $this->xmargin + 2 * $this->mark_abs_hsize,
  288.                 $colwidth[$i % $numcolumns]
  289.             );
  290.         }
  292.         // Get the total width
  293.         $mtw = 0;
  294.         for ($i = 0; $i < $numcolumns; ++$i) {
  295.             $mtw += $colwidth[$i];
  296.         }
  298.         // remove the last rows interpace margin (since there is no next row)
  299.         $abs_height -= $this->ylinespacing;
  301.         // Find out maximum width we need for legend box
  302.         $abs_width = $mtw + $this->xlmargin + ($numcolumns - 1) * $this->mark_abs_hsize;
  304.         if ($this->xabspos === -1 && $this->yabspos === -1) {
  305.             $this->xabspos = $this->xpos * $aImg->width;
  306.             $this->yabspos = $this->ypos * $aImg->height;
  307.         }
  309.         // Positioning of the legend box
  310.         if ($this->halign == 'left') {
  311.             $xp = $this->xabspos;
  312.         } elseif ($this->halign == 'center') {
  313.             $xp = $this->xabspos - $abs_width / 2;
  314.         } else {
  315.             $xp = $aImg->width - $this->xabspos - $abs_width;
  316.         }
  318.         $yp = $this->yabspos;
  319.         if ($this->valign == 'center') {
  320.             $yp -= $abs_height / 2;
  321.         } elseif ($this->valign == 'bottom') {
  322.             $yp -= $abs_height;
  323.         }
  325.         // Stroke legend box
  326.         $aImg->SetColor($this->color);
  327.         $aImg->SetLineWeight($this->frameweight);
  328.         $aImg->SetLineStyle('solid');
  330.         if ($this->shadow) {
  331.             $aImg->ShadowRectangle(
  332.                 $xp,
  333.                 $yp,
  334.                 $xp + $abs_width + $this->shadow_width + 2,
  335.                 $yp + $abs_height + $this->shadow_width + 2,
  336.                 $this->fill_color,
  337.                 $this->shadow_width + 2,
  338.                 $this->shadow_color
  339.             );
  340.         } else {
  341.             $aImg->SetColor($this->fill_color);
  342.             $aImg->FilledRectangle($xp, $yp, $xp + $abs_width, $yp + $abs_height);
  343.             $aImg->SetColor($this->color);
  344.             $aImg->Rectangle($xp, $yp, $xp + $abs_width, $yp + $abs_height);
  345.         }
  347.         if ($this->bkg_gradtype >= 0) {
  348.             $grad = new Plot\Gradient($aImg);
  349.             $grad->FilledRectangle(
  350.                 $xp + 1,
  351.                 $yp + 1,
  352.                 $xp + $abs_width - 3,
  353.                 $yp + $abs_height - 3,
  354.                 $this->bkg_gradfrom,
  355.                 $this->bkg_gradto,
  356.                 $this->bkg_gradtype
  357.             );
  358.         }
  360.         // x1,y1 is the position for the legend marker + text
  361.         // The vertical position is the baseline position for the text
  362.         // and every marker is adjusted acording to that.
  364.         // For multiline texts this get more complicated.
  366.         $x1 = $xp + $this->xlmargin;
  367.         $y1 = $yp + $rowheight[0] - $this->ylinespacing + 2; // The ymargin is included in rowheight
  369.         // Now, y1 is the bottom vertical position of the first legend, i.e if
  370.         // the legend has multiple lines it is the bottom line.
  372.         $grad           = new Plot\Gradient($aImg);
  373.         $patternFactory = null;
  375.         // Now stroke each legend in turn
  376.         // Each plot has added the following information to  the legend
  377.         // p[0] = Legend text
  378.         // p[1] = Color,
  379.         // p[2] = For markers a reference to the PlotMark object
  380.         // p[3] = For lines the line style, for gradient the negative gradient style
  381.         // p[4] = CSIM target
  382.         // p[5] = CSIM Alt text
  383.         $i   = 1;
  384.         $row = 0;
  385.         foreach ($this->txtcol as $p) {
  386.             // STROKE DEBUG BOX
  387.             if (_JPG_DEBUG) {
  388.                 $aImg->SetLineWeight(1);
  389.                 $aImg->SetColor('red');
  390.                 $aImg->SetLineStyle('solid');
  391.                 $aImg->Rectangle($x1, $y1, $xp + $abs_width - 1, $y1 - $rowheight[$row]);
  392.             }
  394.             $aImg->SetLineWeight($this->weight);
  395.             $x1 = round($x1) + 1; // We add one to not collide with the border
  396.             $y1 = round($y1);
  398.             // This is the center offset up from the baseline which is
  399.             // considered the "center" of the marks. This gets slightly complicated since
  400.             // we need to consider if the text is a multiline paragraph or if it is only
  401.             // a single line. The reason is that for single line the y1 corresponds to the baseline
  402.             // and that is fine. However for a multiline paragraph there is no single baseline
  403.             // and in that case the y1 corresponds to the lowest y for the bounding box. In that
  404.             // case we center the mark in the middle of the paragraph
  405.             if (!preg_match('/\n/', $p[0])) {
  406.                 // Single line
  407.                 $marky = ceil($y1 - $this->mark_abs_vsize / 2) - 1;
  408.             } else {
  409.                 // Paragraph
  410.                 $marky = $y1 - $aImg->GetTextHeight($p[0]) / 2;
  412.                 //  echo "y1=$y1, p[o]={$p[0]}, marky=$marky<br>";
  413.             }
  415.             //echo "<br>Mark #$i: marky=$marky<br>";
  417.             $x1 += $this->mark_abs_hsize;
  419.             if (!empty($p[2]) && $p[2]->GetType() > -1) {
  420.                 // Make a plot mark legend. This is constructed with a mark which
  421.                 // is run through with a line
  423.                 // First construct a bit of the line that looks exactly like the
  424.                 // line in the plot
  425.                 $aImg->SetColor($p[1]);
  426.                 if (is_string($p[3]) || $p[3] > 0) {
  427.                     $aImg->SetLineStyle($p[3]);
  428.                     $aImg->StyleLine($x1 - $this->mark_abs_hsize, $marky, $x1 + $this->mark_abs_hsize, $marky);
  429.                 }
  431.                 // Stroke a mark using image
  432.                 if ($p[2]->GetType() == MARK_IMG) {
  433.                     $p[2]->Stroke($aImg, $x1, $marky);
  434.                 }
  436.                 // Stroke a mark with the standard size
  437.                 // (As long as it is not an image mark )
  438.                 if ($p[2]->GetType() != MARK_IMG) {
  439.                     // Clear any user callbacks since we ont want them called for
  440.                     // the legend marks
  441.                     $p[2]->iFormatCallback  = '';
  442.                     $p[2]->iFormatCallback2 = '';
  444.                     // Since size for circles is specified as the radius
  445.                     // this means that we must half the size to make the total
  446.                     // width behave as the other marks
  447.                     if ($p[2]->GetType() == MARK_FILLEDCIRCLE || $p[2]->GetType() == MARK_CIRCLE) {
  448.                         $p[2]->SetSize(min($this->mark_abs_vsize, $this->mark_abs_hsize) / 2);
  449.                         $p[2]->Stroke($aImg, $x1, $marky);
  450.                     } else {
  451.                         $p[2]->SetSize(min($this->mark_abs_vsize, $this->mark_abs_hsize));
  452.                         $p[2]->Stroke($aImg, $x1, $marky);
  453.                     }
  454.                 }
  455.             } elseif (!empty($p[2]) && (is_string($p[3]) || $p[3] > 0)) {
  456.                 // Draw a styled line
  457.                 $aImg->SetColor($p[1]);
  458.                 $aImg->SetLineStyle($p[3]);
  459.                 $aImg->StyleLine($x1 - $this->mark_abs_hsize, $marky, $x1 + $this->mark_abs_hsize, $marky);
  460.                 $aImg->StyleLine($x1 - $this->mark_abs_hsize, $marky + 1, $x1 + $this->mark_abs_hsize, $marky + 1);
  461.             } else {
  462.                 // Draw a colored box
  463.                 $color = $p[1];
  465.                 // We make boxes slightly larger to better show
  466.                 $boxsize = max($this->mark_abs_vsize, $this->mark_abs_hsize) + 2;
  468.                 $ym = $marky - ceil($boxsize / 2); // Marker y-coordinate
  470.                 // We either need to plot a gradient or a
  471.                 // pattern. To differentiate we use a kludge.
  472.                 // Patterns have a p[3] value of < -100
  473.                 if ($p[3] < -100) {
  474.                     // p[1][0] == iPattern, p[1][1] == iPatternColor, p[1][2] == iPatternDensity
  475.                     if ($patternFactory == null) {
  476.                         $patternFactory = new RectPatternFactory();
  477.                     }
  478.                     $prect = $patternFactory->Create($p[1][0], $p[1][1], 1);
  479.                     $prect->SetBackground($p[1][3]);
  480.                     $prect->SetDensity($p[1][2] + 1);
  481.                     $prect->SetPos(new Util\Rectangle($x1, $ym, $boxsize, $boxsize));
  482.                     $prect->Stroke($aImg);
  483.                     $prect = null;
  484.                 } else {
  485.                     if (is_array($color) && safe_count($color) == 2) {
  486.                         // The client want a gradient color
  487.                         $grad->FilledRectangle(
  488.                             $x1 - $boxsize / 2,
  489.                             $ym,
  490.                             $x1 + $boxsize / 2,
  491.                             $ym + $boxsize,
  492.                             $color[0],
  493.                             $color[1],
  494.                             -$p[3]
  495.                         );
  496.                     } else {
  497.                         $aImg->SetColor($p[1]);
  498.                         $aImg->FilledRectangle($x1 - $boxsize / 2, $ym, $x1 + $boxsize / 2, $ym + $boxsize);
  499.                     }
  501.                     // Draw a plot frame line
  502.                     $aImg->SetColor($this->color);
  503.                     $aImg->SetLineWeight($fillBoxFrameWeight);
  504.                     $aImg->Rectangle(
  505.                         $x1 - $boxsize / 2,
  506.                         $ym,
  507.                         $x1 + $boxsize / 2,
  508.                         $ym + $boxsize
  509.                     );
  510.                 }
  511.             }
  512.             $aImg->SetColor($this->font_color);
  513.             $aImg->SetFont($this->font_family, $this->font_style, $this->font_size);
  514.             $aImg->SetTextAlign('left', 'baseline');
  516.             $debug = false;
  517.             $aImg->StrokeText(
  518.                 $x1 + $this->mark_abs_hsize + $this->xmargin,
  519.                 $y1,
  520.                 $p[0],
  521.                 0,
  522.                 'left',
  523.                 $debug
  524.             );
  526.             // Add CSIM for Legend if defined
  527.             if (!empty($p[4])) {
  528.                 $xs     = $x1 - $this->mark_abs_hsize;
  529.                 $ys     = $y1 + 1;
  530.                 $xe     = $x1 + $aImg->GetTextWidth($p[0]) + $this->mark_abs_hsize + $this->xmargin;
  531.                 $ye     = $y1 - $rowheight[$row] + 1;
  532.                 $coords = "${xs},${ys},${xe},${y1},${xe},${ye},${xs},${ye}";
  533.                 if (!empty($p[4])) {
  534.                     $this->csimareas .= "<area shape=\"poly\" coords=\"${coords}\" href=\"" . htmlentities($p[4]) . '"';
  536.                     if (!empty($p[6])) {
  537.                         $this->csimareas .= ' target="' . $p[6] . '"';
  538.                     }
  540.                     if (!empty($p[5])) {
  541.                         $tmp = sprintf($p[5], $p[0]);
  542.                         $this->csimareas .= " title=\"${tmp}\" alt=\"${tmp}\" ";
  543.                     }
  544.                     $this->csimareas .= " />\n";
  545.                 }
  546.             }
  548.             if ($i >= $this->layout_n) {
  549.                 $x1 = $xp + $this->xlmargin;
  550.                 ++$row;
  551.                 if (!empty($rowheight[$row])) {
  552.                     $y1 += $rowheight[$row];
  553.                 }
  555.                 $i = 1;
  556.             } else {
  557.                 $x1 += $colwidth[($i - 1) % $numcolumns];
  558.                 ++$i;
  559.             }
  560.         }
  561.     }
  562. } // @class