org.docx4j.wml.TcPr Java Examples

/**
 *  我们创建一个单元格和单元格属性对象.
 *  也创建了一个纵向合并对象. 如果合并值不为null, 将它设置到合并对象中. 然后将该对象添加到
 *  单元格属性并将属性添加到单元格中. 最后设置单元格内容并将单元格添加到行中.
 *  
 *  如果合并值为'restart', 表明要开始一个新行. 如果为null, 继续按前面的行处理, 也就是合并单元格.
 */
private static void addMergedCell(Tr row, String content, String vMergeVal) {
    Tc tableCell = factory.createTc();
    TcPr tableCellProperties = new TcPr();
 
    VMerge merge = new VMerge();
    if(vMergeVal != null){
        merge.setVal(vMergeVal);
    }
    tableCellProperties.setVMerge(merge);
 
    tableCell.setTcPr(tableCellProperties);
    if(content != null) {
            tableCell.getContent().add(
            wordMLPackage.getMainDocumentPart().
                createParagraphOfText(content));
    }
 
    row.getContent().add(tableCell);
}
 

private void applyGridSpan( final Tc cell, final int colSpan, final String rowSpan, int w, boolean mergedVertical ) {
	
    TcPr tcPr = factory.createTcPr();
    TblWidth tblWidth = factory.createTblWidth();
    tblWidth.setType( "dxa" );
    tblWidth.setW( BigInteger.valueOf( w*colSpan ) );
    tcPr.setTcW( tblWidth  );
    
    if ( colSpan > 1) {
        GridSpan gridSpan = factory.createTcPrInnerGridSpan();
        gridSpan.setVal(BigInteger.valueOf(colSpan));
        tcPr.setGridSpan(gridSpan);
    }
    
    if ( mergedVertical ) {
    	//logger.debug(" this is vertical span");
    	VMerge gridVSpan = factory.createTcPrInnerVMerge();
    	if (rowSpan != null)
    		gridVSpan.setVal(rowSpan);
        tcPr.setVMerge(gridVSpan);
                    
    }
   
    cell.setTcPr(tcPr);
}
 

/** 
 * @Description: 跨行合并 
 */  
public void mergeCellsVertically(Tbl tbl, int col, int fromRow, int toRow) {  
    if (col < 0 || fromRow < 0 || toRow < 0) {  
        return;  
    }  
    for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {  
        Tc tc = getTc(tbl, rowIndex, col);  
        if (tc == null) {  
            break;  
        }  
        TcPr tcPr = getTcPr(tc);  
        VMerge vMerge = tcPr.getVMerge();  
        if (vMerge == null) {  
            vMerge = new VMerge();  
            tcPr.setVMerge(vMerge);  
        }  
        if (rowIndex == fromRow) {  
            vMerge.setVal("restart");  
        } else {  
            vMerge.setVal("continue");  
        }  
    }  
}
 

/** 
 * @Description: 跨行合并 
 */  
public static void mergeCellsVertically(Tbl tbl, int col, int fromRow, int toRow) {  
    if (col < 0 || fromRow < 0 || toRow < 0) {  
        return;  
    }  
    for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {  
        Tc tc = getTc(tbl, rowIndex, col);  
        if (tc == null) {  
            break;  
        }  
        TcPr tcPr = getTcPr(tc);  
        VMerge vMerge = tcPr.getVMerge();  
        if (vMerge == null) {  
            vMerge = factory.createTcPrInnerVMerge();  
            tcPr.setVMerge(vMerge);  
        }  
        if (rowIndex == fromRow) {  
            vMerge.setVal("restart");  
        } else {  
            vMerge.setVal("continue");  
        }  
    }  
}
 

/**
 *   实现思路:
     主要分在当前行上方插入行和在当前行下方插入行。对首尾2行特殊处理，在有跨行合并情况时，在第一行上面或者在最后一行下面插入是不会跨行的但是可能会跨列。
    对于中间的行，主要参照当前行，如果当前行跨行，则新增行也跨行，如果当前行单元格结束跨行，则新增的上方插入行跨行，下方插入行不跨行，如果当前行单元格开始跨行，则新增的上方插入行不跨行，下发插入行跨行。
    主要思路就是这样，插入的时候需要得到真实位置的单元格，代码如下:
 */
