View | Details | Raw Unified | Return to bug 60866
Collapse All | Expand All

(-)src/ooxml/java/org/apache/poi/xssf/model/StylesTable.java (-22 / +99 lines)
Lines 46-67 Link Here
46
import org.apache.poi.xssf.usermodel.extensions.XSSFCellBorder;
46
import org.apache.poi.xssf.usermodel.extensions.XSSFCellBorder;
47
import org.apache.poi.xssf.usermodel.extensions.XSSFCellFill;
47
import org.apache.poi.xssf.usermodel.extensions.XSSFCellFill;
48
import org.apache.xmlbeans.XmlException;
48
import org.apache.xmlbeans.XmlException;
49
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorder;
49
import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
50
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorders;
51
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCellStyleXfs;
52
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCellXfs;
53
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTDxf;
54
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTDxfs;
55
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFill;
56
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFills;
57
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
58
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFonts;
59
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTNumFmt;
60
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTNumFmts;
61
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTStylesheet;
62
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTXf;
63
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STPatternType;
64
import org.openxmlformats.schemas.spreadsheetml.x2006.main.StyleSheetDocument;
65
50
66
/**
51
/**
67
 * Table of styles shared across all sheets in a workbook.
52
 * Table of styles shared across all sheets in a workbook.
Lines 710-715 Link Here
710
        CTXf xf = createDefaultXf();
695
        CTXf xf = createDefaultXf();
711
        xf.setXfId(0);
696
        xf.setXfId(0);
712
        xfs.add(xf);
697
        xfs.add(xf);
698
699
        createDefaultCellStyles(doc.getStyleSheet());
713
    }
700
    }
714
701
715
    private static CTXf createDefaultXf() {
702
    private static CTXf createDefaultXf() {
Lines 749-754 Link Here
749
        return xssfFont;
736
        return xssfFont;
750
    }
737
    }
751
738
739
    /**
740
     * Ensures there is at least one cell style in the styles collection.
741
     * See https://msdn.microsoft.com/en-us/library/dd952635(v=office.12).aspx
742
     * @param styleSheet Style sheet
743
     * @return Cell styles collection
744
     */
745
    private static void createDefaultCellStyles(CTStylesheet styleSheet) {
746
        CTCellStyles cellStyles = styleSheet.getCellStyles();
747
        if (cellStyles == null) {
748
            cellStyles = styleSheet.addNewCellStyles();
749
            cellStyles.setCount(0);
750
        }
751
        if (cellStyles.getCount() == 0) {
752
            CTCellStyle normalCellStyle = cellStyles.addNewCellStyle();
753
            normalCellStyle.setName("Normal");
754
            normalCellStyle.setXfId(0);
755
            normalCellStyle.setBuiltinId(0);
756
            cellStyles.setCount(1);
757
        }
758
    }
759
752
    @Internal
760
    @Internal
