使用Jacob来处理Word文档
Word或Excel程序是以一种COM组件形式存在的。如果能够在Java中调用Word的COM组件，就
能使用它的方法来获取Word文档中的文本信息。目前网上有许多提供这样的工具。
1 Jacob的下载
Jacob 是Java-COM Bridge的缩写，它在Java与微软的COM组件之间构建一座桥梁。使用Jacob
自带的DLL动态链接库，并通过JNI的方式实现了在Java平台上对COM程序的调用。Jacob下载
的地址为：
http://sourceforge.net/project/showfiles.php? group_id=109543&package_id=118368。本书
采用的是jacob_1.11_zip。解压下载的 Jacob_1.11_zip文件后，
2 在Eclipse中配置
（1）将jacob.jar导入工程的Build Path，然后确认自己机器的CPU类型（X86或AMD64），并
选择不同目录下的jacob.dll文件。
（2）将jacob.dll放到% JAVA_HOME%/jre/bin目录下，其中，%JAVA_HOME%就是JDK的安装
目录。注意这个的jre目录必须是Eclipse当前正在使 用的目录，在Eclipse中选择“window-
>Preferences”菜单，在弹出的对话框中选择“Java->Installed JREs”项，
（3）当前选择的JRE是“C:/Program Files/Java/jdk1.5.0_07/jre”目录下的，所以需要把
jacob.dll复制到“C:/Program Files/Java/jdk1.5.0_07/jre/bin”目录下面。
（4）在工程中新建一个ch7.jacob包， 并在包中创建WordReader类。该类将提供一个静态的
extractDoc()方法。它接收两个参数，一个是要处理的DOC文件名，另一个则是输出 的文件名
，然后通过JNI调用Word的API转换内容，该函数的代码如下。
public static void extractDoc(String inputFIle, String outputFile) {
boolean flag = false;
// 打开Word应用程序
ActiveXComponent app = new ActiveXComponent("Word.Application");
try {
// 设置word不可见
app.setProperty("Visible", new Variant(false));
// 打开word文件
Dispatch doc1 = app.getProperty("Documents").toDispatch();
Dispatch doc2 = Dispatch.invoke(
doc1,
"Open",
Dispatch.Method,
new Object[] { inputFIle, new Variant(false),
new Variant(true) }, new int[1]).toDispatch();
// 作为txt格式保存到临时文件
Dispatch.invoke(doc2, "SaveAs", Dispatch.Method, new Object[] {
outputFile, new Variant(7) }, new int[1]);
// 关闭word
Variant f = new Variant(false);
Dispatch.call(doc2, "Close", f);
flag = true;
} catch (Exception e) {
e.printStackTrace();
} finally {
app.invoke("Quit", new Variant[] {});
}
if (flag == true) {
System.out.println("Transformed Successfully");
} else {
System.out.println("Transform Failed");
}
}
（5）创建一个main函数来测试WordReader类，该main函数代码如下。
public static void main(String[] args) {
WordReader.extractDoc("c:/test.doc","c:/jacob.txt");
}
（6）新生成的txt文件被保存到c:/jacob.txt下
在使用Jacob时，很重要的一点是，用户本地系统中必须安装有Word的应用程序。否则也就无
法建立Java-COM桥，进而无法解析了。
解决jacob调用word处理doc文件的内存溢出问题
背景：
有个项目在系统后台用Jacob调用Word进程的API做doc文件处理。在进行压力测试的时候，发现运行一段时间后，内存占用奇高，大约7.4G。由于JVM占用内存限制为2G，因此怀疑多出来的内存应当是Jacob泄露的。
在网路上搜索解决办法，都是要这样调用
[java] view plaincopyprint?ComThread.InitSTA();
// do something
ComThread.Release();
ComThread.InitSTA();
// do something
ComThread.Release();
但是在项目中，使用了线程池进行DOC文件处理，也就是同一时间，会有多个WORD进程在跑，使用ComThread.InitSTA();之后，Jacob仅允许线程池里面的一个线程执行，其他线程都被锁住。
最后修改成ComThread.InitMTA(true);来初始化，经过24小时压力测试，可以同时有多个WORD进程运行，另外也解决了Jacob内存溢出问题。
使用JACOB进行Word编程示例
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.ComThread;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import com.sun.star.uno.RuntimeException;
import org.apache.log4j.Logger;
/**
* @date : 2011-5-5
* @description : 利用jacob插件生成word 文件！
* @author weich
*/
public class DOCWriter {
/**
* @date : 2011-5-5
* 日志记录器
*/
private static Logger logger = Logger.getLogger(DOCWriter.class);
/**
* @date : 2011-5-5
* word文档
* 在本类中有两种方式可以进行文档的创建,<br>
* 第一种调用 createNewDocument
* 第二种调用 openDocument
*/
private Dispatch document = null;
/**
* @date : 2011-5-5
* word运行程序对象
*/
private ActiveXComponent word = null;
/**
* @date : 2011-5-5
* 所有word文档
*/
private Dispatch documents = null;
/**
* @date :
* Selection 对象 代表窗口或窗格中的当前所选内容。 所选内容代表文档中选定（或突出显示）的区域，如果文档中没有选定任何内容，则代表插入点。
* 每个文档窗格只能有一个Selection 对象，并且在整个应用程序中只能有一个活动的 Selection 对象。
*/
private Dispatch selection = null;
/**
* @date :
* Range 对象 代表文档中的一个连续区域。 每个 Range 对象由一个起始字符位置和一个终止字符位置定义。
* 说明：与书签在文档中的使用方法类似，Range 对象在 Visual Basic 过程中用来标识文档的特定部分。
* 但与书签不同的是，Range对象只在定义该对象的过程运行时才存在。
* Range对象独立于所选内容。也就是说，您可以定义和处理一个范围而无需更改所选内容。还可以在文档中定义多个范围，但每个窗格中只能有一个所选内容。
*/
private Dispatch range = null;
/**
* @date :
* PageSetup 对象 该对象包含文档的所有页面设置属性（如左边距、下边距和纸张大小）。
*/
private Dispatch pageSetup = null;
/**
* @date :
* 文档中的所有表格对象
*/
private Dispatch tables = null;
/**
* @date :
* 一个表格对象
*/
private Dispatch table = null;
private static Boolean isUsed=false;
/**
* @date :
* 表格所有行对象
*/
private Dispatch rows = null;
/**
* @date :
* 表格所有列对象
*/
private Dispatch cols = null;
/**
* @date :
* 表格指定行对象
*/
private Dispatch row = null;
/**
* @date :
* 表格指定列对象
* */
private Dispatch col = null;
/**
* @date :
* 表格中指定的单元格
*/
private Dispatch cell = null;
/**
* @date :
* 字体
*/
private Dispatch font = null;
/**
* @date :
* 对齐方式
*/
private Dispatch alignment = null;
/**
* @date :
* 特殊字符集合
*/
private static String[] speCharArray = {" ", "&"};
/**
* @date :
* 与特殊字符对应的真实字符
*/
private static String[] parCharArray = {" ", "&"};
/**
* @date :
* 构造方法
*/
public DOCWriter() {
ComThread.InitSTA();
if (this.word == null) {
/* 初始化应用所要用到的对象实例 */
this.word = new ActiveXComponent("Word.Application");
/* 设置Word文档是否可见，true-可见false-不可见 */
this.word.setProperty("Visible", new Variant(false));
/* 禁用宏 */
this.word.setProperty("AutomationSecurity", new Variant(3));
}
if (this.documents == null) {
this.documents = word.getProperty("Documents").toDispatch();
}
}
//插入上标值;10.5是五号，9是小五，8是六号，12是小四
public void insertSuperValue(boolean isHomeKey, String toFindText,String text,double size){
boolean isFind=this.find(toFindText);//查找替换字段;
if(!"".equals(text) && null != text){
text = this.replaceSpeChar(text); //替换字符串中含有的特殊字符
}
if(isFind){
List<String> list=new ArrayList<String>();
int start=text.indexOf("<su");
String supOrSub="p";
int i = -1;
int j = -1;
try {
synchronized (isUsed) {
if(isUsed){
isUsed=false;
return;
}else{
isUsed=true;
while(start != -1) {
supOrSub=text.substring(start+3,start+4);
i = text.indexOf("<su"+supOrSub+">");
j = text.indexOf("</su"+supOrSub+">");
if(i!=0){
list.add(text.substring(0,i));
}
if("p".equals(supOrSub)){//如果当前为上标的话;
list.add("Sup:"+text.substring(i+5,j));
}else if("b".equals(supOrSub)){
list.add("Sub:"+text.substring(i+5,j));
}
text = text.substring(j+6);
start = text.indexOf("<su");
if(start==-1){
if(text.length()>0){
list.add(text);
text="";
}
}
}
isUsed=false;
}
}
if(list.size()<=0){
list.add(text);
//text="";
}
if(list!=null && list.size()>0){
for(int s=0;s<list.size();s++){
String dataStr=list.get(s);
if(dataStr.startsWith("Su")){
String supState=dataStr.substring(2,3);
if("p".equals(supState)){
String supStr=dataStr.substring(4);
this.insertSupText(supStr);//插入数据;
this.doSupValue(supStr,true);//设置上标;
this.font = Dispatch.get(selection,"Font").toDispatch();
Dispatch.put(font, "Size", size);
this.moveRight(1);
}else if("b".equals(supState)){
String subStr=dataStr.substring(4);
this.insertSupText(subStr);//插入数据;
this.doSubValue_fontsize(subStr,true,toFindText);//设置下标;
this.font = Dispatch.get(selection,"Font").toDispatch();
Dispatch.put(font, "Size", size);
this.moveRight(1);
}else{
this.insertSupText(dataStr);
//取消上下标格式化;
this.doSupValue(dataStr,false);
this.doSubValue_fontsize(dataStr,false,toFindText);
this.moveRight(1);
}
}else{
this.insertSupText(dataStr);
//取消上下标格式化;
this.doSupValue(dataStr,false);
this.doSubValue_fontsize(dataStr,false,toFindText);
this.moveRight(1);
}
if(isHomeKey){//返回顶部起点;
if(s==list.size()-1){
this.moveStart();
}
}
}
}
} catch (Exception e) {
new RuntimeException("插入上下标数据时出错");
}finally{
isUsed=false;
}
}
}
// 设置是否在前台打开 word 程序 ，
public void setVisible(boolean visible) {
//word.setProperty("Visible", new Variant(visible));
// 这一句作用相同
Dispatch.put(word, "Visible", new Variant(visible));
}
//插入上标值;
public void insertSuper(boolean isHomeKey,String text){
List<String> list=new ArrayList<String>();
text=(text==null)?"":text;
text=text.replace("<SUB>", "<sub>");
text=text.replace("</SUB>","</sub>");
text=text.replace("<SUP>","<sup>");
text=text.replace("</SUP>","</sup>");
text = this.replaceSpeChar(text); //替换字符串中含有的特殊字符
int start=text.indexOf("<su");
String supOrSub="p";
int i = -1;
int j = -1;
try {
synchronized (isUsed) {
if(isUsed){
isUsed=false;
return;
}else{
isUsed=true;
while(start != -1) {
supOrSub=text.substring(start+3,start+4);
i = text.indexOf("<su"+supOrSub+">");
j = text.indexOf("</su"+supOrSub+">");
if(i!=0){
list.add(text.substring(0,i));
}
if("p".equals(supOrSub)){//如果当前为上标的话;
list.add("Sup:"+text.substring(i+5,j));
}else if("b".equals(supOrSub)){
list.add("Sub:"+text.substring(i+5,j));
}
text = text.substring(j+6);
start = text.indexOf("<su");
if(start==-1){
if(text.length()>0){
list.add(text);
text="";
}
}
}
if(start==-1) {
if(text.length()>0){
list.add(text);
text="";
}
}
isUsed=false;
}
}
if(list.size()<=0){
list.add(text);
text="";
}
if(list!=null && list.size()>0){
for(int s=0;s<list.size();s++){
String dataStr=list.get(s);
if(dataStr.startsWith("Su")){
String supState=dataStr.substring(2,3);
if("p".equals(supState)){
String supStr=dataStr.substring(4);
this.insertSupText(supStr);//插入数据;
this.doSupValue(supStr,true);//设置上标;
this.font = Dispatch.get(selection,"Font").toDispatch();
Dispatch.put(font, "Size", 10.5);
this.moveRight(1);
}else if("b".equals(supState)){
String subStr=dataStr.substring(4);
this.insertSupText(subStr);//插入数据;
this.doSubValue(subStr,true);//设置下标;
this.font = Dispatch.get(selection,"Font").toDispatch();
Dispatch.put(font, "Size", 10.5);
this.moveRight(1);
}
}else{
this.insertSupText(dataStr);
//取消上下标格式化;
this.doSupValue(dataStr,false);
this.doSubValue(dataStr,false);
if(!"".equals(dataStr)){
this.moveRight(1);
}
}
if(isHomeKey){//返回顶部起点;
if(s==list.size()-1){
this.moveStart();
}
}
}
}
} catch (Exception e) {
new RuntimeException("插入上下标字符串时出错!");
}finally{
isUsed=false;
}
}
/**
* @date :
* 设置页面方向和页边距
* @param orientation 可取值0或1，分别代表横向和纵向
* @param leftMargin 左边距的值
* @param rightMargin 右边距的值
* @param topMargin 上边距的值
* @param buttomMargin 下边距的值
*/
public void setPageSetup(int orientation, int leftMargin, int rightMargin, int topMargin, int buttomMargin) {
logger.debug("设置页面方向和页边距...");
if (this.pageSetup == null) {
this.getPageSetup();
}
Dispatch.put(pageSetup, "Orientation", orientation);
Dispatch.put(pageSetup, "LeftMargin", leftMargin);
Dispatch.put(pageSetup, "RightMargin", rightMargin);
Dispatch.put(pageSetup, "TopMargin", topMargin);
Dispatch.put(pageSetup, "BottomMargin", buttomMargin);
}
//格式化上标值;
public void doSupValue(String text,boolean isTrue){
this.font = Dispatch.get(selection,"Font").toDispatch();
Dispatch.put(font, "Size", 10.5);
Dispatch.put(font, "Superscript", new Variant(isTrue));
}
//格式化下标值;
public void doSubValue(String text,boolean isTrue){
this.font = Dispatch.get(selection,"Font").toDispatch();
Dispatch.put(font, "Size", 10.5);
Dispatch.put(font, "Subscript", new Variant(isTrue));
}
//格式化下标值;
public void doSubValue_fontsize(String text,boolean isTrue,String fieldName){
this.font = Dispatch.get(selection,"Font").toDispatch();
float size = 0.0f;
if("SampleNamefp".equals(fieldName) || "ModelSizefp".equals(fieldName)){//报告首页加大字号
size=15.5f;
}else if("SampleName".equals(fieldName) || "Brand".equals(fieldName)||"ModelSize".equals(fieldName)||"modelSize".equals(fieldName)||"sampleBatch".equals(fieldName)||"ModelSizeZp".equals(fieldName)||"testStandard".equals(fieldName)||"sampleName".equals(fieldName)){
size=10.5f;
}else{
size=9f;
}
Dispatch.put(font, "Size", size);
Dispatch.put(font, "Subscript", new Variant(isTrue));
}
/**
* @date :
* 打开文件
* @param inputDoc 要打开的文件，全路径
* @return Dispatch 打开的文件
*/
public Dispatch openDocument(String inputDoc) {
logger.debug("打开Word文档...");
this.document = Dispatch.call(documents, "Open", inputDoc).toDispatch();
this.getSelection();
this.getRange();
this.getAlignment();
this.getFont();
this.getPageSetup();
return this.document;
}
/**
* @date :
* 创建新的文件
* @return Dispache 返回新建文件
*/
public Dispatch createNewDocument() {
logger.debug("创建新的文件...");
this.document = Dispatch.call(documents, "Add").toDispatch();
this.getSelection();
this.getRange();
this.getPageSetup();
this.getAlignment();
this.getFont();
return this.document;
}
/**
* @date :
* 选定内容
* @return Dispatch 选定的范围或插入点
*/
public Dispatch getSelection() {
logger.debug("获取选定范围的插入点...");
this.selection = word.getProperty("Selection").toDispatch();
return this.selection;
}
/**
* @date :
* 获取当前Document内可以修改的部分<p><br>
* 前提条件：选定内容必须存在
* @return 可修改的对象
*/
public Dispatch getRange() {
logger.debug("获取当前Document内可以修改的部分...");
this.range = Dispatch.get(this.selection, "Range").toDispatch();
return this.range;
}
/**
* @date :
* 获得当前文档的文档页面属性
*/
public Dispatch getPageSetup() {
logger.debug("获得当前文档的文档页面属性...");
if (this.document == null) {
logger.warn("document对象为空...");
return this.pageSetup;
}
this.pageSetup = Dispatch.get(this.document, "PageSetup").toDispatch();
return this.pageSetup;
}
/**
* @date :
* 把选定内容或插入点向上移动
* @param count 移动的距离
*/
public void moveUp(int count) {
logger.debug("把选定内容或插入点向上移动...");
for (int i = 0; i < count; i++) {
Dispatch.call(this.selection, "MoveUp");
}
}
/**
* @date :
* 把选定内容或插入点向下移动
* @param count 移动的距离
*/
public void moveDown(int count) {
logger.debug("把选定内容或插入点向下移动...");
for (int i = 0; i < count; i++) {
Dispatch.call(this.selection, "MoveDown");
}
}
/**
* @date :
* 把选定内容或插入点向左移动
* @param count 移动的距离
*/
public void moveLeft(int count) {
logger.debug("把选定内容或插入点向左移动...");
for (int i = 0; i < count; i++) {
Dispatch.call(this.selection, "MoveLeft");
}
}
/**
* @date :
* 把选定内容或插入点向右移动
* @param count 移动的距离
*/
public void moveRight(int count) {
logger.debug("把选定内容或插入点向右移动...");
for (int i = 0; i < count; i++) {
Dispatch.call(this.selection, "MoveRight");
}
}
/**
* @date :
* 回车键
*/
public void enterDown(int count) {
logger.debug("按回车键...");
for (int i = 0; i < count; i++) {
Dispatch.call(this.selection, "TypeParagraph");
}
}
/**
* @date :
* 把插入点移动到文件首位置
*/
public void moveStart() {
logger.debug("把插入点移动到文件首位置...");
Dispatch.call(this.selection, "HomeKey", new Variant(6));
}
/**
* @date :
* 从选定内容或插入点开始查找文本
* @param toFindText 要查找的文本
* @return boolean true-查找到并选中该文本，false-未查找到文本
*/
public boolean find(String toFindText) {
logger.debug("从选定内容或插入点开始查找文本" + " 要查找内容： " + toFindText);
/* 从selection所在位置开始查询 */
Dispatch find = Dispatch.call(this.selection, "Find").toDispatch();
/* 设置要查找的内容 */
Dispatch.put(find, "Text", toFindText);
/* 向前查找 */
Dispatch.put(find, "Forward", "True");
/* 设置格式 */
Dispatch.put(find, "Format", "True");
/* 大小写匹配 */
Dispatch.put(find, "MatchCase", "True");
/* 全字匹配 */
//Dispatch.put(find,"MatchWholeWord","True");
/* 查找并选中 */
return Dispatch.call(find, "Execute").getBoolean();
}
/**
* @date :
* 把选定内容替换为设定文本
* @param newText 替换为文本
*/
public void replace(String newText) {
logger.debug("把选定内容替换为设定文本...");
/* 设置替换文本 */
Dispatch.put(this.selection, "Text", newText);
}
/**
* @date :
* 全局替换
* @param oldText 要替换的文本
* @param replaceObj 替换为文本
*/
public void replaceAll(String oldText, Object replaceObj) {
logger.debug("全局替换...");
/* 移动到文件开头 */
moveStart();
/* 表格替换方式 */
String newText = (String) replaceObj;
/* 图片替换方式 */
if (oldText.indexOf("image") != -1 || newText.lastIndexOf(".bmp") != -1
|| newText.lastIndexOf(".jpg") != -1 || newText.lastIndexOf(".gif") != -1) {
while (find(oldText)) {
insertImage(newText);
Dispatch.call(this.selection, "MoveRight");
}
/* 正常替换方式 */
} else {
while (find(oldText)) {
replace(newText);
Dispatch.call(this.selection, "MoveRight");
}
}
}
/**
* @date :
* 插入图片
* @param imagePath 图片文件（全路径）
*/
public void insertImage(String imagePath) {
logger.debug("插入图片...");
Dispatch.call(this.selection, "TypeParagraph");
Dispatch.call(Dispatch.get(this.selection, "InLineShapes").toDispatch(), "AddPicture", imagePath);
}
/**
* @date :
* 合并表格
*
* @param tableIndex 表格起始点
* @param fstCellRowIdx 开始行
* @param fstCellColIdx 开始列
* @param secCellRowIdx 结束行
* @param secCellColIdx 结束列
*/
public void mergeCell(int tableIndex, int fstCellRowIdx, int fstCellColIdx, int secCellRowIdx, int secCellColIdx) {
logger.debug("合并单元格...");
if (this.table == null) {
table = this.getTable(tableIndex);
}
Dispatch fstCell = Dispatch.call(table, "Cell", new Variant(fstCellRowIdx),
new Variant(fstCellColIdx)).toDispatch();
Dispatch secCell = Dispatch.call(table, "Cell", new Variant(secCellRowIdx),
new Variant(secCellColIdx)).toDispatch();
Dispatch.call(fstCell, "Merge", secCell);
}
/**
* @date :
* 想Table对象中插入数值
* List.size()为表格的总行数
* String[]的length属性值应该与所创建的表格列数相同
* @param list 数据内容
*/
public void insertToTable(List<String[]> list) {
logger.debug("向Table对象中插入数据...");
if (list == null || list.size() <= 0) {
logger.warn("写出数据集为空...");
return;
}
if (this.table == null) {
logger.warn("table对象为空...");
return;
}
for (int i = 0; i < list.size(); i++) {
String[] strs = list.get(i);
for (int j = 0; j < strs.length; j++) {
/* 遍历表格中每一个单元格，遍历次数与所要填入的内容数量相同 */
Dispatch cel = this.getCell(i + 1, j + 1);
/* 选中此单元格 */
Dispatch.call(cel, "Select");
/* 写出内容到此单元格中 */
Dispatch.put(this.selection, "Text", strs[j]);
/* 移动游标到下一个位置 */
}
this.moveDown(1);
}
this.enterDown(1);
}
/**
* @date :
* 在文档中正常插入文字内容
* @param list 数据内容
*/
public void insertToDocument(List<String> list) {
logger.debug("向Document对象中插入数据...");
if (list == null || list.size() <= 0) {
logger.warn("写出数据集为空...");
return;
}
if (this.document == null) {
logger.warn("document对象为空...");
return;
}
for (String str : list) {
/* 写出至word中 */
//this.applyListTemplate(3, 2);
Dispatch.put(this.selection, "Text", str);
//this.moveRight(1);
this.moveDown(1);
this.moveUp(1);
//this.enterDown(1);
}
}
/**
* @date :
* 在文档中正常插入文字内容
*/
public void insertText(String str) {
logger.debug("向Document对象中插入数据...");
if (str == null || str == "") {
logger.warn("写出数据集为空...");
return;
}
if (this.document == null) {
logger.warn("document对象为空...");
return;
}
Dispatch.put(this.selection, "Text", str);
this.moveRight(1);
}
/**
* @date :
* 创建新的表格
*
* @param rowCount 行数
* @param colCount 列数
* @param width 边框数值 0浅色1深色
* @return 新创建的表格对象
*/
public Dispatch createNewTable(int rowCount, int colCount, int width) {
logger.debug("创建新的表格...");
if (this.tables == null) {
this.getTables();
}
this.getRange();
if (rowCount > 0 && colCount > 0) {
this.table = Dispatch.call(this.tables, "Add", this.range, new Variant(rowCount),
new Variant(colCount), new Variant(width)).toDispatch();
}
/* 返回新创建表格 */
return this.table;
}
/**
* @date :
* @author :
* @description : 创建表格
* @modify : 修改人 时间 简单描述
* @param pos
* @param numCols
* @param numRows
*/
public void createTable(String pos, int numCols, int numRows) {
if (find(pos)) {
Dispatch tables1 = Dispatch.get(this.document, "Tables").toDispatch();
Dispatch range1 = Dispatch.get(selection, "Range").toDispatch();
@SuppressWarnings("unused")
Dispatch newTable = Dispatch.call(tables1, "Add", range1, new Variant(numRows),
new Variant(numCols)).toDispatch();
Dispatch.call(selection, "MoveRight");
}
}
/**
* @date :
* @author :
* @description : 增加一行
* @modify : 修改人 时间 简单描述
* @param tableIndex
*/
public void addRow(int tableIndex) {
Dispatch tables1 = Dispatch.get(this.document, "Tables").toDispatch();
//要填充的表格
Dispatch table1 = Dispatch.call(tables1, "Item", new Variant(tableIndex)).toDispatch();
//表格的所有行
Dispatch rows1 = Dispatch.get(table1, "Rows").toDispatch();
Dispatch.call(rows1, "Add");
}
/**
* @date :
* @author :
* @description : 在指定行前面增加一行
* @modify : 修改人 时间 简单描述
* @param tableIndex
* @param rowIndex
*/
//在指定行前面增加一行
public void addTableRow(int tableIndex, int rowIndex) {
//要填充的表格
if (this.table == null) {
this.table = this.getTable(tableIndex);
}
//表格的所有行
this.row = this.getTableRow(rowIndex);
Dispatch.call(rows, "Add", new Variant(row));
}
/**
* @date :
* @author :
* @description : 在第一行前增加一行
* @modify : 修改人 时间 简单描述
* @param tableIndex
*/
public void addFirstTableRow(int tableIndex) {
if (this.table == null) {
table = this.getTable(tableIndex);
}
//表格的所有行
Dispatch rows1 = Dispatch.get(table, "Rows").toDispatch();
Dispatch row1 = Dispatch.get(rows1, "First").toDispatch();
Dispatch.call(rows1, "Add", new Variant(row1));
}
/**
* @date :
* @author :
* @description : 在最后一行前增加一行
* @modify : 修改人 时间 简单描述
* @param tableIndex
*/
public void addLastTableRow(int tableIndex) {
if (this.table == null) {
table = this.getTable(tableIndex);
}
//表格的所有行
Dispatch rows1 = Dispatch.get(table, "Rows").toDispatch();
Dispatch row1 = Dispatch.get(rows1, "Last").toDispatch();
Dispatch.call(rows1, "Add", new Variant(row1));
}
/**
* @date :
* @author :
* @description : 增加一列
* @modify : 修改人 时间 简单描述
* @param tableIndex
*/
public void addCol(int tableIndex) {
if(this.table == null) {
table = this.getTable(tableIndex);
}
//表格的所有行
Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
Dispatch.call(cols1, "Add").toDispatch();
Dispatch.call(cols1, "AutoFit");
}
/**
* @date :
* @author :
* @description : 在指定列前面增加表格的列
* @modify : 修改人 时间 简单描述
* @param tableIndex
* @param colIndex
*/
public void addTableCol(int tableIndex, int colIndex) {
if (this.table == null) {
table = this.getTable(tableIndex);
}
//表格的所有行
Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
Dispatch col1 = Dispatch.call(cols1, "Item", new Variant(colIndex)).toDispatch();
Dispatch.call(cols1, "Add", col1).toDispatch();
Dispatch.call(cols1, "AutoFit");
}
/**
* @date :
* @author :
* @description : 在第一列之前增加一列
* @modify : 修改人 时间 简单描述
* @param tableIndex
*/
public void addFirstTableCol(int tableIndex) {
if (this.table == null) {
table = this.getTable(tableIndex);
}
// 表格的所有行
Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
Dispatch col1 = Dispatch.get(cols1, "First").toDispatch();
Dispatch.call(cols1, "Add ", col1).toDispatch();
Dispatch.call(cols1, "AutoFit");
}
/**
* @date :
* @author :
* @description : 在最后一列前增加一列
* @modify : 修改人 时间 简单描述
* @param tableIndex
*/
public void addLastTableCol(int tableIndex) {
if (this.table == null) {
table = this.getTable(tableIndex);
}
//表格的所有行
Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
Dispatch col1 = Dispatch.get(cols1, "Last").toDispatch();
Dispatch.call(cols1, "Add", col1).toDispatch();
Dispatch.call(cols1, "AutoFit");
}
/**
* @date :
* 获取Document对象中的所有Table对象
* @return 所有Table对象
*/
public Dispatch getTables() {
logger.debug("获取所有表格对象...");
if (this.document == null) {
logger.warn("document对象为空...");
return this.tables;
}
this.tables = Dispatch.get(this.document, "Tables").toDispatch();
return this.tables;
}
/**
* @date :
* 获取Document中Table的数量
* @return 表格数量
*/
public int getTablesCount() {
logger.debug("获取文档中表格数量...");
if (this.tables == null) {
this.getTables();
}
return Dispatch.get(tables, "Count").getInt();
}
/**
* @date :
* 获取指定序号的Table对象
* @param tableIndex Table序列
* @return
*/
public Dispatch getTable(int tableIndex) {
logger.debug("获取指定表格对象...");
if (this.tables == null) {
this.getTables();
}
if (tableIndex >= 0) {
this.table = Dispatch.call(this.tables, "Item", new Variant(tableIndex)).toDispatch();
}
return this.table;
}
/**
* @date :
* 获取表格的总列数
* @return 总列数
*/
public int getTableColumnsCount() {
logger.debug("获取表格总行数...");
if (this.table == null) {
logger.warn("table对象为空...");
return 0;
}
return Dispatch.get(this.cols, "Count").getInt();
}
/**
* @date :
* 获取表格的总行数
* @return 总行数
*/
public int getTableRowsCount() {
logger.debug("获取表格总行数...");
if (this.table == null) {
logger.warn("table对象为空...");
return 0;
}
return Dispatch.get(this.rows, "Count").getInt();
}
/**
* @date :
* 获取表格列对象
* @return 列对象
*/
public Dispatch getTableColumns() {
logger.debug("获取表格行对象...");
if (this.table == null) {
logger.warn("table对象为空...");
return this.cols;
}
this.cols = Dispatch.get(this.table, "Columns").toDispatch();
return this.cols;
}
/**
* @date :
* 获取表格的行对象
* @return 总行数
*/
public Dispatch getTableRows() {
logger.debug("获取表格总行数...");
if (this.table == null) {
logger.warn("table对象为空...");
return this.rows;
}
this.rows = Dispatch.get(this.table, "Rows").toDispatch();
return this.rows;
}
/**
* @date :
* 获取指定表格列对象
* @return 列对象
*/
public Dispatch getTableColumn(int columnIndex) {
logger.debug("获取指定表格行对象...");
if (this.cols == null) {
this.getTableColumns();
}
if (columnIndex >= 0) {
this.col = Dispatch.call(this.cols, "Item", new Variant(columnIndex)).toDispatch();
}
return this.col;
}
/**
* @date :
* 获取表格中指定的行对象
* @param rowIndex 行序号
* @return 行对象
*/
public Dispatch getTableRow(int rowIndex) {
logger.debug("获取指定表格总行数...");
if (this.rows == null) {
this.getTableRows();
}
if (rowIndex >= 0) {
this.row = Dispatch.call(this.rows, "Item", new Variant(rowIndex)).toDispatch();
}
return this.row;
}
/**
* @date :
* 自动调整表格
*/
public void autoFitTable() {
logger.debug("自动调整表格...");
int count = this.getTablesCount();
for (int i = 0; i < count; i++) {
Dispatch table1 = Dispatch.call(tables, "Item", new Variant(i + 1)).toDispatch();
Dispatch cols1 = Dispatch.get(table1, "Columns").toDispatch();
Dispatch.call(cols1, "AutoFit");
}
}
/**
* @date :
* 获取当前文档中，表格中的指定单元格
* @return 指定单元格对象
*/
public Dispatch getCell(int cellRowIdx, int cellColIdx) {
logger.debug("获取当前文档中，表格中的指定单元格...");
if (this.table == null) {
logger.warn("table对象为空...");
return this.cell;
}
if (cellRowIdx >= 0 && cellColIdx >= 0) {
this.cell = Dispatch.call(this.table, "Cell", new Variant(cellRowIdx),
new Variant(cellColIdx)).toDispatch();
}
return this.cell;
}
/**
* @date : 2011-8-16 下午05:04:40
* @author : lvchq
* @description : 获取表格中的值
* @modify : 修改人 时间 简单描述
* @param tableIndex
* @param cellRowIdx 单元格所在行
* @param cellColIdx 单元格所在列
* @return
*/
public String getCellData(int tableIndex, int cellRowIdx, int cellColIdx) {
logger.debug("获取当前文档中，表格中的指定单元格...");
if (this.table == null) {
//lvchq修改 20111013 如果table为空需要初始化table
table = this.getTable(tableIndex);
}
Dispatch cellDis = Dispatch.call(table, "Cell", new Variant(cellRowIdx), new Variant(cellColIdx)).toDispatch();
Dispatch rangeDis = Dispatch.get(cellDis, "Range").toDispatch();
return Dispatch.get(rangeDis, "Text").toString();
}
/**
* @date :
* 设置文档标题
* @param title 标题内容
*/
public void setTitle(String title) {
logger.debug("设置文档标题...");
if (title == null || "".equals(title)) {
logger.warn("文档标题为空...");
return;
}
Dispatch.call(this.selection, "TypeText", title);
}
/**
* @date :
* 设置当前表格线的粗细
* @param width 其中width大于1小于13,如果是0，就代表没有框
*/
public void setTableBorderWidth(int width) {
logger.debug("设置当前表格线的粗细...");
if (this.table == null) {
logger.warn("table对象为空...");
return;
}
/*
* 设置表格线的粗细 1：代表最上边一条线 2：代表最左边一条线 3：最下边一条线 4：最右边一条线 5：除最上边最下边之外的所有横线
* 6：除最左边最右边之外的所有竖线 7：从左上角到右下角的斜线 8：从左下角到右上角的斜线
*/
Dispatch borders = Dispatch.get(table, "Borders").toDispatch();
Dispatch border = null;
for (int i = 1; i < 7; i++) {
border = Dispatch.call(borders, "Item", new Variant(i)).toDispatch();
if (width != 0) {
Dispatch.put(border, "LineWidth", new Variant(width));
Dispatch.put(border, "Visible", new Variant(false));
} else if (width == 0) {
Dispatch.put(border, "Visible", new Variant(false));
}
}
}
/**
* @date :
* 对当前selection设置项目符号和编号
* @param tabIndex
* 1: 项目编号
* 2: 编号
* 3: 多级编号
* 4: 列表样式
* @param index
* 0:表示没有 ,其它数字代表的是该Tab页中的第几项内容
*/
public void applyListTemplate(int tabIndex, int index) {
logger.debug("对当前selection设置项目符号和编号...");
/* 取得ListGalleries对象列表 */
Dispatch listGalleries = Dispatch.get(this.word, "ListGalleries").toDispatch();
/* 取得列表中一个对象 */
Dispatch listGallery = Dispatch.call(listGalleries, "Item", new Variant(tabIndex)).toDispatch();
Dispatch listTemplates = Dispatch.get(listGallery, "ListTemplates").toDispatch();
if (this.range == null) {
this.getRange();
}
Dispatch listFormat = Dispatch.get(this.range, "ListFormat").toDispatch();
Dispatch.call(listFormat, "ApplyListTemplate", Dispatch.call(listTemplates, "Item",
new Variant(index)), new Variant(true), new Variant(1), new Variant(0));
}
/**
* @date :
* 增加文档目录
* 目前采用固定参数方式，以后可以动态进行调整
*/
public void addTablesOfContents() {
/* 取得ActiveDocument、TablesOfContents、range对象 */
Dispatch activeDocument = word.getProperty("ActiveDocument").toDispatch();
Dispatch tablesOfContents = Dispatch.get(activeDocument, "TablesOfContents").toDispatch();
Dispatch range1 = Dispatch.get(this.selection, "Range").toDispatch();
/* 增加目录 */
Dispatch.call(tablesOfContents, "Add", range1, new Variant(true), new Variant(1),
new Variant(3), new Variant(true), new Variant(""), new Variant(true), new Variant(true));
}
/**
* @date :
* 设置当前Selection 位置方式
*/
public void setAlignment(int alignmentType) {
logger.debug("设置当前Selection 位置方式...");
if (this.alignment == null) {
this.getAlignment();
}
Dispatch.put(this.alignment, "Alignment", alignmentType);
}
/**
* @date :
* 获取当前选择区域的对齐方式
* @return 对其方式对象
*/
public Dispatch getAlignment() {
logger.debug("获取当前选择区域的对齐方式...");
if (this.selection == null) {
this.getSelection();
}
this.alignment = Dispatch.get(this.selection, "ParagraphFormat").toDispatch();
return this.alignment;
}
/**
* @date :
* 获取字体对象
*
* @return 字体对象
*/
public Dispatch getFont() {
logger.debug("获取字体对象...");
if (this.selection == null) {
this.getSelection();
}
this.font = Dispatch.get(this.selection, "Font").toDispatch();
return this.font;
}
/**
* @date :
* 设置选定内容的字体 注：在调用此方法前，选定区域对象selection必须存在
* @param fontName 字体名称，例如 "宋体"
* @param isBold 粗体
* @param isItalic 斜体
* @param isUnderline 下划线
* @param rgbColor 颜色，例如"255,255,255"
* @param fontSize 字体大小
* @param Scale 字符间距，百分比值。例如 70代表缩放为70%
*/
public void setFontScale(String fontName, boolean isBold, boolean isItalic, boolean isUnderline,
String rgbColor, int Scale, int fontSize,boolean isSub,boolean isSup) {
logger.debug("设置字体...");
if(!"".equals(fontName))
Dispatch.put(this.font, "Name", fontName);
Dispatch.put(this.font, "Bold", isBold);
Dispatch.put(this.font, "Italic", isItalic);
Dispatch.put(this.font, "Underline", isUnderline);
if(!"".equals(rgbColor))
Dispatch.put(this.font, "Color", rgbColor);
if(!"".equals(Scale))
Dispatch.put(this.font, "Scaling", Scale);
Dispatch.put(this.font, "Size", fontSize);
Dispatch.put(this.font, "Subscript", isSub);
Dispatch.put(this.font, "Superscript", isSup);
}
/**
* @date :
* 设置上下标
* isSub下标
* isSup上标
*
*/
public void setScale(boolean isSub, boolean isSup) {
logger.debug("设置字体...");
Dispatch.put(this.font, "Subscript", isSub);
Dispatch.put(this.font, "Superscript", isSup);
}
/**
* @date :
* 保存文件
* @param outputPath 输出文件（包含路径）
*/
public void saveAs(String outputPath) {
logger.debug("保存文件...");
if (this.document == null) {
logger.warn("document对象为空...");
return;
}
if (outputPath == null || "".equals(outputPath)) {
logger.warn("文件保存路径为空...");
return;
}
Dispatch.call(this.document, "SaveAs", outputPath);
}
/**
* @date :
* @author :
* @description :
* @modify : 修改人 时间 简单描述
* @param htmlFile
*/
public void saveAsHtml(String htmlFile) {
Dispatch.invoke(this.document, "SaveAs", Dispatch.Method, new Object[]{htmlFile, new Variant(8)}, new int[1]);
}
/**
* @date :
* 关闭文件
*/
public void close() {
logger.debug("关闭文件...");
if (document == null) {
logger.warn("document对象为空...");
return;
}
Dispatch.call(document, "Close", new Variant(0));
}
/**
* @date :
* 列印word文件
*/
public void printFile() {
logger.debug("打印文件...");
if (document == null) {
logger.warn("document对象为空...");
return;
}
Dispatch.call(document, "PrintOut");
}
/**
* @date :
* 退出程序
*/
public void quit() {
logger.debug("退出程序");
word.invoke("Quit", new Variant[0]);
ComThread.Release();
}
//插入数据
public void insertSupText(String fieldValue){
String repaceText = fieldValue;
this.selection = Dispatch.get(word, "Selection").toDispatch();
this.replace(repaceText);
}
/**
* @date :
* @author :
* @description : 查找替换 包含上下标的判断
* @modify : 修改人 时间 简单描述
* @param fieldName
* @param fieldValue
*/
public void replaceTemplate(String fieldName, String fieldValue) {
this.moveStart();
String toFindText = fieldName;
String repaceText = fieldValue;
if (this.find(toFindText)) {
if ("".equals(repaceText)) {
this.replace(repaceText);
} else {
while (repaceText.indexOf("<SUP>") > 0 || repaceText.indexOf("<SUB>") > 0) {
int i = repaceText.indexOf("<SUP>");
int j = repaceText.indexOf("<SUB>");
if ((i < j && i > 0) || (j < 0 && i > 0)) {
this.find("tanwn"); //就是这两行胡乱试了一下竟然成了
this.replace("tanwn"); //可能是在两行之间进行了其他操作了
String firstText = repaceText.substring(0, i);
this.setScale(false, false);
this.insertText(firstText);
this.find("tanwn"); //就是这两行胡乱试了一下竟然成了
this.replace("tanwn"); //可能是在两行之间进行了其他操作了
String supText = repaceText.substring(i + 5, repaceText.indexOf("</SUP>"));
this.setScale(false, true);
this.insertText(supText);
repaceText = repaceText.substring(repaceText.indexOf("</SUP>") + 6, repaceText.length());
}
if ((i > j && j > 0) || (i < 0 && j > 0)) {
this.find("tanwn"); //就是这两行胡乱试了一下竟然成了
this.replace("tanwn"); //可能是在两行之间进行了其他操作了
String firstText = repaceText.substring(0, j);
this.setScale(false, false);
this.insertText(firstText);
this.find("tanwn"); //就是这两行胡乱试了一下竟然成了
this.replace("tanwn"); //可能是在两行之间进行了其他操作了
String subText = repaceText.substring(j + 5, repaceText.indexOf("</SUB>"));
this.setScale(true, false);
this.insertText(subText);
repaceText = repaceText.substring(repaceText.indexOf("</SUB>") + 6, repaceText.length());
}
}
repaceText = this.replaceSpeChar(repaceText); //替换字符串中含有的特殊字符
if (repaceText != "") {
this.find("tanwn"); //就是这两行胡乱试了一下竟然成了
this.replace("tanwn"); //可能是在两行之间进行了其他操作了
this.setScale(false, false);
this.insertText(repaceText);
}
}
}
}
/**
* @date : 2012-1-12 下午02:25:48
* @author : lvchq
* @description : 替换字符串中含有的特殊字符
* @modify : 修改人 时间 简单描述
* @param replaceText
* @return
*/
private String replaceSpeChar(String replaceText) {
for (int i = 0; i < speCharArray.length; i++) {
while (replaceText.indexOf(speCharArray[i]) != -1) {
int j = replaceText.indexOf(speCharArray[i]);
replaceText = replaceText.substring(0, j) + parCharArray[i]
+ replaceText.substring(j + speCharArray[i].length());
}
}
return replaceText;
}
/**
* @date :
* @author :
* @description : 根据数据库表获取字段和数据，替换模板
* @modify : 修改人 时间 简单描述
* @param tableName
* @param strWhere
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
* @throws SQLException
*/
@SuppressWarnings("unchecked")
// public void replaceTemplateByDB(String tableName, String strWhere)
// throws InstantiationException, IllegalAccessException, ClassNotFoundException, SQLException {
// DBTable db = new DBTable();
// List list = db.getDBTable(tableName, strWhere);
//
// for (int m = 0; m < list.size(); m++) {
// String[] str = (String[]) list.get(m);
// this.replaceTemplate(str[1], str[2]);
// }
// }
/**
* @date :
* @author :
* @description :
* @modify : 修改人 时间 简单描述
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
* @throws SQLException
*/
// public void createWord() throws InstantiationException, IllegalAccessException,
// ClassNotFoundException, SQLException {
// DOCWriter writer = new DOCWriter();
// String path = System.getProperty("user.dir");
// writer.openDocument(path + "/template/委托书.doc"); //打开模板
// String textName = "委托书" + new java.text.SimpleDateFormat("yyyymmddhhmmss")
// .format(new Date()).toString() + ".doc";
// writer.enterDown(1);
//
// //从数据库获取字段名称和数据,并进行替换
// writer.replaceTemplateByDB("EntrustForm", " where sampleid=00000000000000000013");
// //对于枚举值进行处理
// String fieldName = "SendWay00";
// String fieldValue = "获取值SendWay";
// writer.replaceTemplate(fieldName, fieldValue);
// fieldName = "IfRequire00";
// fieldValue = "获取值IfRequire";
// writer.replaceTemplate(fieldName, fieldValue);
// fieldName = "IfSecrecy00";
// fieldValue = "获取值IfSecrecy";
// writer.replaceTemplate(fieldName, fieldValue);
// fieldName = "IfRecover00";
// fieldValue = "获取值IfRecover";
// writer.replaceTemplate(fieldName, fieldValue);
// fieldName = "GetWay00";
// fieldValue = "获取值GetWay";
// writer.replaceTemplate(fieldName, fieldValue);
// writer.saveAs(path + "/template/" + textName);
// }
/**
* @date :
* @author :
* @description :
* @modify : 修改人 时间 简单描述
* @param args
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
* @throws SQLException
*/
// public static void main(String args[]) throws InstantiationException,
// IllegalAccessException, ClassNotFoundException, SQLException {
// DOCWriter writer = new DOCWriter();
// String path = System.getProperty("user.dir");
// writer.openDocument(path + "/template/委托书.doc"); //打开模板
// String textName = new java.text.SimpleDateFormat("yyyymmddhhmmss").format(new Date()).toString() + ".doc";
// writer.enterDown(1);
//
// //测试，查找替换，包含上下标的判断
// String fieldName = "登记表_编号";
// String fieldValue = "获取值";
// writer.replaceTemplate(fieldName, fieldValue);
// //从数据库获取字段名称和数据,并进行替换
// writer.replaceTemplateByDB("EntrustForm", " where sampleid=00000000000000000013");
//
// /---------上侧是上下标的研究，成功了，现在下面研究动态输出表格-----------//
// List<String[]> listTable = new ArrayList<String[]>();
// for (int i = 0; i < 10; i++) {
// String str[] = new String[4];
// for (int j = 0; j < 4; j++) {
// str[j] = "第几行第几列" + String.valueOf(j);
// }
// listTable.add(str);
// }
// writer.setFontScale("幼圆", true, true, true, "1,1,1,1", 70, 14, true, true);
// for (int i = 0; i < 10; i++) {
// writer.addTableRow(1, 3);
// }
// writer.find("Part"); //移动光标
// writer.moveRight(3);
// for (int i = 0; i < listTable.size(); i++) {
// String[] strs = listTable.get(i);
// for (int j = 0; j < strs.length; j++) {
// writer.insertText(strs[j]);
// writer.moveRight(1);
// }
// writer.moveRight(1);
// }
//
// writer.saveAs(path + "/template/" + textName);
// }
//
/**
* @date : 2011-8-9 上午10:39:15
* @author : lvchq
* @description : 在指定的表格里填入内容
* @modify : 修改人 时间 简单描述
* @param tableIndex 表格起始点
* @param cellRowIdx 第几行
* @param cellColIdx 第几列
* @param txt 内容字符串
*/
public void putTxtToCell(int tableIndex, int cellRowIdx, int cellColIdx, String txt) {
if (this.table == null) {
table = this.getTable(tableIndex);
}
Dispatch selCell = Dispatch.call(table, "Cell", new Variant(cellRowIdx), new Variant(cellColIdx)).toDispatch();
Dispatch.call(selCell, "Select");
Dispatch.put(selection, "Text", txt);
}
/**
* @date :
* 在指定的表格里填入内容
* @param tableIndex 表格起始点
* @param cellRowIdx 第几列
* @param cellColIdx 第几栏
* @param txt 内容字符串数组
*/
@SuppressWarnings("unchecked")
public void putTxtToCell(Dispatch pfont, Dispatch palignment,
int tableIndex, int cellRowIdx, int cellColIdx, ArrayList txt) {
// 所有表格
Dispatch tables1 = Dispatch.get(document, "Tables").toDispatch();
// 主要内容(即参数数组中的值)
for (int i = 0; i < txt.size(); i++) {
String arrtostr = txt.get(i).toString(); // 先将数组元素转成字符串
String arrsubstr = arrtostr.substring(1, arrtostr.length() - 1); // 去掉前后'['和']'
String[] arrsplit = arrsubstr.split(","); // 字符串数组(在分隔每个元素值)
for (int j = 0; j < arrsplit.length; j++) {
// 要填入的表格(对表格列依序填入内容),cellRowIdx++代表从第一列开始
Dispatch table1 = Dispatch.call(tables1, "Item", new Variant(tableIndex)).toDispatch();
Dispatch cell1 = Dispatch.call(table1, "Cell",
new Variant(cellRowIdx++), new Variant(cellColIdx)).toDispatch();
// Dispatch.put(cell, "Height",new Variant(1)); //设置列高
Dispatch.call(cell1, "Select");
// 主要内容
// Dispatch.call(selection, "TypeParagraph"); //空一行段落
// Dispatch.put(alignment, "Alignment", "3"); //(1:置中 2:靠右 3:靠左)
if (j == 0) {
Dispatch.put(selection, "Text", arrsplit[j]); // 写入word的内容
Dispatch.put(pfont, "Bold", "1"); // 字型租体(1:租体 0:取消租体)
Dispatch.put(pfont, "Color", "1,1,1,1"); // 字型颜色
// Dispatch.put(font, "Italic", "1"); //字型斜体(1:斜体 0:取消斜体)
// Dispatch.put(font, "Underline", "1"); //文字加底线
Dispatch.call(selection, "MoveDown"); // 光标往下一行(才不会输入盖过上一输入位置)
} else {
if (arrsplit[j].indexOf(" ") != -1) {
String str = arrsplit[j].replaceAll(" ", " "); // 作字符串隔行对齐用
Dispatch.call(selection, "TypeParagraph"); // 空一行段落
Dispatch.put(palignment, "Alignment", "3"); // (1:置中 2:靠右 3:靠左)
Dispatch.put(selection, "Text", str); // 写入word的内容
Dispatch.put(pfont, "Bold", "0"); // 字型租体(1:租体 0:取消租体)
Dispatch.put(pfont, "Color", "1,1,1,0"); // 字型颜色
// Dispatch.put(font, "Italic", "1"); //字型斜体(1:斜体 0:取消斜体)
// Dispatch.put(font, "Underline", "1"); //文字加底线
Dispatch.call(selection, "MoveDown"); // 光标往下一行(才不会输入盖过上一输入位置)
} else {
Dispatch.put(selection, "Text", arrsplit[j]); // 写入word的内容
Dispatch.put(pfont, "Bold", "0"); // 字型租体(1:租体 0:取消租体)
Dispatch.put(pfont, "Color", "1,1,1,0"); // 字型颜色
// Dispatch.put(font, "Italic", "1"); //字型斜体(1:斜体 0:取消斜体)
// Dispatch.put(font, "Underline", "1"); //文字加底线
Dispatch.call(selection, "MoveDown"); // 光标往下一行(才不会输入盖过上一输入位置)
}
}
}
}
}
/**
* @date : 2012-2-23 下午01:09:18
* @author : lvchq
* @description : 删除一行
* @modify : 修改人 时间 简单描述
* @param tableIndex
* @param rowIndex
*/
public void delRow(int tableIndex, int rowIndex) {
if (this.table == null) {
table = this.getTable(tableIndex);
}
this.row = this.getTableRow(rowIndex);
Dispatch.call(row, "Delete");
}
}
1045
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