// 按位置得到单元格(考虑跨列合并情况)  
public Tc getTcByPosition(List<Tc> tcList, int position) {  
    int k = 0;  
    for (int i = 0, len = tcList.size(); i < len; i++) {  
        Tc tc = tcList.get(i);  
        TcPr trPr = tc.getTcPr();  
        if (trPr != null) {  
            GridSpan gridSpan = trPr.getGridSpan();  
            if (gridSpan != null) {  
                k += gridSpan.getVal().intValue() - 1;  
            }  
        }  
        if (k >= position) {  
            return tcList.get(i);  
        }  
        k++;  
    }  
    if (position < tcList.size()) {  
        return tcList.get(position);  
    }  
    return null;  
}
 

public Tc getTcByPosition(List<Tc> tcList, int position) {  
    int k = 0;  
    for (int i = 0, len = tcList.size(); i < len; i++) {  
        Tc tc = tcList.get(i);  
        TcPr trPr = tc.getTcPr();  
        if (trPr != null) {  
            GridSpan gridSpan = trPr.getGridSpan();  
            if (gridSpan != null) {  
                k += gridSpan.getVal().intValue() - 1;  
            }
        }  
        if (k >= position) {  
            return tcList.get(i);  
        }  
        k++;  
    }  
    if (position < tcList.size()) {  
        return tcList.get(position);  
    }  
    return null;  
}
 

/**
 * @Description: 得到行的列数
 */
public int getTcCellSizeWithMergeNum(Tr tr) {
    int cellSize = 1;
    List<Tc> tcList = getTrAllCell(tr);
    if (tcList == null || tcList.size() == 0) {
        return cellSize;
    }
    cellSize = tcList.size();
    for (Tc tc : tcList) {
        TcPr tcPr = getTcPr(tc);
        GridSpan gridSpan = tcPr.getGridSpan();
        if (gridSpan != null) {
            cellSize += gridSpan.getVal().intValue() - 1;
        }
    }
    return cellSize;
}
 

/**
 * @Description: 跨行合并
 */
public void mergeCellsVertically(Tbl tbl, int col, int fromRow, int toRow) {
    if (col < 0 || fromRow < 0 || toRow < 0) {
        return;
    }
    for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
        Tc tc = getTc(tbl, rowIndex, col);
        if (tc == null) {
            break;
        }
        TcPr tcPr = getTcPr(tc);
        VMerge vMerge = tcPr.getVMerge();
        if (vMerge == null) {
            vMerge = new VMerge();
            tcPr.setVMerge(vMerge);
        }
        if (rowIndex == fromRow) {
            vMerge.setVal("restart");
        } else {
            vMerge.setVal("continue");
        }
    }
}
 

public void addMergedCell(Tr row, String content, String vMergeVal) {  
    Tc tableCell = factory.createTc();  
    TcPr tableCellProperties = new TcPr();  
   
    VMerge merge = new VMerge();  
    if(vMergeVal != null){  
        merge.setVal(vMergeVal);  
    }  
    tableCellProperties.setVMerge(merge);  
   
    tableCell.setTcPr(tableCellProperties);  
    if(content != null) {  
    	tableCell.getContent().add(wmlPackage.getMainDocumentPart(). createParagraphOfText(content));  
    }  
   
    row.getContent().add(tableCell);  
}
 

/**
 * @Description: 得到行的列数
 */
public static int getTcCellSizeWithMergeNum(Tr tr) {
    int cellSize = 1;
    List<Tc> tcList = getTrAllCell(tr);
    if (tcList == null || tcList.size() == 0) {
        return cellSize;
    }
    cellSize = tcList.size();
    for (Tc tc : tcList) {
        TcPr tcPr = getTcPr(tc);
        GridSpan gridSpan = tcPr.getGridSpan();
        if (gridSpan != null) {
            cellSize += gridSpan.getVal().intValue() - 1;
        }
    }
    return cellSize;
}
 

/**
 * @Description: 跨行合并
 */