753
    public CTDxf getDxfAt(int idx) {
761
    public CTDxf getDxfAt(int idx) {
754
        return dxfs.get(idx);
762
        return dxfs.get(idx);
Lines 771-784 Link Here
771
     * Create a cell style in this style table.
779
     * Create a cell style in this style table.
772
     * Note - End users probably want to call {@link XSSFWorkbook#createCellStyle()}
780
     * Note - End users probably want to call {@link XSSFWorkbook#createCellStyle()}
773
     * rather than working with the styles table directly.
781
     * rather than working with the styles table directly.
774
     * @throws IllegalStateException if the maximum number of cell styles has been reached. 
782
     * @throws IllegalStateException if the maximum number of cell styles has been reached.
775
     */
783
     */
776
    public XSSFCellStyle createCellStyle() {
784
    public XSSFCellStyle createCellStyle() {
777
        if (getNumCellStyles() > MAXIMUM_STYLE_ID) {
785
        checkNumStyles();
778
            throw new IllegalStateException("The maximum number of Cell Styles was exceeded. " +
779
                      "You can define up to " + MAXIMUM_STYLE_ID + " style in a .xlsx Workbook");
780
        }
781
782
        int xfSize = styleXfs.size();
786
        int xfSize = styleXfs.size();
783
        CTXf xf = CTXf.Factory.newInstance();
787
        CTXf xf = CTXf.Factory.newInstance();
784
        xf.setNumFmtId(0);
788
        xf.setNumFmtId(0);
Lines 790-795 Link Here
790
        return new XSSFCellStyle(indexXf - 1, xfSize - 1, this, theme);
794
        return new XSSFCellStyle(indexXf - 1, xfSize - 1, this, theme);
791
    }
795
    }
792
796
797
    /**
798
     * Creates a new cell style which is based on a named style.
799
     * @param name Name of style on which to base the new cell style
800
     * @return Cell style based on the specified named style; null if there is no such named style
801
     * @throws IllegalStateException if the maximum number of cell styles has been reached.
802
     */
803
    public XSSFCellStyle createCellStyleForNamedStyle(String name) {
804
        CTCellStyle cellStyle = findCellStyleByName(name);
805
        if (cellStyle == null) {
806
            return null;
807
        } else {
808
            checkNumStyles();
809
            int cellStyleXfId = (int) cellStyle.getXfId();
810
            CTXf xf = CTXf.Factory.newInstance();
811
            xf.setXfId(cellStyleXfId);
812
813
            int indexXf = putCellXf(xf);
814
            return new XSSFCellStyle(indexXf - 1, cellStyleXfId, this, theme);
815
        }
816
    }
817
818
    /**
819
     * Checks whether the maximum number of allowed cell styles has been exceeded.
820
     * @throws IllegalStateException if the maximum number of cell styles has been reached.
821
     */
822
    private void checkNumStyles() {
823
        if (getNumCellStyles() > MAXIMUM_STYLE_ID) {
824
            throw new IllegalStateException("The maximum number of cell styles was exceeded. " +
825
                    "You can define up to " + MAXIMUM_STYLE_ID + " styles in a .xlsx workbook.");
826
        }
827
    }
828
793
    /**
829
    /**
794
     * Finds a font that matches the one with the supplied attributes
830
     * Finds a font that matches the one with the supplied attributes
795
     * @deprecated POI 3.15 beta 2. Use {@link #findFont(boolean, short, short, String, boolean, boolean, short, byte)} instead.
831
     * @deprecated POI 3.15 beta 2. Use {@link #findFont(boolean, short, short, String, boolean, boolean, short, byte)} instead.
Lines 830-833 Link Here
830
        }
866
        }
831
        return null;
867
        return null;
832
    }
868
    }
869
870
    /**
871
     * Adds or replaces a cell style with the specified name
872
     * @param name Name of cell style to add or replace
873
     * @param cellStyleXf Cell style Xf
874
     * @return Cell style Xf id
875
     */
876
    @Internal
877
    public int addOrReplaceNamedCellStyle(String name, CTXf cellStyleXf) {
878
        CTCellStyle cellStyle = findCellStyleByName(name);
879
880
        int cellStyleXfId;
881
        if (cellStyle == null) {
882
            // There is no cell style with that name so we create a new one
883
            CTCellStyles cellStyles = doc.getStyleSheet().getCellStyles();
884
            cellStyle = cellStyles.addNewCellStyle();
885
            cellStyle.setName(name);
886
            cellStyles.setCount(cellStyles.getCount() + 1);
887
            cellStyleXfId = putCellStyleXf(cellStyleXf) - 1;
888
            cellStyle.setXfId(cellStyleXfId);
889
        } else {
890
            cellStyleXfId = (int) cellStyle.getXfId();
891
            replaceCellStyleXfAt(cellStyleXfId, cellStyleXf);
892
        }
893
894
        return cellStyleXfId;
895
    }
896
897
    /**
898
     * Find a cell style by name
899
     * @param name Name of cell style
900
     * @return Cell style having the specified name; null if there is no such cell style.
901
     */
902
    private CTCellStyle findCellStyleByName(String name) {
903
        CTCellStyles cellStyles = doc.getStyleSheet().getCellStyles();
904
        for (int i = 0; i < cellStyles.getCount(); i++) {
905
            CTCellStyle cellStyle = cellStyles.getCellStyleArray(i);
906
            if (name != null && name.equals(cellStyle.getName())) return cellStyle;
907
        }
908
        return null;
909
    }
833
}
910
}
(-)src/java/org/apache/poi/ss/usermodel/Workbook.java (+9 lines)
Lines 344-349 Link Here
344
     */
344
     */
345
    CellStyle getCellStyleAt(int idx);
345
    CellStyle getCellStyleAt(int idx);
346
346
347
    /**
348
     * Retrieve a cell style which is based on the specified named style
349
     * but has no other cell-specific formatting applied.
350
     *
351
     * @param name Name of style
352
     * @return Cell style which is based on the specified named style
353
     */
354
    CellStyle getCellStyle(String name);
355
347
    /**
356
    /**
348
     * Write out this workbook to an Outputstream.
357
     * Write out this workbook to an Outputstream.
349
     *
358
     *
(-)src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFWorkbook.java (+13 lines)
Lines 956-961 Link Here
956
        return stylesSource.getStyleAt(idx);
956
        return stylesSource.getStyleAt(idx);
957
    }
957
    }
958
958
959
    /**
960
     * Retrieve a cell style which is based on the specified named style
961
     * but has no other cell-specific formatting applied.
962
     *
963
     * NOTE: This actually creates a new cell style which references the
964
     * specified named style.
965
     *
966
     * @param name Name of style
967
     * @return Cell style which is based on the specified named style
968
     */
969
    @Override
970
    public XSSFCellStyle getCellStyle(String name) { return stylesSource.createCellStyleForNamedStyle(name); }
971
959
    /**
972
    /**
960
     * Get the font at the given index number
973
     * Get the font at the given index number
961
     *
974
     *
(-)src/ooxml/java/org/apache/poi/xssf/streaming/SXSSFWorkbook.java (+13 lines)
Lines 890-895 Link Here
890
        return _wb.getCellStyleAt(idx);
890
        return _wb.getCellStyleAt(idx);
891
    }
891
    }
892
892
893
    /**
894
     * Retrieve a cell style which is based on the specified named style
895
     * but has no other cell-specific formatting applied.
896
     *
897
     * NOTE: This actually creates a new cell style which references the
898
     * specified named style.
899
     *
900
     * @param name Name of style
901
     * @return Cell style which is based on the specified named style
902
     */
903
    @Override
904
    public CellStyle getCellStyle(String name) { return _wb.getCellStyle(name); }
905
893
    /**
906
    /**
894
     * Closes the underlying {@link XSSFWorkbook} and {@link OPCPackage} 
907
     * Closes the underlying {@link XSSFWorkbook} and {@link OPCPackage} 
895
     *  on which this Workbook is based, if any.
908
     *  on which this Workbook is based, if any.
(-)src/java/org/apache/poi/hssf/usermodel/HSSFWorkbook.java (+18 lines)
Lines 1350-1355 Link Here
1350
        return new HSSFCellStyle((short)idx, xfr, this);
1350
        return new HSSFCellStyle((short)idx, xfr, this);
1351
    }
1351
    }
1352
1352
1353
    /**
1354
     * Retrieve a cell style which is based on the specified named style
1355
     * but has no other cell-specific formatting applied.
1356
     *
1357
     * @param name Name of style
1358
     * @return Cell style which is based on the specified named style
1359
     */
1360
    @Override
1361
    public HSSFCellStyle getCellStyle(String name) {
1362
        for (int i = 0; i < getNumCellStyles(); i++) {
1363
            HSSFCellStyle cs = getCellStyleAt(i);
1364
            String userStyleName = cs.getUserStyleName();
1365
            if (userStyleName != null && userStyleName.equals(name)) return cs;
1366
        }
1367
1368
        return null;
1369
    }
1370
1353
    /**
1371
    /**
1354
     * Closes the underlying {@link NPOIFSFileSystem} from which
1372
     * Closes the underlying {@link NPOIFSFileSystem} from which
1355
     *  the Workbook was read, if any.
1373
     *  the Workbook was read, if any.
(-)src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCellStyle.java (+73 lines)
Lines 1062-1065 Link Here
1062
        
1062
        
1063
        workbook.close();
1063
        workbook.close();
1064
    }
1064
    }
1065
1066
    /**
1067
     * Creates a new cell style by using the style xf of the original cell style as the cell xf of the new cell style.
1068
     * This allows us to use the XSSFCellStyle getters to test properties of the style xf.
1069
     */
1070
    private XSSFCellStyle styleXfAsCellXf(XSSFWorkbook workbook, XSSFCellStyle cs) {
1071
        int cellXfCount = workbook.getStylesSource().putCellXf(cs.getStyleXf());
1072
        return new XSSFCellStyle(cellXfCount - 1, -1, workbook.getStylesSource(), workbook.getTheme());
1073
    }
1074
1075
    /**
1076
     * Tests that an appropriate named cell style is created when an XSSFCellStyle is being converted
1077
     * to a named cell style and that the named cell style can be retrieved accordingly.
1078
     * @throws IOException
1079
     */
1080
    @Test
1081
    public void testNamedCellStyle() throws IOException {
1082
        XSSFWorkbook workbook = new XSSFWorkbook();
1083
1084
        // Name of test style
1085
        String styleName = "TestStyle";
1086
        // Style properties
1087
        HorizontalAlignment alignment = HorizontalAlignment.DISTRIBUTED;
1088
        BorderStyle borderStyle1 = BorderStyle.MEDIUM_DASH_DOT;
1089
        XSSFFont font = workbook.createFont();
1090
        short identation = 4;
1091
1092
        // Create a new cell style
1093
        XSSFCellStyle cellStyle = workbook.createCellStyle();
1094
        cellStyle.setAlignment(alignment);
1095
        cellStyle.setBorderRight(borderStyle1);
1096
        cellStyle.setFont(font);
1097
        cellStyle.setWrapText(true);
1098
        cellStyle.setIndention(identation);
1099
1100
        // Set as new named style
1101
        cellStyle.asNamedStyle(styleName);
1102
1103
        // Get named cell style
1104
        XSSFCellStyle cs1 = workbook.getCellStyle(styleName);
1105
        XSSFCellStyle target1 = styleXfAsCellXf(workbook, cs1);
1106
1107
        // Test properties (1)
1108
        assertEquals(alignment, target1.getAlignmentEnum());
1109
        assertEquals(borderStyle1, target1.getBorderRightEnum());
1110
        assertEquals(font, target1.getFont());
1111
        assertEquals(true, target1.getWrapText());
1112
        assertEquals(identation, target1.getIndention());
1113
1114
        // Change properties
1115
        XSSFColor color = new XSSFColor(IndexedColors.CORNFLOWER_BLUE);
1116
        FillPatternType fillPatternType = FillPatternType.THIN_HORZ_BANDS;
1117
        BorderStyle borderStyle2 = BorderStyle.HAIR;
1118
        cs1.setFillPattern(fillPatternType);
1119
        cs1.setFillBackgroundColor(color);
1120
        cs1.setBorderRight(borderStyle2);
1121
1122
        // Redefine named style
1123
        cs1.asNamedStyle(styleName);
1124
1125
        // Get named cell style
1126
        XSSFCellStyle cs2 = workbook.getCellStyle(styleName);
1127
        XSSFCellStyle target2 = styleXfAsCellXf(workbook, cs2);
1128
1129
        // Test properties (2)
1130
        assertEquals(alignment, target2.getAlignmentEnum());
1131
        assertEquals(borderStyle2, target2.getBorderRightEnum());
1132
        assertEquals(true, target2.getWrapText());
1133
        assertEquals(font, target2.getFont());
1134
        assertEquals(fillPatternType, target2.getFillPatternEnum());
1135
        assertEquals(color, target2.getFillBackgroundXSSFColor());
1136
        assertEquals(identation, target2.getIndention());
1137
    }
1065
}
1138
}
(-)src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFCellStyle.java (-10 / +71 lines)
Lines 36-50 Link Here
36
import org.apache.poi.xssf.usermodel.extensions.XSSFCellBorder.BorderSide;
36
import org.apache.poi.xssf.usermodel.extensions.XSSFCellBorder.BorderSide;
37
import org.apache.poi.xssf.usermodel.extensions.XSSFCellFill;
37
import org.apache.poi.xssf.usermodel.extensions.XSSFCellFill;
38
import org.apache.xmlbeans.XmlException;
38
import org.apache.xmlbeans.XmlException;
39
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorder;
39
import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
40
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorderPr;
41
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCellAlignment;
42
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFill;
43
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
44
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPatternFill;
45
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTXf;
46
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STBorderStyle;
47
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STPatternType;
48
40
49
/**
41
/**
50
 *
42
 *
Lines 60-66 Link Here
60
    private int _cellXfId;
52
    private int _cellXfId;
61
    private final StylesTable _stylesSource;
53
    private final StylesTable _stylesSource;
62
    private CTXf _cellXf;
54
    private CTXf _cellXf;
63
    private final CTXf _cellStyleXf;
55
    private CTXf _cellStyleXf;
64
    private XSSFFont _font;
56
    private XSSFFont _font;
65
    private XSSFCellAlignment _cellAlignment;
57
    private XSSFCellAlignment _cellAlignment;
66
    private ThemesTable _theme;
58
    private ThemesTable _theme;
Lines 1481-1486 Link Here
1481
        return _cellXf.getAlignment();
1473
        return _cellXf.getAlignment();
1482
    }
1474
    }
1483
1475
1476
    /**
1477
     * Converts this style into a named cell style.
1478
     *
1479
     * Any cell-specific formatting will be merged into a named cell style
1480
     * and cell-specific formatting will be reset.
1481
     */
