| /* |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * ==================================================================== |
| */ |
| package org.apache.poi.xslf.usermodel; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.io.IOException; |
| import java.util.List; |
| |
| import org.apache.poi.ooxml.POIXMLDocumentPart; |
| import org.apache.poi.ss.util.CellRangeAddress; |
| import org.apache.poi.xddf.usermodel.chart.AxisCrossBetween; |
| import org.apache.poi.xddf.usermodel.chart.AxisCrosses; |
| import org.apache.poi.xddf.usermodel.chart.AxisOrientation; |
| import org.apache.poi.xddf.usermodel.chart.AxisPosition; |
| import org.apache.poi.xddf.usermodel.chart.AxisTickMark; |
| import org.apache.poi.xddf.usermodel.chart.BarDirection; |
| import org.apache.poi.xddf.usermodel.chart.BarGrouping; |
| import org.apache.poi.xddf.usermodel.chart.Grouping; |
| import org.apache.poi.xddf.usermodel.chart.LayoutMode; |
| import org.apache.poi.xddf.usermodel.chart.LayoutTarget; |
| import org.apache.poi.xddf.usermodel.chart.LegendPosition; |
| import org.apache.poi.xddf.usermodel.chart.RadarStyle; |
| import org.apache.poi.xddf.usermodel.chart.ScatterStyle; |
| import org.apache.poi.xddf.usermodel.chart.XDDFBarChartData; |
| import org.apache.poi.xddf.usermodel.chart.XDDFChartData; |
| import org.apache.poi.xddf.usermodel.chart.XDDFChartLegend; |
| import org.apache.poi.xddf.usermodel.chart.XDDFDataSource; |
| import org.apache.poi.xddf.usermodel.chart.XDDFDataSourcesFactory; |
| import org.apache.poi.xddf.usermodel.chart.XDDFLineChartData; |
| import org.apache.poi.xddf.usermodel.chart.XDDFManualLayout; |
| import org.apache.poi.xddf.usermodel.chart.XDDFNumericalDataSource; |
| import org.apache.poi.xddf.usermodel.chart.XDDFPieChartData; |
| import org.apache.poi.xddf.usermodel.chart.XDDFRadarChartData; |
| import org.apache.poi.xddf.usermodel.chart.XDDFScatterChartData; |
| import org.apache.poi.xddf.usermodel.chart.XDDFValueAxis; |
| import org.apache.poi.xslf.XSLFTestDataSamples; |
| import org.junit.Test; |
| |
| /** |
| * a modified version from POI-examples |
| */ |
| public class TestXSLFChart { |
| @Test |
| public void testFillPieChartTemplate() throws IOException { |
| XMLSlideShow pptx = XSLFTestDataSamples.openSampleDocument("pie-chart.pptx"); |
| XSLFChart chart = findChart(pptx.getSlides().get(0)); |
| List<XDDFChartData> data = findChartData(chart); |
| |
| XDDFPieChartData pie = (XDDFPieChartData) data.get(0); |
| XDDFPieChartData.Series firstSeries = (XDDFPieChartData.Series) pie.getSeries().get(0); |
| firstSeries.setExplosion(25); |
| assertEquals(25, firstSeries.getExplosion()); |
| |
| fillChartData(chart, pie); |
| pptx.close(); |
| } |
| |
| @Test |
| public void testFillBarChartTemplate() throws IOException { |
| XMLSlideShow pptx = XSLFTestDataSamples.openSampleDocument("bar-chart.pptx"); |
| XSLFSlide slide = pptx.getSlides().get(0); |
| // duplicate slide and chart before applying "destructive" tests to it |
| XSLFChart chart2 = findChart(pptx.createSlide().importContent(slide)); |
| XSLFChart chart = findChart(slide); |
| |
| List<XDDFChartData> data = findChartData(chart); |
| XDDFBarChartData bar = (XDDFBarChartData) data.get(0); |
| assertEquals(BarDirection.BAR, bar.getBarDirection()); |
| assertEquals(BarGrouping.CLUSTERED, bar.getBarGrouping()); |
| assertEquals(100, bar.getGapWidth()); |
| fillChartData(chart, bar); |
| |
| XDDFBarChartData column = (XDDFBarChartData) findChartData(chart2).get(0); |
| column.setBarDirection(BarDirection.COL); |
| assertEquals(BarDirection.COL, column.getBarDirection()); |
| column.getCategoryAxis().setOrientation(AxisOrientation.MIN_MAX); |
| column.getValueAxes().get(0).setPosition(AxisPosition.BOTTOM); |
| fillChartData(chart2, column); |
| |
| pptx.close(); |
| } |
| |
| @Test |
| public void testFillLineChartTemplate() throws IOException { |
| XMLSlideShow pptx = XSLFTestDataSamples.openSampleDocument("line-chart.pptx"); |
| XSLFChart chart = findChart(pptx.getSlides().get(0)); |
| List<XDDFChartData> data = findChartData(chart); |
| |
| XDDFLineChartData line = (XDDFLineChartData) data.get(0); |
| assertEquals(Grouping.STANDARD, line.getGrouping()); |
| line.setGrouping(Grouping.PERCENT_STACKED); |
| assertEquals(Grouping.PERCENT_STACKED, line.getGrouping()); |
| |
| fillChartData(chart, line); |
| pptx.close(); |
| } |
| |
| @Test |
| public void testFillRadarChartTemplate() throws IOException { |
| XMLSlideShow pptx = XSLFTestDataSamples.openSampleDocument("radar-chart.pptx"); |
| XSLFChart chart = findChart(pptx.getSlides().get(0)); |
| List<XDDFChartData> data = findChartData(chart); |
| |
| XDDFRadarChartData radar = (XDDFRadarChartData) data.get(0); |
| assertEquals(RadarStyle.MARKER, radar.getStyle()); |
| radar.setStyle(RadarStyle.FILLED); |
| assertEquals(RadarStyle.FILLED, radar.getStyle()); |
| |
| fillChartData(chart, radar); |
| pptx.close(); |
| } |
| |
| @Test |
| public void testFillScatterChartTemplate() throws IOException { |
| XMLSlideShow pptx = XSLFTestDataSamples.openSampleDocument("scatter-chart.pptx"); |
| XSLFChart chart = findChart(pptx.getSlides().get(0)); |
| List<XDDFChartData> data = findChartData(chart); |
| |
| XDDFScatterChartData scatter = (XDDFScatterChartData) data.get(0); |
| assertEquals(ScatterStyle.LINE_MARKER, scatter.getStyle()); |
| scatter.setStyle(ScatterStyle.SMOOTH); |
| assertEquals(ScatterStyle.SMOOTH, scatter.getStyle()); |
| |
| fillChartData(chart, scatter); |
| pptx.close(); |
| } |
| |
| private void fillChartData(XSLFChart chart, XDDFChartData data) { |
| final int numOfPoints = 3; |
| final String[] categories = {"First", "Second", "Third"}; |
| final Integer[] values = {1, 3, 4}; |
| |
| final String categoryDataRange = chart.formatRange(new CellRangeAddress(1, numOfPoints, 0, 0)); |
| final String valuesDataRange = chart.formatRange(new CellRangeAddress(1, numOfPoints, 1, 1)); |
| |
| final XDDFChartData.Series series = data.getSeries().get(0); |
| final XDDFDataSource<?> categoryData = XDDFDataSourcesFactory.fromArray(categories, categoryDataRange); |
| final XDDFNumericalDataSource<Integer> valuesData = XDDFDataSourcesFactory.fromArray(values, valuesDataRange); |
| series.replaceData(categoryData, valuesData); |
| final String title = "Apache POI"; |
| series.setTitle(title, chart.setSheetTitle(title, 0)); |
| chart.plot(data); |
| } |
| |
| private XSLFChart findChart(XSLFSlide slide) { |
| // find chart in the slide |
| XSLFChart chart = null; |
| for(POIXMLDocumentPart part : slide.getRelations()){ |
| if(part instanceof XSLFChart){ |
| chart = (XSLFChart) part; |
| break; |
| } |
| } |
| |
| if(chart == null) { |
| throw new IllegalStateException("chart not found in the template"); |
| } |
| |
| checkLegendOperations(chart); |
| return chart; |
| } |
| |
| private List<XDDFChartData> findChartData(XSLFChart chart) { |
| List<XDDFChartData> data = chart.getChartSeries(); |
| assertNotNull(data); |
| assertEquals(1, data.size()); |
| |
| XDDFChartData firstSeries = data.get(0); |
| assertNotNull(firstSeries); |
| if (firstSeries instanceof XDDFScatterChartData) { |
| assertEquals(null, firstSeries.getCategoryAxis()); |
| assertEquals(2, firstSeries.getValueAxes().size()); |
| checkAxisOperations(firstSeries.getValueAxes().get(0)); |
| checkAxisOperations(firstSeries.getValueAxes().get(1)); |
| } else if (!(firstSeries instanceof XDDFPieChartData)) { |
| assertNotNull(firstSeries.getCategoryAxis()); |
| assertEquals(1, firstSeries.getValueAxes().size()); |
| checkAxisOperations(firstSeries.getValueAxes().get(0)); |
| } |
| |
| return data; |
| } |
| |
| private void checkLegendOperations(XSLFChart chart) { |
| XDDFChartLegend legend = chart.getOrAddLegend(); |
| assertFalse(legend.isOverlay()); |
| legend.setOverlay(true); |
| assertTrue(legend.isOverlay()); |
| legend.setPosition(LegendPosition.TOP_RIGHT); |
| assertEquals(LegendPosition.TOP_RIGHT, legend.getPosition()); |
| |
| XDDFManualLayout layout = legend.getOrAddManualLayout(); |
| assertNotNull(layout.getTarget()); |
| assertNotNull(layout.getXMode()); |
| assertNotNull(layout.getYMode()); |
| assertNotNull(layout.getHeightMode()); |
| assertNotNull(layout.getWidthMode()); |
| /* |
| * According to interface, 0.0 should be returned for |
| * uninitialized double properties. |
| */ |
| assertTrue(layout.getX() == 0.0); |
| assertTrue(layout.getY() == 0.0); |
| assertTrue(layout.getWidthRatio() == 0.0); |
| assertTrue(layout.getHeightRatio() == 0.0); |
| |
| final double newRatio = 1.1; |
| final double newCoordinate = 0.3; |
| final LayoutMode nonDefaultMode = LayoutMode.FACTOR; |
| final LayoutTarget nonDefaultTarget = LayoutTarget.OUTER; |
| |
| layout.setWidthRatio(newRatio); |
| assertTrue(layout.getWidthRatio() == newRatio); |
| |
| layout.setHeightRatio(newRatio); |
| assertTrue(layout.getHeightRatio() == newRatio); |
| |
| layout.setX(newCoordinate); |
| assertTrue(layout.getX() == newCoordinate); |
| |
| layout.setY(newCoordinate); |
| assertTrue(layout.getY() == newCoordinate); |
| |
| layout.setXMode(nonDefaultMode); |
| assertTrue(layout.getXMode() == nonDefaultMode); |
| |
| layout.setYMode(nonDefaultMode); |
| assertTrue(layout.getYMode() == nonDefaultMode); |
| |
| layout.setWidthMode(nonDefaultMode); |
| assertTrue(layout.getWidthMode() == nonDefaultMode); |
| |
| layout.setHeightMode(nonDefaultMode); |
| assertTrue(layout.getHeightMode() == nonDefaultMode); |
| |
| layout.setTarget(nonDefaultTarget); |
| assertTrue(layout.getTarget() == nonDefaultTarget); |
| } |
| |
| private void checkAxisOperations(XDDFValueAxis axis) { |
| axis.setCrossBetween(AxisCrossBetween.MIDPOINT_CATEGORY); |
| assertEquals(AxisCrossBetween.MIDPOINT_CATEGORY, axis.getCrossBetween()); |
| |
| axis.setCrosses(AxisCrosses.AUTO_ZERO); |
| assertEquals(AxisCrosses.AUTO_ZERO, axis.getCrosses()); |
| |
| final String numberFormat = "General"; |
| axis.setNumberFormat(numberFormat); |
| assertEquals(numberFormat, axis.getNumberFormat()); |
| |
| axis.setPosition(AxisPosition.BOTTOM); |
| assertEquals(AxisPosition.BOTTOM, axis.getPosition()); |
| |
| axis.setMajorTickMark(AxisTickMark.NONE); |
| assertEquals(AxisTickMark.NONE, axis.getMajorTickMark()); |
| |
| axis.setMajorTickMark(AxisTickMark.IN); |
| assertEquals(AxisTickMark.IN, axis.getMajorTickMark()); |
| |
| axis.setMajorTickMark(AxisTickMark.OUT); |
| assertEquals(AxisTickMark.OUT, axis.getMajorTickMark()); |
| |
| axis.setMajorTickMark(AxisTickMark.CROSS); |
| assertEquals(AxisTickMark.CROSS, axis.getMajorTickMark()); |
| |
| axis.setMinorTickMark(AxisTickMark.NONE); |
| assertEquals(AxisTickMark.NONE, axis.getMinorTickMark()); |
| |
| axis.setMinorTickMark(AxisTickMark.IN); |
| assertEquals(AxisTickMark.IN, axis.getMinorTickMark()); |
| |
| axis.setMinorTickMark(AxisTickMark.OUT); |
| assertEquals(AxisTickMark.OUT, axis.getMinorTickMark()); |
| |
| axis.setMinorTickMark(AxisTickMark.CROSS); |
| assertEquals(AxisTickMark.CROSS, axis.getMinorTickMark()); |
| |
| axis.setVisible(true); |
| assertTrue(axis.isVisible()); |
| |
| axis.setVisible(false); |
| assertFalse(axis.isVisible()); |
| |
| final double EPSILON = 1E-7; |
| axis.setLogBase(Math.E); |
| assertTrue(Math.abs(axis.getLogBase() - Math.E) < EPSILON); |
| |
| final double newValue = 10.0; |
| |
| axis.setMinimum(newValue); |
| assertTrue(Math.abs(axis.getMinimum() - newValue) < EPSILON); |
| |
| axis.setMaximum(newValue); |
| assertTrue(Math.abs(axis.getMaximum() - newValue) < EPSILON); |
| |
| IllegalArgumentException iae = null; |
| try { |
| axis.setLogBase(0.0); |
| } catch (IllegalArgumentException e) { |
| iae = e; |
| } |
| assertNotNull(iae); |
| |
| iae = null; |
| try { |
| axis.setLogBase(30000.0); |
| } catch (IllegalArgumentException e) { |
| iae = e; |
| } |
| assertNotNull(iae); |
| } |
| } |