public static void mergeCellsVertically(Tbl tbl, int col, int fromRow, int toRow) {
    if (col < 0 || fromRow < 0 || toRow < 0) {
        return;
    }
    for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
        Tc tc = getTc(tbl, rowIndex, col);
        if (tc == null) {
            break;
        }
        TcPr tcPr = getTcPr(tc);
        VMerge vMerge = tcPr.getVMerge();
        if (vMerge == null) {
            vMerge = new VMerge();
            tcPr.setVMerge(vMerge);
        }
        if (rowIndex == fromRow) {
            vMerge.setVal("restart");
        } else {
            vMerge.setVal("continue");
        }
    }
}
 

/**
 * @Description: 跨列合并
 */
public static void mergeCellsHorizontal(Tbl tbl, int row, int fromCell, int toCell) {
    if (row < 0 || fromCell < 0 || toCell < 0) {
        return;
    }
    List<Tr> trList = getTblAllTr(tbl);
    if (row > trList.size()) {
        return;
    }
    Tr tr = trList.get(row);
    List<Tc> tcList = getTrAllCell(tr);
    for (int cellIndex = fromCell, len = Math.min(tcList.size() - 1, toCell); cellIndex <= len; cellIndex++) {
        Tc tc = tcList.get(cellIndex);
        TcPr tcPr = getTcPr(tc);
        HMerge hMerge = tcPr.getHMerge();
        if (hMerge == null) {
            hMerge = new HMerge();
            tcPr.setHMerge(hMerge);
        }
        if (cellIndex == fromCell) {
            hMerge.setVal("restart");
        } else {
            hMerge.setVal("continue");
        }
    }
}
 

/**
 * @Description: 跨列合并
 */
public static void mergeCellsHorizontalByGridSpan(Tbl tbl, int row, int fromCell, int toCell) {
    if (row < 0 || fromCell < 0 || toCell < 0) {
        return;
    }
    List<Tr> trList = getTblAllTr(tbl);
    if (row > trList.size()) {
        return;
    }
    Tr tr = trList.get(row);
    List<Tc> tcList = getTrAllCell(tr);
    for (int cellIndex = Math.min(tcList.size() - 1, toCell); cellIndex >= fromCell; cellIndex--) {
        Tc tc = tcList.get(cellIndex);
        TcPr tcPr = getTcPr(tc);
        if (cellIndex == fromCell) {
            GridSpan gridSpan = tcPr.getGridSpan();
            if (gridSpan == null) {
                gridSpan = new GridSpan();
                tcPr.setGridSpan(gridSpan);
            }
            gridSpan.setVal(BigInteger.valueOf(Math.min(tcList.size() - 1, toCell) - fromCell + 1));
        } else {
            tr.getContent().remove(cellIndex);
        }
    }
}
 

protected static void createFoAttributes(TcPr tcPr, Element foBlockElement){
  	// includes TcPrInner.TcBorders, CTShd, TcMar, CTVerticalJc
  	
if (tcPr==null) {
	return;
}
  	applyFoAttributes(PropertyFactory.createProperties(tcPr), foBlockElement);
  }
 

/**
 * @Description: 设置单元格垂直对齐方式
 */
public void setTcVAlign(Tc tc, STVerticalJc vAlignType) {
    if (vAlignType != null) {
        TcPr tcPr = getTcPr(tc);
        CTVerticalJc vAlign = new CTVerticalJc();
        vAlign.setVal(vAlignType);
        tcPr.setVAlign(vAlign);
    }
}
 

public void addTableCell(ObjectFactory factory,
		WordprocessingMLPackage wordMLPackage, Tr tableRow, String content,
		RPr rpr, JcEnumeration jcEnumeration, boolean hasBgColor,
		String backgroudColor) {
	Tc tableCell = factory.createTc();
	P p = factory.createP();
	setParagraphAlign(factory, p, jcEnumeration);
	Text t = factory.createText();
	t.setValue(content);
	R run = factory.createR();
	// 设置表格内容字体样式
	run.setRPr(rpr);
	run.getContent().add(t);
	p.getContent().add(run);
	tableCell.getContent().add(p);

	if (hasBgColor) {
		TcPr tcPr = tableCell.getTcPr();
		if (tcPr == null) {
			tcPr = factory.createTcPr();
		}
		CTShd shd = tcPr.getShd();
		if (shd == null) {
			shd = factory.createCTShd();
		}
		shd.setColor("auto");
		shd.setFill(backgroudColor);
		tcPr.setShd(shd);
		tableCell.setTcPr(tcPr);
	}
	tableRow.getContent().add(tableCell);
}
 