1482
    @Override
1483
    public void asNamedStyle(String name) {
1484
        CTXf newStyleXf = createMergedXf();
1485
        int cellStyleXfId = _stylesSource.addOrReplaceNamedCellStyle(name, newStyleXf);
1486
       
1487
        // Replace cell and cell style xfs	
1488
        _cellStyleXf = newStyleXf;
1489
        _cellXf = CTXf.Factory.newInstance();
1490
        _cellXf.setXfId(cellStyleXfId);
1491
        _stylesSource.replaceCellXfAt(_cellXfId, _cellXf);
1492
    }
1493
1494
    /**
1495
     * Name of this style if this style represents a named cell style.
1496
     * May return null if there is no named cell style or if this
1497
     * style contains cell-specific formatting.
1498
     */
1499
    @Override
1500
    public String getStyleName() {
1501
        CTCellStyles cellStyles = _stylesSource.getCTStylesheet().getCellStyles();
1502
        if (cellStyles != null) {
1503
            CTXf expectedCellXf = CTXf.Factory.newInstance();
1504
1505
            for (int i = 0; i < cellStyles.getCount(); i++) {
1506
                CTCellStyle cellStyle = cellStyles.getCellStyleArray(i);
1507
                int styleXfId = (int) cellStyle.getXfId();
1508
                if (_stylesSource.getCellStyleXfAt(styleXfId).equals(_cellStyleXf)) {
1509
                    // We need to check whether the cell Xf has been modified; if that's the case, this
1510
                    // XSSFCellStyle does not just represent a named cell style but also contains cell-specific
1511
                    // formatting
1512
                    expectedCellXf.setXfId(styleXfId);
1513
                    if (_cellXf.equals(expectedCellXf)) return cellStyle.getName();
1514
                }
1515
            }
1516
        }
1517
1518
	    return null;
1519
    }
