[Summary view]

Differences Between: [Versions 310 and 311] [Versions 311 and 400] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403] [Versions 39 and 311]

   1  <?php
   2  
   3  namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
   4  
   5  use PhpOffice\PhpSpreadsheet\Calculation\Functions;
   6  use PhpOffice\PhpSpreadsheet\Chart\DataSeries;
   7  use PhpOffice\PhpSpreadsheet\Chart\DataSeriesValues;
   8  use PhpOffice\PhpSpreadsheet\Chart\Layout;
   9  use PhpOffice\PhpSpreadsheet\Chart\Legend;
  10  use PhpOffice\PhpSpreadsheet\Chart\PlotArea;
  11  use PhpOffice\PhpSpreadsheet\Chart\Title;
  12  use PhpOffice\PhpSpreadsheet\RichText\RichText;
  13  use PhpOffice\PhpSpreadsheet\Style\Color;
  14  use PhpOffice\PhpSpreadsheet\Style\Font;
  15  use SimpleXMLElement;
  16  
  17  class Chart
  18  {
  19      /**
  20       * @param string $name
  21       * @param string $format
  22       *
  23       * @return null|bool|float|int|string
  24       */
  25      private static function getAttribute(SimpleXMLElement $component, $name, $format)
  26      {
  27          $attributes = $component->attributes();
  28          if (isset($attributes[$name])) {
  29              if ($format == 'string') {
  30                  return (string) $attributes[$name];
  31              } elseif ($format == 'integer') {
  32                  return (int) $attributes[$name];
  33              } elseif ($format == 'boolean') {
  34                  return (bool) ($attributes[$name] === '0' || $attributes[$name] !== 'true') ? false : true;
  35              }
  36  
  37              return (float) $attributes[$name];
  38          }
  39  
  40          return null;
  41      }
  42  
  43      private static function readColor($color, $background = false)
  44      {
  45          if (isset($color['rgb'])) {
  46              return (string) $color['rgb'];
  47          } elseif (isset($color['indexed'])) {
  48              return Color::indexedColor($color['indexed'] - 7, $background)->getARGB();
  49          }
  50      }
  51  
  52      /**
  53       * @param string $chartName
  54       *
  55       * @return \PhpOffice\PhpSpreadsheet\Chart\Chart
  56       */
  57      public static function readChart(SimpleXMLElement $chartElements, $chartName)
  58      {
  59          $namespacesChartMeta = $chartElements->getNamespaces(true);
  60          $chartElementsC = $chartElements->children($namespacesChartMeta['c']);
  61  
  62          $XaxisLabel = $YaxisLabel = $legend = $title = null;
  63          $dispBlanksAs = $plotVisOnly = null;
  64  
  65          foreach ($chartElementsC as $chartElementKey => $chartElement) {
  66              switch ($chartElementKey) {
  67                  case 'chart':
  68                      foreach ($chartElement as $chartDetailsKey => $chartDetails) {
  69                          $chartDetailsC = $chartDetails->children($namespacesChartMeta['c']);
  70                          switch ($chartDetailsKey) {
  71                              case 'plotArea':
  72                                  $plotAreaLayout = $XaxisLable = $YaxisLable = null;
  73                                  $plotSeries = $plotAttributes = [];
  74                                  foreach ($chartDetails as $chartDetailKey => $chartDetail) {
  75                                      switch ($chartDetailKey) {
  76                                          case 'layout':
  77                                              $plotAreaLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta);
  78  
  79                                              break;
  80                                          case 'catAx':
  81                                              if (isset($chartDetail->title)) {
  82                                                  $XaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta);
  83                                              }
  84  
  85                                              break;
  86                                          case 'dateAx':
  87                                              if (isset($chartDetail->title)) {
  88                                                  $XaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta);
  89                                              }
  90  
  91                                              break;
  92                                          case 'valAx':
  93                                              if (isset($chartDetail->title)) {
  94                                                  $YaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta);
  95                                              }
  96  
  97                                              break;
  98                                          case 'barChart':
  99                                          case 'bar3DChart':
 100                                              $barDirection = self::getAttribute($chartDetail->barDir, 'val', 'string');
 101                                              $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 102                                              $plotSer->setPlotDirection($barDirection);
 103                                              $plotSeries[] = $plotSer;
 104                                              $plotAttributes = self::readChartAttributes($chartDetail);
 105  
 106                                              break;
 107                                          case 'lineChart':
 108                                          case 'line3DChart':
 109                                              $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 110                                              $plotAttributes = self::readChartAttributes($chartDetail);
 111  
 112                                              break;
 113                                          case 'areaChart':
 114                                          case 'area3DChart':
 115                                              $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 116                                              $plotAttributes = self::readChartAttributes($chartDetail);
 117  
 118                                              break;
 119                                          case 'doughnutChart':
 120                                          case 'pieChart':
 121                                          case 'pie3DChart':
 122                                              $explosion = isset($chartDetail->ser->explosion);
 123                                              $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 124                                              $plotSer->setPlotStyle($explosion);
 125                                              $plotSeries[] = $plotSer;
 126                                              $plotAttributes = self::readChartAttributes($chartDetail);
 127  
 128                                              break;
 129                                          case 'scatterChart':
 130                                              $scatterStyle = self::getAttribute($chartDetail->scatterStyle, 'val', 'string');
 131                                              $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 132                                              $plotSer->setPlotStyle($scatterStyle);
 133                                              $plotSeries[] = $plotSer;
 134                                              $plotAttributes = self::readChartAttributes($chartDetail);
 135  
 136                                              break;
 137                                          case 'bubbleChart':
 138                                              $bubbleScale = self::getAttribute($chartDetail->bubbleScale, 'val', 'integer');
 139                                              $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 140                                              $plotSer->setPlotStyle($bubbleScale);
 141                                              $plotSeries[] = $plotSer;
 142                                              $plotAttributes = self::readChartAttributes($chartDetail);
 143  
 144                                              break;
 145                                          case 'radarChart':
 146                                              $radarStyle = self::getAttribute($chartDetail->radarStyle, 'val', 'string');
 147                                              $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 148                                              $plotSer->setPlotStyle($radarStyle);
 149                                              $plotSeries[] = $plotSer;
 150                                              $plotAttributes = self::readChartAttributes($chartDetail);
 151  
 152                                              break;
 153                                          case 'surfaceChart':
 154                                          case 'surface3DChart':
 155                                              $wireFrame = self::getAttribute($chartDetail->wireframe, 'val', 'boolean');
 156                                              $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 157                                              $plotSer->setPlotStyle($wireFrame);
 158                                              $plotSeries[] = $plotSer;
 159                                              $plotAttributes = self::readChartAttributes($chartDetail);
 160  
 161                                              break;
 162                                          case 'stockChart':
 163                                              $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
 164                                              $plotAttributes = self::readChartAttributes($plotAreaLayout);
 165  
 166                                              break;
 167                                      }
 168                                  }
 169                                  if ($plotAreaLayout == null) {
 170                                      $plotAreaLayout = new Layout();
 171                                  }
 172                                  $plotArea = new PlotArea($plotAreaLayout, $plotSeries);
 173                                  self::setChartAttributes($plotAreaLayout, $plotAttributes);
 174  
 175                                  break;
 176                              case 'plotVisOnly':
 177                                  $plotVisOnly = self::getAttribute($chartDetails, 'val', 'string');
 178  
 179                                  break;
 180                              case 'dispBlanksAs':
 181                                  $dispBlanksAs = self::getAttribute($chartDetails, 'val', 'string');
 182  
 183                                  break;
 184                              case 'title':
 185                                  $title = self::chartTitle($chartDetails, $namespacesChartMeta);
 186  
 187                                  break;
 188                              case 'legend':
 189                                  $legendPos = 'r';
 190                                  $legendLayout = null;
 191                                  $legendOverlay = false;
 192                                  foreach ($chartDetails as $chartDetailKey => $chartDetail) {
 193                                      switch ($chartDetailKey) {
 194                                          case 'legendPos':
 195                                              $legendPos = self::getAttribute($chartDetail, 'val', 'string');
 196  
 197                                              break;
 198                                          case 'overlay':
 199                                              $legendOverlay = self::getAttribute($chartDetail, 'val', 'boolean');
 200  
 201                                              break;
 202                                          case 'layout':
 203                                              $legendLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta);
 204  
 205                                              break;
 206                                      }
 207                                  }
 208                                  $legend = new Legend($legendPos, $legendLayout, $legendOverlay);
 209  
 210                                  break;
 211                          }
 212                      }
 213              }
 214          }
 215          $chart = new \PhpOffice\PhpSpreadsheet\Chart\Chart($chartName, $title, $legend, $plotArea, $plotVisOnly, $dispBlanksAs, $XaxisLabel, $YaxisLabel);
 216  
 217          return $chart;
 218      }
 219  
 220      private static function chartTitle(SimpleXMLElement $titleDetails, array $namespacesChartMeta)
 221      {
 222          $caption = [];
 223          $titleLayout = null;
 224          foreach ($titleDetails as $titleDetailKey => $chartDetail) {
 225              switch ($titleDetailKey) {
 226                  case 'tx':
 227                      $titleDetails = $chartDetail->rich->children($namespacesChartMeta['a']);
 228                      foreach ($titleDetails as $titleKey => $titleDetail) {
 229                          switch ($titleKey) {
 230                              case 'p':
 231                                  $titleDetailPart = $titleDetail->children($namespacesChartMeta['a']);
 232                                  $caption[] = self::parseRichText($titleDetailPart);
 233                          }
 234                      }
 235  
 236                      break;
 237                  case 'layout':
 238                      $titleLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta);
 239  
 240                      break;
 241              }
 242          }
 243  
 244          return new Title($caption, $titleLayout);
 245      }
 246  
 247      private static function chartLayoutDetails($chartDetail, $namespacesChartMeta)
 248      {
 249          if (!isset($chartDetail->manualLayout)) {
 250              return null;
 251          }
 252          $details = $chartDetail->manualLayout->children($namespacesChartMeta['c']);
 253          if ($details === null) {
 254              return null;
 255          }
 256          $layout = [];
 257          foreach ($details as $detailKey => $detail) {
 258              $layout[$detailKey] = self::getAttribute($detail, 'val', 'string');
 259          }
 260  
 261          return new Layout($layout);
 262      }
 263  
 264      private static function chartDataSeries($chartDetail, $namespacesChartMeta, $plotType)
 265      {
 266          $multiSeriesType = null;
 267          $smoothLine = false;
 268          $seriesLabel = $seriesCategory = $seriesValues = $plotOrder = [];
 269  
 270          $seriesDetailSet = $chartDetail->children($namespacesChartMeta['c']);
 271          foreach ($seriesDetailSet as $seriesDetailKey => $seriesDetails) {
 272              switch ($seriesDetailKey) {
 273                  case 'grouping':
 274                      $multiSeriesType = self::getAttribute($chartDetail->grouping, 'val', 'string');
 275  
 276                      break;
 277                  case 'ser':
 278                      $marker = null;
 279                      $seriesIndex = '';
 280                      foreach ($seriesDetails as $seriesKey => $seriesDetail) {
 281                          switch ($seriesKey) {
 282                              case 'idx':
 283                                  $seriesIndex = self::getAttribute($seriesDetail, 'val', 'integer');
 284  
 285                                  break;
 286                              case 'order':
 287                                  $seriesOrder = self::getAttribute($seriesDetail, 'val', 'integer');
 288                                  $plotOrder[$seriesIndex] = $seriesOrder;
 289  
 290                                  break;
 291                              case 'tx':
 292                                  $seriesLabel[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta);
 293  
 294                                  break;
 295                              case 'marker':
 296                                  $marker = self::getAttribute($seriesDetail->symbol, 'val', 'string');
 297  
 298                                  break;
 299                              case 'smooth':
 300                                  $smoothLine = self::getAttribute($seriesDetail, 'val', 'boolean');
 301  
 302                                  break;
 303                              case 'cat':
 304                                  $seriesCategory[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta);
 305  
 306                                  break;
 307                              case 'val':
 308                                  $seriesValues[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
 309  
 310                                  break;
 311                              case 'xVal':
 312                                  $seriesCategory[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
 313  
 314                                  break;
 315                              case 'yVal':
 316                                  $seriesValues[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
 317  
 318                                  break;
 319                          }
 320                      }
 321              }
 322          }
 323  
 324          return new DataSeries($plotType, $multiSeriesType, $plotOrder, $seriesLabel, $seriesCategory, $seriesValues, $smoothLine);
 325      }
 326  
 327      private static function chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker = null)
 328      {
 329          if (isset($seriesDetail->strRef)) {
 330              $seriesSource = (string) $seriesDetail->strRef->f;
 331              $seriesData = self::chartDataSeriesValues($seriesDetail->strRef->strCache->children($namespacesChartMeta['c']), 's');
 332  
 333              return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
 334          } elseif (isset($seriesDetail->numRef)) {
 335              $seriesSource = (string) $seriesDetail->numRef->f;
 336              $seriesData = self::chartDataSeriesValues($seriesDetail->numRef->numCache->children($namespacesChartMeta['c']));
 337  
 338              return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
 339          } elseif (isset($seriesDetail->multiLvlStrRef)) {
 340              $seriesSource = (string) $seriesDetail->multiLvlStrRef->f;
 341              $seriesData = self::chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlStrRef->multiLvlStrCache->children($namespacesChartMeta['c']), 's');
 342              $seriesData['pointCount'] = count($seriesData['dataValues']);
 343  
 344              return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
 345          } elseif (isset($seriesDetail->multiLvlNumRef)) {
 346              $seriesSource = (string) $seriesDetail->multiLvlNumRef->f;
 347              $seriesData = self::chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlNumRef->multiLvlNumCache->children($namespacesChartMeta['c']), 's');
 348              $seriesData['pointCount'] = count($seriesData['dataValues']);
 349  
 350              return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
 351          }
 352  
 353          return null;
 354      }
 355  
 356      private static function chartDataSeriesValues($seriesValueSet, $dataType = 'n')
 357      {
 358          $seriesVal = [];
 359          $formatCode = '';
 360          $pointCount = 0;
 361  
 362          foreach ($seriesValueSet as $seriesValueIdx => $seriesValue) {
 363              switch ($seriesValueIdx) {
 364                  case 'ptCount':
 365                      $pointCount = self::getAttribute($seriesValue, 'val', 'integer');
 366  
 367                      break;
 368                  case 'formatCode':
 369                      $formatCode = (string) $seriesValue;
 370  
 371                      break;
 372                  case 'pt':
 373                      $pointVal = self::getAttribute($seriesValue, 'idx', 'integer');
 374                      if ($dataType == 's') {
 375                          $seriesVal[$pointVal] = (string) $seriesValue->v;
 376                      } elseif ($seriesValue->v === Functions::NA()) {
 377                          $seriesVal[$pointVal] = null;
 378                      } else {
 379                          $seriesVal[$pointVal] = (float) $seriesValue->v;
 380                      }
 381  
 382                      break;
 383              }
 384          }
 385  
 386          return [
 387              'formatCode' => $formatCode,
 388              'pointCount' => $pointCount,
 389              'dataValues' => $seriesVal,
 390          ];
 391      }
 392  
 393      private static function chartDataSeriesValuesMultiLevel($seriesValueSet, $dataType = 'n')
 394      {
 395          $seriesVal = [];
 396          $formatCode = '';
 397          $pointCount = 0;
 398  
 399          foreach ($seriesValueSet->lvl as $seriesLevelIdx => $seriesLevel) {
 400              foreach ($seriesLevel as $seriesValueIdx => $seriesValue) {
 401                  switch ($seriesValueIdx) {
 402                      case 'ptCount':
 403                          $pointCount = self::getAttribute($seriesValue, 'val', 'integer');
 404  
 405                          break;
 406                      case 'formatCode':
 407                          $formatCode = (string) $seriesValue;
 408  
 409                          break;
 410                      case 'pt':
 411                          $pointVal = self::getAttribute($seriesValue, 'idx', 'integer');
 412                          if ($dataType == 's') {
 413                              $seriesVal[$pointVal][] = (string) $seriesValue->v;
 414                          } elseif ($seriesValue->v === Functions::NA()) {
 415                              $seriesVal[$pointVal] = null;
 416                          } else {
 417                              $seriesVal[$pointVal][] = (float) $seriesValue->v;
 418                          }
 419  
 420                          break;
 421                  }
 422              }
 423          }
 424  
 425          return [
 426              'formatCode' => $formatCode,
 427              'pointCount' => $pointCount,
 428              'dataValues' => $seriesVal,
 429          ];
 430      }
 431  
 432      private static function parseRichText(SimpleXMLElement $titleDetailPart)
 433      {
 434          $value = new RichText();
 435          $objText = null;
 436          foreach ($titleDetailPart as $titleDetailElementKey => $titleDetailElement) {
 437              if (isset($titleDetailElement->t)) {
 438                  $objText = $value->createTextRun((string) $titleDetailElement->t);
 439              }
 440              if (isset($titleDetailElement->rPr)) {
 441                  if (isset($titleDetailElement->rPr->rFont['val'])) {
 442                      $objText->getFont()->setName((string) $titleDetailElement->rPr->rFont['val']);
 443                  }
 444  
 445                  $fontSize = (self::getAttribute($titleDetailElement->rPr, 'sz', 'integer'));
 446                  if ($fontSize !== null) {
 447                      $objText->getFont()->setSize(floor($fontSize / 100));
 448                  }
 449  
 450                  $fontColor = (self::getAttribute($titleDetailElement->rPr, 'color', 'string'));
 451                  if ($fontColor !== null) {
 452                      $objText->getFont()->setColor(new Color(self::readColor($fontColor)));
 453                  }
 454  
 455                  $bold = self::getAttribute($titleDetailElement->rPr, 'b', 'boolean');
 456                  if ($bold !== null) {
 457                      $objText->getFont()->setBold($bold);
 458                  }
 459  
 460                  $italic = self::getAttribute($titleDetailElement->rPr, 'i', 'boolean');
 461                  if ($italic !== null) {
 462                      $objText->getFont()->setItalic($italic);
 463                  }
 464  
 465                  $baseline = self::getAttribute($titleDetailElement->rPr, 'baseline', 'integer');
 466                  if ($baseline !== null) {
 467                      if ($baseline > 0) {
 468                          $objText->getFont()->setSuperscript(true);
 469                      } elseif ($baseline < 0) {
 470                          $objText->getFont()->setSubscript(true);
 471                      }
 472                  }
 473  
 474                  $underscore = (self::getAttribute($titleDetailElement->rPr, 'u', 'string'));
 475                  if ($underscore !== null) {
 476                      if ($underscore == 'sng') {
 477                          $objText->getFont()->setUnderline(Font::UNDERLINE_SINGLE);
 478                      } elseif ($underscore == 'dbl') {
 479                          $objText->getFont()->setUnderline(Font::UNDERLINE_DOUBLE);
 480                      } else {
 481                          $objText->getFont()->setUnderline(Font::UNDERLINE_NONE);
 482                      }
 483                  }
 484  
 485                  $strikethrough = (self::getAttribute($titleDetailElement->rPr, 's', 'string'));
 486                  if ($strikethrough !== null) {
 487                      if ($strikethrough == 'noStrike') {
 488                          $objText->getFont()->setStrikethrough(false);
 489                      } else {
 490                          $objText->getFont()->setStrikethrough(true);
 491                      }
 492                  }
 493              }
 494          }
 495  
 496          return $value;
 497      }
 498  
 499      private static function readChartAttributes($chartDetail)
 500      {
 501          $plotAttributes = [];
 502          if (isset($chartDetail->dLbls)) {
 503              if (isset($chartDetail->dLbls->howLegendKey)) {
 504                  $plotAttributes['showLegendKey'] = self::getAttribute($chartDetail->dLbls->showLegendKey, 'val', 'string');
 505              }
 506              if (isset($chartDetail->dLbls->showVal)) {
 507                  $plotAttributes['showVal'] = self::getAttribute($chartDetail->dLbls->showVal, 'val', 'string');
 508              }
 509              if (isset($chartDetail->dLbls->showCatName)) {
 510                  $plotAttributes['showCatName'] = self::getAttribute($chartDetail->dLbls->showCatName, 'val', 'string');
 511              }
 512              if (isset($chartDetail->dLbls->showSerName)) {
 513                  $plotAttributes['showSerName'] = self::getAttribute($chartDetail->dLbls->showSerName, 'val', 'string');
 514              }
 515              if (isset($chartDetail->dLbls->showPercent)) {
 516                  $plotAttributes['showPercent'] = self::getAttribute($chartDetail->dLbls->showPercent, 'val', 'string');
 517              }
 518              if (isset($chartDetail->dLbls->showBubbleSize)) {
 519                  $plotAttributes['showBubbleSize'] = self::getAttribute($chartDetail->dLbls->showBubbleSize, 'val', 'string');
 520              }
 521              if (isset($chartDetail->dLbls->showLeaderLines)) {
 522                  $plotAttributes['showLeaderLines'] = self::getAttribute($chartDetail->dLbls->showLeaderLines, 'val', 'string');
 523              }
 524          }
 525  
 526          return $plotAttributes;
 527      }
 528  
 529      /**
 530       * @param mixed $plotAttributes
 531       */
 532      private static function setChartAttributes(Layout $plotArea, $plotAttributes): void
 533      {
 534          foreach ($plotAttributes as $plotAttributeKey => $plotAttributeValue) {
 535              switch ($plotAttributeKey) {
 536                  case 'showLegendKey':
 537                      $plotArea->setShowLegendKey($plotAttributeValue);
 538  
 539                      break;
 540                  case 'showVal':
 541                      $plotArea->setShowVal($plotAttributeValue);
 542  
 543                      break;
 544                  case 'showCatName':
 545                      $plotArea->setShowCatName($plotAttributeValue);
 546  
 547                      break;
 548                  case 'showSerName':
 549                      $plotArea->setShowSerName($plotAttributeValue);
 550  
 551                      break;
 552                  case 'showPercent':
 553                      $plotArea->setShowPercent($plotAttributeValue);
 554  
 555                      break;
 556                  case 'showBubbleSize':
 557                      $plotArea->setShowBubbleSize($plotAttributeValue);
 558  
 559                      break;
 560                  case 'showLeaderLines':
 561                      $plotArea->setShowLeaderLines($plotAttributeValue);
 562  
 563                      break;
 564              }
 565          }
 566      }
 567  }