/**
  * In the FO case, if we need to rotate the text, we do that
  * by inserting a block-container.
  * 
  * @param cellNode
  * @return
  */
@Override
 protected Element interposeBlockContainer(Document doc, Element cellNode, TcPr tcPr) {
 	
	if (tcPr==null || tcPr.getTextDirection()==null) {
		// usual case
		return cellNode;
	} else {
		
		/* We need block-container, something like:
		 * 
        <table-cell>
          <block-container reference-orientation="90">
            <block>Hello</block>
          </block-container>
        </table-cell>
         */
		
		Element ret = doc.createElementNS("http://www.w3.org/1999/XSL/Format", "fo:block-container");
		
		TextDir textDir = new TextDir(tcPr.getTextDirection());
		textDir.setXslFO(ret);
		
		cellNode.appendChild(ret);
		
		if (cellNode.hasAttribute("reference-orientation")) {
			// remove it, since it doesn't work at that level
			cellNode.removeAttribute("reference-orientation");
		}
		
		return ret;
		
	}
 }
 

/**
 *  本方法创建一个单元格属性集对象和一个表格宽度对象. 将给定的宽度设置到宽度对象然后将其添加到
 *  属性集对象. 最后将属性集对象设置到单元格中.
 */
private static void setCellWidth(Tc tableCell, int width) {
    TcPr tableCellProperties = new TcPr();
    TblWidth tableWidth = new TblWidth();
    tableWidth.setW(BigInteger.valueOf(width));
    tableCellProperties.setTcW(tableWidth);
    tableCell.setTcPr(tableCellProperties);
}
 

private static void createFoAttributes(TcPr tcPr, Element foBlockElement){
  	// includes TcPrInner.TcBorders, CTShd, TcMar, CTVerticalJc
  	
if (tcPr==null) {
	return;
}
  	applyFoAttributes(PropertyFactory.createProperties(tcPr), foBlockElement);
  }
 

public void addTableCell(ObjectFactory factory,
		WordprocessingMLPackage wordMLPackage, Tr tableRow, String content,
		RPr rpr, JcEnumeration jcEnumeration, boolean hasBgColor,
		String backgroudColor) {
	Tc tableCell = factory.createTc();
	P p = factory.createP();
	setParagraphSpacing(factory, p, jcEnumeration, true, "0", "0", null,
			null, true, "240", STLineSpacingRule.AUTO);
	Text t = factory.createText();
	t.setValue(content);
	R run = factory.createR();
	// 设置表格内容字体样式
	run.setRPr(rpr);

	TcPr tcPr = tableCell.getTcPr();
	if (tcPr == null) {
		tcPr = factory.createTcPr();
	}

	CTVerticalJc valign = factory.createCTVerticalJc();
	valign.setVal(STVerticalJc.CENTER);
	tcPr.setVAlign(valign);

	run.getContent().add(t);
	p.getContent().add(run);
	tableCell.getContent().add(p);
	if (hasBgColor) {
		CTShd shd = tcPr.getShd();
		if (shd == null) {
			shd = factory.createCTShd();
		}
		shd.setColor("auto");
		shd.setFill(backgroudColor);
		tcPr.setShd(shd);
	}
	tableCell.setTcPr(tcPr);
	tableRow.getContent().add(tableCell);
}
 