1520
1521
    /**
1522
     * Creates a new merged CTXf from the existing cell style Xf and cell Xf.
1523
     */
1524
    private CTXf createMergedXf() {
1525
        CTXf mergedXf = (CTXf) _cellStyleXf.copy();
1526
        if (_cellXf.isSetAlignment()) mergedXf.setAlignment(_cellXf.getAlignment());
1527
        if (_cellXf.isSetProtection()) mergedXf.setProtection(_cellXf.getProtection());
1528
        if (_cellXf.isSetExtLst()) mergedXf.setExtLst(_cellXf.getExtLst());
1529
        if (_cellXf.isSetNumFmtId()) mergedXf.setNumFmtId(_cellXf.getNumFmtId());
1530
        if (_cellXf.isSetFontId()) mergedXf.setFontId(_cellXf.getFontId());
1531
        if (_cellXf.isSetFillId()) mergedXf.setFillId(_cellXf.getFillId());
1532
        if (_cellXf.isSetBorderId()) mergedXf.setBorderId(_cellXf.getBorderId());
1533
        if (_cellXf.isSetQuotePrefix()) mergedXf.setQuotePrefix(_cellXf.getQuotePrefix());
1534
        if (_cellXf.isSetPivotButton()) mergedXf.setPivotButton(_cellXf.getPivotButton());
1535
        if (_cellXf.isSetApplyNumberFormat()) mergedXf.setApplyNumberFormat(_cellXf.getApplyNumberFormat());
1536
        if (_cellXf.isSetApplyFont()) mergedXf.setApplyFont(_cellXf.getApplyFont());
1537
        if (_cellXf.isSetApplyFill()) mergedXf.setApplyFill(_cellXf.getApplyFill());
1538
        if (_cellXf.isSetApplyBorder()) mergedXf.setApplyBorder(_cellXf.getApplyBorder());
1539
        if (_cellXf.isSetApplyAlignment()) mergedXf.setApplyAlignment(_cellXf.getApplyAlignment());
1540
        if (_cellXf.isSetApplyProtection()) mergedXf.setApplyProtection(_cellXf.getApplyProtection());
1541
1542
        return mergedXf;
1543
    }
