Regression fix for XSLF

- master style was always overridden, because of r1745100
- AIOOB in TextDirection mapping

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1746858 13f79535-47bb-0310-9956-ffa450edef68

src/ooxml/java/org/apache/poi/xslf/model/CharacterPropertyFetcher.java

 import org.openxmlformats.schemas.drawingml.x2006.main.CTTextCharacterProperties;
 import org.openxmlformats.schemas.drawingml.x2006.main.CTTextParagraphProperties;
 
-/**
- *
- * @author Yegor Kozlov
- */
 public abstract class CharacterPropertyFetcher<T> extends ParagraphPropertyFetcher<T> {
     public CharacterPropertyFetcher(int level) {
         super(level);
     }
 
     public boolean fetch(CTTextParagraphProperties props) {
-        if (props.isSetDefRPr()) {
+        if (props != null && props.isSetDefRPr()) {
             return fetch(props.getDefRPr());
         }
 

src/ooxml/java/org/apache/poi/xslf/usermodel/XSLFLineBreak.java

 import org.openxmlformats.schemas.drawingml.x2006.main.CTRegularTextRun;
 import org.openxmlformats.schemas.drawingml.x2006.main.CTTextCharacterProperties;
 
-/**
- * @author Yegor Kozlov
- */
 class XSLFLineBreak extends XSLFTextRun {
     private final CTTextCharacterProperties _brProps;
 
     }
 
     @Override
-    protected CTTextCharacterProperties getRPr(){
+    protected CTTextCharacterProperties getRPr(boolean create){
         return _brProps;
     }
 

src/ooxml/java/org/apache/poi/xslf/usermodel/XSLFTextParagraph.java

         CTTextCharacterProperties brProps = br.addNewRPr();
         if(_runs.size() > 0){
             // by default line break has the font size of the last text run
-            CTTextCharacterProperties prevRun = _runs.get(_runs.size() - 1).getRPr();
+            CTTextCharacterProperties prevRun = _runs.get(_runs.size() - 1).getRPr(true);
             brProps.set(prevRun);
         }
         CTRegularTextRun r = CTRegularTextRun.Factory.newInstance();
         }
         if (!_runs.isEmpty()) {
             int size = _runs.size();
-            thisP.setEndParaRPr(_runs.get(size-1).getRPr());
+            XSLFTextRun lastRun = _runs.get(size-1);
+            CTTextCharacterProperties cpOther = lastRun.getRPr(false);
+            if (cpOther != null) {
+                if (thisP.isSetEndParaRPr()) {
+                    thisP.unsetEndParaRPr();
+                }
+                CTTextCharacterProperties cp = thisP.addNewEndParaRPr();
+                cp.set(cpOther);
+            }
             for (int i=size; i>0; i--) {
                 thisP.removeR(i-1);
             }

src/ooxml/java/org/apache/poi/xslf/usermodel/XSLFTextRun.java

         SolidPaint sp = (SolidPaint)color;
         Color c = DrawPaint.applyColorTransform(sp.getSolidColor());
         
-        CTTextCharacterProperties rPr = getRPr();
+        CTTextCharacterProperties rPr = getRPr(true);
         CTSolidColorFillProperties fill = rPr.isSetSolidFill() ? rPr.getSolidFill() : rPr.addNewSolidFill();
         
         XSLFColor col = new XSLFColor(fill, getParentParagraph().getParentShape().getSheet().getTheme(), fill.getSchemeClr());
     public PaintStyle getFontColor(){
         CharacterPropertyFetcher<PaintStyle> fetcher = new CharacterPropertyFetcher<PaintStyle>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                XSLFShape shape = _p.getParentShape();
-                CTShapeStyle style = shape.getSpStyle();
-                CTSchemeColor phClr = null;
-                if (style != null && style.getFontRef() != null) {
-                    phClr = style.getFontRef().getSchemeClr();
-                }
-
-                PaintStyle ps = shape.getPaint(props, phClr);
-                if (ps != null)  {
-                    setValue(ps);
-                    return true;
+                if (props != null) {
+                    XSLFShape shape = _p.getParentShape();
+                    CTShapeStyle style = shape.getSpStyle();
+                    CTSchemeColor phClr = null;
+                    if (style != null && style.getFontRef() != null) {
+                        phClr = style.getFontRef().getSchemeClr();
+                    }
+    
+                    PaintStyle ps = shape.getPaint(props, phClr);
+                    if (ps != null)  {
+                        setValue(ps);
+                        return true;
+                    }
                 }
                 
                 return false;
 
     @Override
     public void setFontSize(Double fontSize){
-        CTTextCharacterProperties rPr = getRPr();
+        CTTextCharacterProperties rPr = getRPr(true);
         if(fontSize == null) {
             if (rPr.isSetSz()) rPr.unsetSz();
         } else {
 
         CharacterPropertyFetcher<Double> fetcher = new CharacterPropertyFetcher<Double>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetSz()){
+                if (props != null && props.isSetSz()) {
                     setValue(props.getSz()*0.01);
                     return true;
                 }
 
         CharacterPropertyFetcher<Double> fetcher = new CharacterPropertyFetcher<Double>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetSpc()){
+                if (props != null && props.isSetSpc()) {
                     setValue(props.getSpc()*0.01);
                     return true;
                 }
      * @param spc  character spacing in points.
      */
     public void setCharacterSpacing(double spc){
-        CTTextCharacterProperties rPr = getRPr();
+        CTTextCharacterProperties rPr = getRPr(true);
         if(spc == 0.0) {
             if(rPr.isSetSpc()) rPr.unsetSpc();
         } else {
     }
 
     public void setFontFamily(String typeface, byte charset, byte pictAndFamily, boolean isSymbol){
-        CTTextCharacterProperties rPr = getRPr();
+        CTTextCharacterProperties rPr = getRPr(true);
 
         if(typeface == null){
             if(rPr.isSetLatin()) rPr.unsetLatin();
 
         CharacterPropertyFetcher<String> visitor = new CharacterPropertyFetcher<String>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                CTTextFont font = props.getLatin();
-                if(font != null){
-                    String typeface = font.getTypeface();
-                    if("+mj-lt".equals(typeface)) {
-                        typeface = theme.getMajorFont();
-                    } else if ("+mn-lt".equals(typeface)){
-                        typeface = theme.getMinorFont();
+                if (props != null) {
+                    CTTextFont font = props.getLatin();
+                    if (font != null) {
+                        String typeface = font.getTypeface();
+                        if("+mj-lt".equals(typeface)) {
+                            typeface = theme.getMajorFont();
+                        } else if ("+mn-lt".equals(typeface)){
+                            typeface = theme.getMinorFont();
+                        }
+                        setValue(typeface);
+                        return true;
                     }
-                    setValue(typeface);
-                    return true;
                 }
                 return false;
             }
 
         CharacterPropertyFetcher<Byte> visitor = new CharacterPropertyFetcher<Byte>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                CTTextFont font = props.getLatin();
-                if(font != null){
-                    setValue(font.getPitchFamily());
-                    return true;
+                if (props != null) {
+                    CTTextFont font = props.getLatin();
+                    if (font != null) {
+                        setValue(font.getPitchFamily());
+                        return true;
+                    }
                 }
                 return false;
             }
 
     @Override
     public void setStrikethrough(boolean strike) {
-        getRPr().setStrike(strike ? STTextStrikeType.SNG_STRIKE : STTextStrikeType.NO_STRIKE);
+        getRPr(true).setStrike(strike ? STTextStrikeType.SNG_STRIKE : STTextStrikeType.NO_STRIKE);
     }
 
     @Override
     public boolean isStrikethrough() {
         CharacterPropertyFetcher<Boolean> fetcher = new CharacterPropertyFetcher<Boolean>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetStrike()){
+                if(props != null && props.isSetStrike()) {
                     setValue(props.getStrike() != STTextStrikeType.NO_STRIKE);
                     return true;
                 }
     public boolean isSuperscript() {
         CharacterPropertyFetcher<Boolean> fetcher = new CharacterPropertyFetcher<Boolean>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetBaseline()){
+                if (props != null && props.isSetBaseline()) {
                     setValue(props.getBaseline() > 0);
                     return true;
                 }
      * @param baselineOffset
      */
     public void setBaselineOffset(double baselineOffset){
-       getRPr().setBaseline((int) baselineOffset * 1000);
+       getRPr(true).setBaseline((int) baselineOffset * 1000);
     }
 
     /**
     public boolean isSubscript() {
         CharacterPropertyFetcher<Boolean> fetcher = new CharacterPropertyFetcher<Boolean>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetBaseline()){
+                if (props != null && props.isSetBaseline()) {
                     setValue(props.getBaseline() < 0);
                     return true;
                 }
     public TextCap getTextCap() {
         CharacterPropertyFetcher<TextCap> fetcher = new CharacterPropertyFetcher<TextCap>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetCap()){
+                if (props != null && props.isSetCap()) {
                     int idx = props.getCap().intValue() - 1;
                     setValue(TextCap.values()[idx]);
                     return true;
 
     @Override
     public void setBold(boolean bold){
-        getRPr().setB(bold);
+        getRPr(true).setB(bold);
     }
 
     @Override
     public boolean isBold(){
         CharacterPropertyFetcher<Boolean> fetcher = new CharacterPropertyFetcher<Boolean>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetB()){
+                if (props != null && props.isSetB()) {
                     setValue(props.getB());
                     return true;
                 }
 
     @Override
     public void setItalic(boolean italic){
-        getRPr().setI(italic);
+        getRPr(true).setI(italic);
     }
 
     @Override
     public boolean isItalic(){
         CharacterPropertyFetcher<Boolean> fetcher = new CharacterPropertyFetcher<Boolean>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetI()){
+                if (props != null && props.isSetI()) {
                     setValue(props.getI());
                     return true;
                 }
 
     @Override
     public void setUnderlined(boolean underline) {
-        getRPr().setU(underline ? STTextUnderlineType.SNG : STTextUnderlineType.NONE);
+        getRPr(true).setU(underline ? STTextUnderlineType.SNG : STTextUnderlineType.NONE);
     }
 
     @Override
     public boolean isUnderlined(){
         CharacterPropertyFetcher<Boolean> fetcher = new CharacterPropertyFetcher<Boolean>(_p.getIndentLevel()){
             public boolean fetch(CTTextCharacterProperties props){
-                if(props.isSetU()){
+                if (props != null && props.isSetU()) {
                     setValue(props.getU() != STTextUnderlineType.NONE);
                     return true;
                 }
         return fetcher.getValue() == null ? false : fetcher.getValue();
     }
 
-    protected CTTextCharacterProperties getRPr(){
-        return _r.isSetRPr() ? _r.getRPr() : _r.addNewRPr();
+    /**
+     * Return the character properties
+     *
+     * @param create if true, create an empty character properties object if it doesn't exist
+     * @return the character properties or null if create was false and the properties haven't exist
+     */
+    protected CTTextCharacterProperties getRPr(boolean create) {
+        if (_r.isSetRPr()) {
+            return _r.getRPr();
+        } else if (create) {
+            return _r.addNewRPr();
+        } else {
+            return null;
+        }
     }
 
     @Override
         XSLFSheet sheet = shape.getSheet();
         boolean ok = false;
 
-        if (_r.isSetRPr()) ok = fetcher.fetch(getRPr());
+        if (_r.isSetRPr()) ok = fetcher.fetch(getRPr(false));
         if (ok) return true;
         
         ok = shape.fetchShapeProperty(fetcher);

src/ooxml/java/org/apache/poi/xslf/usermodel/XSLFTextShape.java

         if (text == null) return null;
 
         // copy properties from last paragraph / textrun or paragraph end marker
-        CTTextParagraphProperties pPr = null;
-        CTTextCharacterProperties rPr = null;
+        CTTextParagraphProperties otherPPr = null;
+        CTTextCharacterProperties otherRPr = null;
 
         boolean firstPara;
         XSLFTextParagraph para;
             firstPara = !newParagraph;
             para = _paragraphs.get(_paragraphs.size()-1);
             CTTextParagraph ctp = para.getXmlObject();
-            pPr = ctp.getPPr();
+            otherPPr = ctp.getPPr();
             List<XSLFTextRun> runs = para.getTextRuns();
             if (!runs.isEmpty()) {
                 XSLFTextRun r0 = runs.get(runs.size()-1);
-                rPr = r0.getXmlObject().getRPr();
-            } else if (ctp.isSetEndParaRPr()) {
-                rPr = ctp.getEndParaRPr();
+                otherRPr = r0.getRPr(false);
+                if (otherRPr == null) {
+                    otherRPr = ctp.getEndParaRPr();
+                }
             }
+            // don't copy endParaRPr to the run in case there aren't any other runs
+            // this is the case when setText() was called initially
+            // otherwise the master style will be overridden/ignored
         }
 
         XSLFTextRun run = null;
         for (String lineTxt : text.split("\\r\\n?|\\n")) {
             if (!firstPara) {
-                if (para != null && para.getXmlObject().isSetEndParaRPr()) {
-                    para.getXmlObject().unsetEndParaRPr();
+                if (para != null) {
+                    CTTextParagraph ctp = para.getXmlObject();
+                    CTTextCharacterProperties unexpectedRPr = ctp.getEndParaRPr();
+                    if (unexpectedRPr != null && unexpectedRPr != otherRPr) {
+                        ctp.unsetEndParaRPr();
+                    }
                 }
                 para = addNewTextParagraph();
-                if (pPr != null) {
-                    para.getXmlObject().setPPr(pPr);
+                if (otherPPr != null) {
+                    para.getXmlObject().setPPr(otherPPr);
                 }
             }
             boolean firstRun = true;
                 }
                 run = para.addNewTextRun();
                 run.setText(runText);
-                if (rPr != null) {
-                    run.getXmlObject().setRPr(rPr);
+                if (otherRPr != null) {
+                    run.getRPr(true).set(otherRPr);
                 }
                 firstRun = false;
             }
         CTTextBodyProperties bodyPr = getTextBodyPr();
         if (bodyPr != null) {
             STTextVerticalType.Enum val = bodyPr.getVert();
-            if(val != null){
-                return TextDirection.values()[val.intValue() - 1];
+            if(val != null) {
+                switch (val.intValue()) {
+                    default:
+                    case STTextVerticalType.INT_HORZ:
+                        return TextDirection.HORIZONTAL;
+                    case STTextVerticalType.INT_EA_VERT:
+                    case STTextVerticalType.INT_MONGOLIAN_VERT:
+                    case STTextVerticalType.INT_VERT:
+                        return TextDirection.VERTICAL;
+                    case STTextVerticalType.INT_VERT_270:
+                        return TextDirection.VERTICAL_270;
+                    case STTextVerticalType.INT_WORD_ART_VERT_RTL:
+                    case STTextVerticalType.INT_WORD_ART_VERT:
+                        return TextDirection.STACKED;
+                }
             }
         }
         return TextDirection.HORIZONTAL;

src/ooxml/testcases/org/apache/poi/xslf/usermodel/TestXSLFTable.java

 import org.openxmlformats.schemas.drawingml.x2006.main.CTTableCell;
 import org.openxmlformats.schemas.presentationml.x2006.main.CTGraphicalObjectFrame;
 
-/**
- * @author Yegor Kozlov
- */
 public class TestXSLFTable {
     @Test
     public void testRead() throws IOException {
 
     @Test
     public void testCreate() throws IOException {
-        XMLSlideShow ppt = new XMLSlideShow();
-        XSLFSlide slide = ppt.createSlide();
+        XMLSlideShow ppt1 = new XMLSlideShow();
+        XSLFSlide slide = ppt1.createSlide();
 
         XSLFTable tbl = slide.createTable();
         assertNotNull(tbl.getCTTable());
         cell1.setVerticalAlignment(null);
         assertEquals(VerticalAlignment.TOP, cell1.getVerticalAlignment());
         
-        ppt.close();
+        XMLSlideShow ppt2 = XSLFTestDataSamples.writeOutAndReadBack(ppt1);
+        ppt1.close();
+
+        slide = ppt2.getSlides().get(0);
+        tbl = (XSLFTable)slide.getShapes().get(0);
+        assertEquals(2, tbl.getNumberOfColumns());
+        assertEquals(1, tbl.getNumberOfRows());
+        assertEquals("POI", tbl.getCell(0, 0).getText());
+        assertEquals("Apache", tbl.getCell(0, 1).getText());
+        
+        ppt2.close();
     }
     
     @Test

src/ooxml/testcases/org/apache/poi/xslf/usermodel/TestXSLFTextRun.java

         XSLFTextShape sh = slide.createAutoShape();
 
         XSLFTextRun r = sh.addNewTextParagraph().addNewTextRun();
-        assertEquals("en-US", r.getRPr().getLang());
+        assertEquals("en-US", r.getRPr(true).getLang());
 
         assertEquals(0., r.getCharacterSpacing(), 0);
         r.setCharacterSpacing(3);
         assertEquals(-3., r.getCharacterSpacing(), 0);
         r.setCharacterSpacing(0);
         assertEquals(0., r.getCharacterSpacing(), 0);
-        assertFalse(r.getRPr().isSetSpc());
+        assertFalse(r.getRPr(true).isSetSpc());
 
         assertTrue(sameColor(Color.black, r.getFontColor()));
         r.setFontColor(Color.red);