@Override
  protected void setupTcPr(TableCellBox tcb, Tc tc, TableProperties tableProperties) {

/*
 * Reinstate
 * 
	context.getWmlPackage().setUserData(cellId+"#Pr", cell.getTcPr() );
	
	as set by SessionAwareAbstractTableWriter
	
 */

String id = tcb.getElement().getAttribute("id");

if (id==null ) {
	log.debug("no id on tc " );
	
} else {
	log.debug("processing tc with id " + id);

	Object o = wordMLPackage.getUserData(id+"#Pr");
	if (o==null) {
		
		log.debug("no #Pr UserData on tc with id " + id);
	
	} else {
		tc.setTcPr((TcPr)o);
		return;
	}
}

super.setupTcPr( tcb,  tc,  tableProperties);
  }
 

/** 
 * @Description: 跨列合并 
 */  
public void mergeCellsHorizontal(Tbl tbl, int row, int fromCell, int toCell) {  
    if (row < 0 || fromCell < 0 || toCell < 0) {  
        return;  
    }  
    List<Tr> trList = getTblAllTr(tbl);  
    if (row > trList.size()) {  
        return;  
    }  
    Tr tr = trList.get(row);  
    List<Tc> tcList = getTrAllCell(tr);  
    for (int cellIndex = fromCell, len = Math  
            .min(tcList.size() - 1, toCell); cellIndex <= len; cellIndex++) {  
        Tc tc = tcList.get(cellIndex);  
        TcPr tcPr = getTcPr(tc);  
        HMerge hMerge = tcPr.getHMerge();  
        if (hMerge == null) {  
            hMerge = new HMerge();  
            tcPr.setHMerge(hMerge);  
        }  
        if (cellIndex == fromCell) {  
            hMerge.setVal("restart");  
        } else {  
            hMerge.setVal("continue");  
        }  
    }  
}
 

public void mergeCellsHorizontalByGridSpan(Tbl tbl, int row, int fromCell,  
        int toCell) {  
    if (row < 0 || fromCell < 0 || toCell < 0) {  
        return;  
    }  
    List<Tr> trList = getTblAllTr(tbl);  
    if (row > trList.size()) {  
        return;  
    }  
    Tr tr = trList.get(row);  
    List<Tc> tcList = getTrAllCell(tr);  
    for (int cellIndex = Math.min(tcList.size() - 1, toCell); cellIndex >= fromCell; cellIndex--) {  
        Tc tc = tcList.get(cellIndex);  
        TcPr tcPr = getTcPr(tc);  
        if (cellIndex == fromCell) {  
            GridSpan gridSpan = tcPr.getGridSpan();  
            if (gridSpan == null) {  
                gridSpan = new GridSpan();  
                tcPr.setGridSpan(gridSpan);  
            }  
            gridSpan.setVal(BigInteger.valueOf(Math.min(tcList.size() - 1,  
                    toCell) - fromCell + 1));  
        } else {  
            tr.getContent().remove(cellIndex);  
        }  
    }  
}
 

/**
 * @Description: 设置单元格宽度
 */
public void setTcWidth(Tc tc, String width) {
    if (StringUtils.isNotBlank(width)) {
        TcPr tcPr = getTcPr(tc);
        TblWidth tcW = tcPr.getTcW();
        if (tcW == null) {
            tcW = new TblWidth();
            tcPr.setTcW(tcW);
        }
        tcW.setW(new BigInteger(width));
        tcW.setType("dxa");
    }
}
 

/**
 * @Description: 跨列合并
 */
public void mergeCellsHorizontal(Tbl tbl, int row, int fromCell, int toCell) {
    if (row < 0 || fromCell < 0 || toCell < 0) {
        return;
    }
    List<Tr> trList = getTblAllTr(tbl);
    if (row > trList.size()) {
        return;
    }
    Tr tr = trList.get(row);
    List<Tc> tcList = getTrAllCell(tr);
    for (int cellIndex = fromCell, len = Math
            .min(tcList.size() - 1, toCell); cellIndex <= len; cellIndex++) {
        Tc tc = tcList.get(cellIndex);
        TcPr tcPr = getTcPr(tc);
        HMerge hMerge = tcPr.getHMerge();
        if (hMerge == null) {
            hMerge = new HMerge();
            tcPr.setHMerge(hMerge);
        }
        if (cellIndex == fromCell) {
            hMerge.setVal("restart");
        } else {
            hMerge.setVal("continue");
        }
    }
}
 