1544
1484
    /**
1545
    /**
1485
     * Returns a hash code value for the object. The hash is derived from the underlying CTXf bean.
1546
     * Returns a hash code value for the object. The hash is derived from the underlying CTXf bean.
1486
     *
1547
     *
(-)src/java/org/apache/poi/hssf/usermodel/HSSFCellStyle.java (+17 lines)
Lines 1032-1037 Link Here
1032
    public boolean getShrinkToFit() {
1032
    public boolean getShrinkToFit() {
1033
        return _format.getShrinkToFit();
1033
        return _format.getShrinkToFit();
1034
    }
1034
    }
1035
1036
    /**
1037
     * Converts this style into a named cell style
1038
     */
1039
    @Override
1040
    public void asNamedStyle(String name) {
1041
        setUserStyleName(name);
1042
    }
1043
1044
    /**
1045
     * Name of this style if this style represents a
1046
     * named cell style
1047
     */
1048
    @Override
1049
    public String getStyleName() {
1050
        return getUserStyleName();
1051
    }
1035
    
1052
    
1036
    /**
1053
    /**
1037
     * Get the reading order, for RTL/LTR ordering of
1054
     * Get the reading order, for RTL/LTR ordering of
(-)src/java/org/apache/poi/ss/usermodel/CellStyle.java (+11 lines)
Lines 899-902 Link Here
899
     *  it to fit if this text is too long?
899
     *  it to fit if this text is too long?
900
     */
900
     */
901
    boolean getShrinkToFit();
901
    boolean getShrinkToFit();
902
903
    /**
904
     * Converts this style into a named cell style
905
     */
906
    void asNamedStyle(String name);
907
908
    /**
909
     * Name of this style if this style represents a
910
     * named cell style
911
     */
912
    String getStyleName();
902
}
913
}

Return to bug 60866