/**
 * @Description: 跨列合并
 */
public void mergeCellsHorizontalByGridSpan(Tbl tbl, int row, int fromCell,
        int toCell) {
    if (row < 0 || fromCell < 0 || toCell < 0) {
        return;
    }
    List<Tr> trList = getTblAllTr(tbl);
    if (row > trList.size()) {
        return;
    }
    Tr tr = trList.get(row);
    List<Tc> tcList = getTrAllCell(tr);
    for (int cellIndex = Math.min(tcList.size() - 1, toCell); cellIndex >= fromCell; cellIndex--) {
        Tc tc = tcList.get(cellIndex);
        TcPr tcPr = getTcPr(tc);
        if (cellIndex == fromCell) {
            GridSpan gridSpan = tcPr.getGridSpan();
            if (gridSpan == null) {
                gridSpan = new GridSpan();
                tcPr.setGridSpan(gridSpan);
            }
            gridSpan.setVal(BigInteger.valueOf(Math.min(tcList.size() - 1,
                    toCell) - fromCell + 1));
        } else {
            tr.getContent().remove(cellIndex);
        }
    }
}
 

public void setCellWidth(Tc tableCell, int width) {  
    TcPr tableCellProperties = new TcPr();  
    TblWidth tableWidth = new TblWidth();  
    tableWidth.setW(BigInteger.valueOf(width));  
    tableCellProperties.setTcW(tableWidth);  
    tableCell.setTcPr(tableCellProperties);  
}
 

/**
 * @Description: 设置单元格垂直对齐方式
 */
public static void setTcVAlign(Tc tc, STVerticalJc vAlignType) {
    if (vAlignType != null) {
        TcPr tcPr = getTcPr(tc);
        CTVerticalJc vAlign = new CTVerticalJc();
        vAlign.setVal(vAlignType);
        tcPr.setVAlign(vAlign);
    }
}
 

/**
 * @Description: 设置单元格宽度
 */
public static void setTcWidth(Tc tc, String width) {
    if (StringUtils.isNotBlank(width)) {
        TcPr tcPr = getTcPr(tc);
        TblWidth tcW = tcPr.getTcW();
        if (tcW == null) {
            tcW = new TblWidth();
            tcPr.setTcW(tcW);
        }
        tcW.setW(new BigInteger(width));
        tcW.setType("dxa");
    }
}
 

public void addTableCell(ObjectFactory factory,  
        WordprocessingMLPackage wordMLPackage, Tr tableRow, String content,  
        RPr rpr, JcEnumeration jcEnumeration, boolean hasBgColor,  
        String backgroudColor) {  
    Tc tableCell = factory.createTc();  
    P p = factory.createP();  
    setParagraphAlign(factory, p, jcEnumeration);  
    Text t = factory.createText();  
    t.setValue(content);  
    R run = factory.createR();  
    // 设置表格内容字体样式  
    run.setRPr(rpr);  
      
    TcPr tcPr = tableCell.getTcPr();  
    if (tcPr == null) {  
        tcPr = factory.createTcPr();  
    }  
      
    CTVerticalJc valign = factory.createCTVerticalJc();  
    valign.setVal(STVerticalJc.CENTER);  
    tcPr.setVAlign(valign);  
      
    run.getContent().add(t);  
    p.getContent().add(run);  
      
    PPr ppr=p.getPPr();  
    if(ppr==null){  
        ppr=factory.createPPr();  
    }  
    //设置段后距离  
    Spacing spacing=new Spacing();  
    spacing.setAfter(new BigInteger("0"));  
    spacing.setLineRule(STLineSpacingRule.AUTO);  
    ppr.setSpacing(spacing);  
    p.setPPr(ppr);  
      
    tableCell.getContent().add(p);  
    if (hasBgColor) {  
        CTShd shd = tcPr.getShd();  
        if (shd == null) {  
            shd = factory.createCTShd();  
        }  
        shd.setColor("auto");  
        shd.setFill(backgroudColor);  
        tcPr.setShd(shd);  
        tableCell.setTcPr(tcPr);  
    }  
    tableRow.getContent().add(tableCell);  
}