1 /**
2 * 感觉很厉害的样子就转了，原帖地址：http://wang-ping001.iteye.com/blog/1452057
3 */
4 package com.xaeds.taecs.common.util;
5
6 import com.jacob.activeX.ActiveXComponent;
7 import com.jacob.com.Dispatch;
8 import com.jacob.com.Variant;
9
10 /**
11 * @author Administrator
12 *
13 */
14 public class WordBean {
15
16 // word文档
17 private Dispatch doc;
18
19 // word运行程序对象
20 private ActiveXComponent word;
21
22 // 所有word文档集合
23 private Dispatch documents;
24
25 // 选定的范围或插入点
26 private Dispatch selection;
27
28 private boolean saveOnExit = true;
29
30 public WordBean(boolean visible) throws Exception {
31 if (word == null) {
32 word = new ActiveXComponent("Word.Application");
33 word.setProperty("Visible", new Variant(visible)); // 不可见打开word
34 word.setProperty("AutomationSecurity", new Variant(3)); // 禁用宏
35 }
36 if (documents == null)
37 documents = word.getProperty("Documents").toDispatch();
38 }
39
40 /**
41 * 设置退出时参数
42 *
43 * @param saveOnExit
44 * boolean true-退出时保存文件，false-退出时不保存文件
45 */
46 public void setSaveOnExit(boolean saveOnExit) {
47 this.saveOnExit = saveOnExit;
48 }
49
50 /**
51 * 创建一个新的word文档
52 *
53 */
54 public void createNewDocument() {
55 doc = Dispatch.call(documents, "Add").toDispatch();
56 selection = Dispatch.get(word, "Selection").toDispatch();
57 }
58
59 /**
60 * 打开一个已存在的文档
61 *
62 * @param docPath
63 */
64 public void openDocument(String docPath) {
65 closeDocument();
66 doc = Dispatch.call(documents, "Open", docPath).toDispatch();
67 selection = Dispatch.get(word, "Selection").toDispatch();
68 }
69
70 /**
71 * 打开一个保护文档,
72 *
73 * @param docPath
74 * -文件全名
75 * @param pwd
76 * -密码
77 */
78 public void openDocumentOnlyRead(String docPath, String pwd)
79 throws Exception {
80 closeDocument();
81 doc = Dispatch.callN(
82 documents,
83 "Open",
84 new Object[] { docPath, new Variant(false), new Variant(true),
85 new Variant(true), pwd, "", new Variant(false) })
86 .toDispatch();
87 selection = Dispatch.get(word, "Selection").toDispatch();
88 }
89
90 public void openDocument(String docPath, String pwd) throws Exception {
91 closeDocument();
92 doc = Dispatch.callN(
93 documents,
94 "Open",
95 new Object[] { docPath, new Variant(false), new Variant(false),
96 new Variant(true), pwd }).toDispatch();
97 selection = Dispatch.get(word, "Selection").toDispatch();
98 }
99
100 /**
101 * 把选定的内容或插入点向上移动
102 *
103 * @param pos
104 * 移动的距离
105 */
106 public void moveUp(int pos) {
107 if (selection == null)
108 selection = Dispatch.get(word, "Selection").toDispatch();
109 for (int i = 0; i < pos; i++)
110 Dispatch.call(selection, "MoveUp");
111
112 }
113
114 /**
115 * 把选定的内容或者插入点向下移动
116 *
117 * @param pos
118 * 移动的距离
119 */
120 public void moveDown(int pos) {
121 if (selection == null)
122 selection = Dispatch.get(word, "Selection").toDispatch();
123 for (int i = 0; i < pos; i++)
124 Dispatch.call(selection, "MoveDown");
125 }
126
127 /**
128 * 把选定的内容或者插入点向左移动
129 *
130 * @param pos
131 * 移动的距离
132 */
133 public void moveLeft(int pos) {
134 if (selection == null)
135 selection = Dispatch.get(word, "Selection").toDispatch();
136 for (int i = 0; i < pos; i++) {
137 Dispatch.call(selection, "MoveLeft");
138 }
139 }
140
141 /**
142 * 把选定的内容或者插入点向右移动
143 *
144 * @param pos
145 * 移动的距离
146 */
147 public void moveRight(int pos) {
148 if (selection == null)
149 selection = Dispatch.get(word, "Selection").toDispatch();
150 for (int i = 0; i < pos; i++)
151 Dispatch.call(selection, "MoveRight");
152 }
153
154 /**
155 * 把插入点移动到文件首位置
156 *
157 */
158 public void moveStart() {
159 if (selection == null)
160 selection = Dispatch.get(word, "Selection").toDispatch();
161 Dispatch.call(selection, "HomeKey", new Variant(6));
162 }
163 public void enterStart(){
164 if (selection == null)
165 selection = Dispatch.get(word, "Selection").toDispatch();
166 Dispatch.call(selection, "TypeParagraph");
167 }
168 /**
169 * 从选定内容或插入点开始查找文本
170 *
171 * @param toFindText
172 * 要查找的文本
173 * @return boolean true-查找到并选中该文本，false-未查找到文本
174 */
175 @SuppressWarnings("static-access")
176 public boolean find(String toFindText) {
177 if (toFindText == null || toFindText.equals(""))
178 return false;
179 // 从selection所在位置开始查询
180 Dispatch find = word.call(selection, "Find").toDispatch();
181 // 设置要查找的内容
182 Dispatch.put(find, "Text", toFindText);
183 // 向前查找
184 Dispatch.put(find, "Forward", "True");
185 // 设置格式
186 Dispatch.put(find, "Format", "True");
187 // 大小写匹配
188 Dispatch.put(find, "MatchCase", "True");
189 // 全字匹配
190 Dispatch.put(find, "MatchWholeWord", "True");
191 // 查找并选中
192 return Dispatch.call(find, "Execute").getBoolean();
193 }
194
195 /**
196 * 把选定选定内容设定为替换文本
197 *
198 * @param toFindText
199 * 查找字符串
200 * @param newText
201 * 要替换的内容
202 * @return
203 */
204 public boolean replaceText(String toFindText, String newText) {
205 if (!find(toFindText))
206 return false;
207 Dispatch.put(selection, "Text", newText);
208 return true;
209 }
210
211 /**
212 * 全局替换文本
213 *
214 * @param toFindText
215 * 查找字符串
216 * @param newText
217 * 要替换的内容
218 */
219 public void replaceAllText(String toFindText, String newText) {
220 while (find(toFindText)) {
221 Dispatch.put(selection, "Text", newText);
222 Dispatch.call(selection, "MoveRight");
223 }
224 }
225
226 /**
227 * 在当前插入点插入字符串
228 *
229 * @param newText
230 * 要插入的新字符串
231 */
232 public void insertText(String newText) {
233 Dispatch.put(selection, "Text", newText);
234 }
235
236 /**
237 *
238 * @param toFindText
239 * 要查找的字符串
240 * @param imagePath
241 * 图片路径
242 * @return
243 */
244 public boolean replaceImage(String toFindText, String imagePath) {
245 if (!find(toFindText))
246 return false;
247 Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
248 "AddPicture", imagePath);
249 return true;
250 }
251
252 /**
253 * 全局替换图片
254 *
255 * @param toFindText
256 * 查找字符串
257 * @param imagePath
258 * 图片路径
259 */
260 public void replaceAllImage(String toFindText, String imagePath) {
261 while (find(toFindText)) {
262 Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
263 "AddPicture", imagePath);
264 Dispatch.call(selection, "MoveRight");
265 }
266 }
267
268 /**
269 * 在当前插入点插入图片
270 *
271 * @param imagePath
272 * 图片路径
273 */
274 public void insertImage(String imagePath) {
275 Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
276 "AddPicture", imagePath);
277 }
278
279 /**
280 * 合并当前表格指定的单元格 如果需要一次合并几个单元格只需要指出第一个单元格和最后一个单元格
281 *
282 * @param fstCellRowIndex
283 * 第一个单元格的行索引
284 * @param fstCellColIndex
285 * 第一个单元格的列索引
286 * @param secCellRowIndex
287 * 第二个单元格的行索引
288 * @param secCellColIndex
289 * 第二个单元格的列索引
290 */
291 public void mergeCell(int tableIndex, int fstCellRowIdx, int fstCellColIdx,
292 int secCellRowIdx, int secCellColIdx) {
293 // 所有表格
294 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
295 // 要填充的表格
296 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
297 .toDispatch();
298 Dispatch fstCell = Dispatch.call(table, "Cell",
299 new Variant(fstCellRowIdx), new Variant(fstCellColIdx))
300 .toDispatch();
301 Dispatch secCell = Dispatch.call(table, "Cell",
302 new Variant(secCellRowIdx), new Variant(secCellColIdx))
303 .toDispatch();
304 Dispatch.call(fstCell, "Merge", secCell);
305 }
306
307 /**
308 * 在指定的单元格里填写数据
309 *
310 * @param tableIndex
311 * @param cellRowIdx
312 * @param cellColIdx
313 * @param txt
314 */
315 public void putTxtToCell(int tableIndex, int cellRowIdx, int cellColIdx,
316 String txt) {
317 // 所有表格
318 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
319 // 要填充的表格
320 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
321 .toDispatch();
322 Dispatch cell = Dispatch.call(table, "Cell", new Variant(cellRowIdx),
323 new Variant(cellColIdx)).toDispatch();
324 Dispatch.call(cell, "Select");
325 Dispatch.put(selection, "Text", txt);
326 }
327
328 /**
329 * 获得指定的单元格里数据
330 *
331 * @param tableIndex
332 * @param cellRowIdx
333 * @param cellColIdx
334 * @return
335 */
336 public String getTxtFromCell(int tableIndex, int cellRowIdx, int cellColIdx) {
337 // 所有表格
338 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
339 // 要填充的表格
340 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
341 .toDispatch();
342 Dispatch cell = Dispatch.call(table, "Cell", new Variant(cellRowIdx),
343 new Variant(cellColIdx)).toDispatch();
344 Dispatch.call(cell, "Select");
345 String ret = "";
346 ret = Dispatch.get(selection, "Text").toString();
347 ret = ret.substring(0, ret.length() - 1); // 去掉最后的回车符;
348 return ret;
349 }
350
351 /**
352 * 在当前文档拷贝剪贴板数据
353 *
354 * @param pos
355 */
356 public void pasteExcelSheet(String pos) {
357 moveStart();
358 if (this.find(pos)) {
359 Dispatch textRange = Dispatch.get(selection, "Range").toDispatch();
360 Dispatch.call(textRange, "Paste");
361 }
362 }
363
364 /**
365 * 在当前文档指定的位置拷贝表格
366 *
367 * @param pos
368 * 当前文档指定的位置
369 * @param tableIndex
370 * 被拷贝的表格在word文档中所处的位置
371 */
372 public void copyTable(String pos, int tableIndex) {
373 // 所有表格
374 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
375 // 要填充的表格
376 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
377 .toDispatch();
378 Dispatch range = Dispatch.get(table, "Range").toDispatch();
379 Dispatch.call(range, "Copy");
380 if (this.find(pos)) {
381 Dispatch textRange = Dispatch.get(selection, "Range").toDispatch();
382 Dispatch.call(textRange, "Paste");
383 }
384 }
385
386 /**
387 * 在当前文档指定的位置拷贝来自另一个文档中的表格
388 *
389 * @param anotherDocPath
390 * 另一个文档的磁盘路径
391 * @param tableIndex
392 * 被拷贝的表格在另一格文档中的位置
393 * @param pos
394 * 当前文档指定的位置
395 */
396 public void copyTableFromAnotherDoc(String anotherDocPath, int tableIndex,
397 String pos) {
398 Dispatch doc2 = null;
399 try {
400 doc2 = Dispatch.call(documents, "Open", anotherDocPath)
401 .toDispatch();
402 // 所有表格
403 Dispatch tables = Dispatch.get(doc2, "Tables").toDispatch();
404 // 要填充的表格
405 Dispatch table = Dispatch.call(tables, "Item",
406 new Variant(tableIndex)).toDispatch();
407 Dispatch range = Dispatch.get(table, "Range").toDispatch();
408 Dispatch.call(range, "Copy");
409 if (this.find(pos)) {
410 Dispatch textRange = Dispatch.get(selection, "Range")
411 .toDispatch();
412 Dispatch.call(textRange, "Paste");
413 }
414 } catch (Exception e) {
415 e.printStackTrace();
416 } finally {
417 if (doc2 != null) {
418 Dispatch.call(doc2, "Close", new Variant(saveOnExit));
419 doc2 = null;
420 }
421 }
422 }
423
424 /**
425 * 在当前文档指定的位置拷贝来自另一个文档中的图片
426 *
427 * @param anotherDocPath
428 * 另一个文档的磁盘路径
429 * @param shapeIndex
430 * 被拷贝的图片在另一格文档中的位置
431 * @param pos
432 * 当前文档指定的位置
433 */
434 public void copyImageFromAnotherDoc(String anotherDocPath, int shapeIndex,
435 String pos) {
436 Dispatch doc2 = null;
437 try {
438 doc2 = Dispatch.call(documents, "Open", anotherDocPath)
439 .toDispatch();
440 Dispatch shapes = Dispatch.get(doc2, "InLineShapes").toDispatch();
441 Dispatch shape = Dispatch.call(shapes, "Item",
442 new Variant(shapeIndex)).toDispatch();
443 Dispatch imageRange = Dispatch.get(shape, "Range").toDispatch();
444 Dispatch.call(imageRange, "Copy");
445 if (this.find(pos)) {
446 Dispatch textRange = Dispatch.get(selection, "Range")
447 .toDispatch();
448 Dispatch.call(textRange, "Paste");
449 }
450 } catch (Exception e) {
451 e.printStackTrace();
452 } finally {
453 if (doc2 != null) {
454 Dispatch.call(doc2, "Close", new Variant(saveOnExit));
455 doc2 = null;
456 }
457 }
458 }
459
460 /**
461 * 创建表格
462 *
463 * @param pos
464 * 位置
465 * @param cols
466 * 列数
467 * @param rows
468 * 行数
469 */
470 public void createTable(String pos, int numCols, int numRows) {
471 if (find(pos)) {
472 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
473 Dispatch range = Dispatch.get(selection, "Range").toDispatch();
474 @SuppressWarnings("unused")
475 Dispatch newTable = Dispatch.call(tables, "Add", range,
476 new Variant(numRows), new Variant(numCols),new Variant(1)).toDispatch();
477 Dispatch.call(selection, "MoveRight");
478 } else {
479 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
480 Dispatch range = Dispatch.get(selection, "Range").toDispatch();
481 @SuppressWarnings("unused")
482 Dispatch newTable = Dispatch.call(tables, "Add", range,
483 new Variant(numRows), new Variant(numCols),new Variant(1)).toDispatch();
484 Dispatch.call(selection, "MoveRight");
485 }
486 }
487
488 /**
489 * 在指定行前面增加行
490 *
491 * @param tableIndex
492 * word文件中的第N张表(从1开始)
493 * @param rowIndex
494 * 指定行的序号(从1开始)
495 */
496 public void addTableRow(int tableIndex, int rowIndex) {
497 // 所有表格
498 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
499 // 要填充的表格
500 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
501 .toDispatch();
502 // 表格的所有行
503 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
504 Dispatch row = Dispatch.call(rows, "Item", new Variant(rowIndex))
505 .toDispatch();
506 Dispatch.call(rows, "Add", new Variant(row));
507 }
508
509 /**
510 * 在第1行前增加一行
511 *
512 * @param tableIndex
513 * word文档中的第N张表(从1开始)
514 */
515 public void addFirstTableRow(int tableIndex) {
516 // 所有表格
517 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
518 // 要填充的表格
519 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
520 .toDispatch();
521 // 表格的所有行
522 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
523 Dispatch row = Dispatch.get(rows, "First").toDispatch();
524 Dispatch.call(rows, "Add", new Variant(row));
525 }
526
527 /**
528 * 在最后1行前增加一行
529 *
530 * @param tableIndex
531 * word文档中的第N张表(从1开始)
532 */
533 public void addLastTableRow(int tableIndex) {
534 // 所有表格
535 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
536 // 要填充的表格
537 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
538 .toDispatch();
539 // 表格的所有行
540 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
541 Dispatch row = Dispatch.get(rows, "Last").toDispatch();
542 Dispatch.call(rows, "Add", new Variant(row));
543 }
544
545 /**
546 * 增加一行
547 *
548 * @param tableIndex
549 * word文档中的第N张表(从1开始)
550 */
551 public void addRow(int tableIndex) {
552 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
553 // 要填充的表格
554 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
555 .toDispatch();
556 // 表格的所有行
557 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
558 Dispatch.call(rows, "Add");
559 }
560
561 /**
562 * 增加一列
563 *
564 * @param tableIndex
565 * word文档中的第N张表(从1开始)
566 */
567 public void addCol(int tableIndex) {
568 // 所有表格
569 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
570 // 要填充的表格
571 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
572 .toDispatch();
573 // 表格的所有行
574 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
575 Dispatch.call(cols, "Add").toDispatch();
576 Dispatch.call(cols, "AutoFit");
577 }
578
579 /**
580 * 在指定列前面增加表格的列
581 *
582 * @param tableIndex
583 * word文档中的第N张表(从1开始)
584 * @param colIndex
585 * 制定列的序号 (从1开始)
586 */
587 public void addTableCol(int tableIndex, int colIndex) {
588 // 所有表格
589 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
590 // 要填充的表格
591 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
592 .toDispatch();
593 // 表格的所有行
594 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
595 System.out.println(Dispatch.get(cols, "Count"));
596 Dispatch col = Dispatch.call(cols, "Item", new Variant(colIndex))
597 .toDispatch();
598 // Dispatch col = Dispatch.get(cols, "First").toDispatch();
599 Dispatch.call(cols, "Add", col).toDispatch();
600 Dispatch.call(cols, "AutoFit");
601 }
602
603 /**
604 * 在第1列前增加一列
605 *
606 * @param tableIndex
607 * word文档中的第N张表(从1开始)
608 */
609 public void addFirstTableCol(int tableIndex) {
610 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
611 // 要填充的表格
612 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
613 .toDispatch();
614 // 表格的所有行
615 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
616 Dispatch col = Dispatch.get(cols, "First").toDispatch();
617 Dispatch.call(cols, "Add", col).toDispatch();
618 Dispatch.call(cols, "AutoFit");
619 }
620
621 /**
622 * 在最后一列前增加一列
623 *
624 * @param tableIndex
625 * word文档中的第N张表(从1开始)
626 */
627 public void addLastTableCol(int tableIndex) {
628 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
629 // 要填充的表格
630 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
631 .toDispatch();
632 // 表格的所有行
633 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
634 Dispatch col = Dispatch.get(cols, "Last").toDispatch();
635 Dispatch.call(cols, "Add", col).toDispatch();
636 Dispatch.call(cols, "AutoFit");
637 }
638
639 /**
640 * 自动调整表格
641 *
642 */
643 public void autoFitTable() {
644 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
645 int count = Dispatch.get(tables, "Count").toInt();
646 for (int i = 0; i < count; i++) {
647 Dispatch table = Dispatch.call(tables, "Item", new Variant(i + 1))
648 .toDispatch();
649 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
650 Dispatch.call(cols, "AutoFit");
651 }
652 }
653
654 /**
655 * 调用word里的宏以调整表格的宽度,其中宏保存在document下
656 *
657 */
658 public void callWordMacro() {
659 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
660 int count = Dispatch.get(tables, "Count").toInt();
661 Variant vMacroName = new Variant("Normal.NewMacros.tableFit");
662 @SuppressWarnings("unused")
663 Variant vParam = new Variant("param1");
664 @SuppressWarnings("unused")
665 Variant para[] = new Variant[] { vMacroName };
666 for (int i = 0; i < count; i++) {
667 Dispatch table = Dispatch.call(tables, "Item", new Variant(i + 1))
668 .toDispatch();
669 Dispatch.call(table, "Select");
670 Dispatch.call(word, "Run", "tableFitContent");
671 }
672 }
673
674 /**
675 * 设置当前选定内容的字体
676 *
677 * @param boldSize
678 * @param italicSize
679 * @param underLineSize
680 * 下划线
681 * @param colorSize
682 * 字体颜色
683 * @param size
684 * 字体大小
685 * @param name
686 * 字体名称
687 */
688 public void setFont(boolean bold, boolean italic, boolean underLine,
689 String size, String name) {
690 Dispatch font = Dispatch.get(selection, "Font").toDispatch();
691 Dispatch.put(font, "Name", new Variant(name));
692 Dispatch.put(font, "Bold", new Variant(bold));
693 Dispatch.put(font, "Italic", new Variant(italic));
694 Dispatch.put(font, "Underline", new Variant(underLine));
695 Dispatch.put(font, "Size", size);
696 }
697
698 /**
699 * 设置单元格被选中
700 *
701 * @param tableIndex
702 * @param cellRowIdx
703 * @param cellColIdx
704 */
705 public void setTableCellSelected(int tableIndex, int cellRowIdx,
706 int cellColIdx) {
707 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
708 Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
709 .toDispatch();
710 Dispatch cell = Dispatch.call(table, "Cell", new Variant(cellRowIdx),
711 new Variant(cellColIdx)).toDispatch();
712 Dispatch.call(cell, "Select");
713 }
714
715 /**
716 * 设置选定单元格的垂直对起方式, 请使用setTableCellSelected选中一个单元格
717 *
718 * @param align
719 * 0-顶端, 1-居中, 3-底端
720 */
721 public void setCellVerticalAlign(int verticalAlign) {
722 Dispatch cells = Dispatch.get(selection, "Cells").toDispatch();
723 Dispatch.put(cells, "VerticalAlignment", new Variant(verticalAlign));
724 }
725
726 /**
727 * 设置当前文档中所有表格水平居中方式及其它一些格式,用在将word文件转化为html中,针对申报表
728 */
729 public void setApplyTableFormat() {
730 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
731 int tabCount = Integer
732 .valueOf(Dispatch.get(tables, "Count").toString()); // System.out.println(tabCount);
733 System.out
734 .println("*******************************************************");
735 for (int i = 1; i <= tabCount; i++) {
736 Dispatch table = Dispatch.call(tables, "Item", new Variant(i))
737 .toDispatch();
738 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
739
740 if (i == 1) {
741 Dispatch.put(rows, "Alignment", new Variant(2)); // 1-居中,2-Right
742 continue;
743 }
744 Dispatch.put(rows, "Alignment", new Variant(1)); // 1-居中
745 Dispatch.call(table, "AutoFitBehavior", new Variant(1));// 设置自动调整表格方式,1-根据窗口自动调整
746 Dispatch.put(table, "PreferredWidthType", new Variant(1));
747 Dispatch.put(table, "PreferredWidth", new Variant(700));
748 System.out.println(Dispatch.get(rows, "HeightRule").toString());
749 Dispatch.put(rows, "HeightRule", new Variant(1)); // 0-自动wdRowHeightAuto,1-最小值wdRowHeightAtLeast,
750 // 2-固定wdRowHeightExactly
751 Dispatch.put(rows, "Height", new Variant(0.04 * 28.35));
752 // int oldAlign = Integer.valueOf(Dispatch.get(rows,
753 // "Alignment").toString());
754 // System.out.println("Algin:" + oldAlign);
755 }
756 }
757
758 /**
759 * 设置段落格式
760 *
761 * @param alignment
762 * 0-左对齐, 1-右对齐, 2-右对齐, 3-两端对齐, 4-分散对齐
763 * @param lineSpaceingRule
764 * @param lineUnitBefore
765 * @param lineUnitAfter
766 * @param characterUnitFirstLineIndent
767 */
768 public void setParagraphsProperties(int alignment, int lineSpaceingRule,
769 int lineUnitBefore, int lineUnitAfter,
770 int characterUnitFirstLineIndent) {
771 Dispatch paragraphs = Dispatch.get(selection, "Paragraphs")
772 .toDispatch();
773 Dispatch.put(paragraphs, "Alignment", new Variant(alignment)); // 对齐方式
774 Dispatch.put(paragraphs, "LineSpacingRule", new Variant(
775 lineSpaceingRule)); // 行距
776 Dispatch.put(paragraphs, "LineUnitBefore", new Variant(lineUnitBefore)); // 段前
777 Dispatch.put(paragraphs, "LineUnitAfter", new Variant(lineUnitAfter)); // 段后
778 Dispatch.put(paragraphs, "CharacterUnitFirstLineIndent", new Variant(
779 characterUnitFirstLineIndent)); // 首行缩进字符数
780 }
781
782 /**
783 * 设置当前段落格式, 使用前,请先选中段落
784 */
785 public void getParagraphsProperties() {
786 Dispatch paragraphs = Dispatch.get(selection, "Paragraphs")
787 .toDispatch();
788 String val = Dispatch.get(paragraphs, "LineSpacingRule").toString(); // 行距
789 val = Dispatch.get(paragraphs, "Alignment").toString(); // 对齐方式
790 val = Dispatch.get(paragraphs, "LineUnitBefore").toString(); // 段前行数
791 val = Dispatch.get(paragraphs, "LineUnitAfter").toString(); // 段后行数
792 val = Dispatch.get(paragraphs, "FirstLineIndent").toString(); // 首行缩进
793 val = Dispatch.get(paragraphs, "CharacterUnitFirstLineIndent")
794 .toString(); // 首行缩进字符数
795 }
796
797 /**
798 * 文件保存或另存为
799 *
800 * @param savePath
801 * 保存或另存为路径
802 */
803 public void save(String savePath) {
804 Dispatch.call(Dispatch.call(word, "WordBasic").getDispatch(),
805 "FileSaveAs", savePath);
806 }
807
808 /**
809 * 文件保存为html格式
810 *
811 * @param savePath
812 * @param htmlPath
813 */
814 public void saveAsHtml(String htmlPath) {
815 Dispatch.invoke(doc, "SaveAs", Dispatch.Method, new Object[] {
816 htmlPath, new Variant(8) }, new int[1]);
817 }
818
819 /**
820 * 关闭文档
821 *
822 * @param val
823 * 0不保存修改 -1 保存修改 -2 提示是否保存修改
824 */
825 public void closeDocument(int val) {
826 Dispatch.call(doc, "Close", new Variant(val));
827 doc = null;
828 }
829
830 /**
831 * 关闭当前word文档
832 *
833 */
834 public void closeDocument() {
835 if (doc != null) {
836 Dispatch.call(doc, "Save");
837 Dispatch.call(doc, "Close", new Variant(saveOnExit));
838 doc = null;
839 }
840 }
841
842 public void closeDocumentWithoutSave() {
843 if (doc != null) {
844 Dispatch.call(doc, "Close", new Variant(false));
845 doc = null;
846 }
847 }
848
849 /**
850 * 关闭全部应用
851 *
852 */
853 public void close() {
854 // closeDocument();
855 if (word != null) {
856 Dispatch.call(word, "Quit");
857 word = null;
858 }
859 selection = null;
860 documents = null;
861 }
862
863 /**
864 * 打印当前word文档
865 *
866 */
867 public void printFile() {
868 if (doc != null) {
869 Dispatch.call(doc, "PrintOut");
870 }
871 }
872
873 /**
874 * 保护当前档,如果不存在, 使用expression.Protect(Type, NoReset, Password)
875 *
876 * @param pwd
877 * WdProtectionType 可以是下列 WdProtectionType 常量之一：
878 * 1-wdAllowOnlyComments, 2-wdAllowOnlyFormFields,
879 * 0-wdAllowOnlyRevisions, -1-wdNoProtection,
880 * 3-wdAllowOnlyReading
881 *
882 * 使用参照 main1()
883 */
884 public void protectedWord(String pwd) {
885 String protectionType = Dispatch.get(doc, "ProtectionType").toString();
886 if (protectionType.equals("-1")) {
887 Dispatch.call(doc, "Protect", new Variant(3), new Variant(true),
888 pwd);
889 }
890 }
891
892 /**
893 * 解除文档保护,如果存在
894 *
895 * @param pwd
896 * WdProtectionType 常量之一(Long 类型，只读)：
897 * 1-wdAllowOnlyComments,2-wdAllowOnlyFormFields、
898 * 0-wdAllowOnlyRevisions,-1-wdNoProtection, 3-wdAllowOnlyReading
899 *
900 * 使用参照 main1()
901 */
902 public void unProtectedWord(String pwd) {
903 String protectionType = Dispatch.get(doc, "ProtectionType").toString();
904 if (protectionType.equals("3")) {
905 Dispatch.call(doc, "Unprotect", pwd);
906 }
907 }
908
909 /**
910 * 设置word文档安全级别
911 *
912 * @param value
913 * 1-msoAutomationSecurityByUI 使用“安全”对话框指定的安全设置。
914 * 2-msoAutomationSecurityForceDisable
915 * 在程序打开的所有文件中禁用所有宏，而不显示任何安全提醒。 3-msoAutomationSecurityLow
916 * 启用所有宏，这是启动应用程序时的默认值。
917 */
918 public void setAutomationSecurity(int value) {
919 word.setProperty("AutomationSecurity", new Variant(value));
920 }
921
922 /**
923 * 读取文档中第paragraphsIndex段文字的内容;
924 *
925 * @param paragraphsIndex
926 * @return
927 */
928 public String getParagraphs(int paragraphsIndex) {
929 String ret = "";
930 Dispatch paragraphs = Dispatch.get(doc, "Paragraphs").toDispatch(); // 所有段落
931 int paragraphCount = Dispatch.get(paragraphs, "Count").getInt(); // 一共的段落数
932 Dispatch paragraph = null;
933 Dispatch range = null;
934 if (paragraphCount > paragraphsIndex && 0 < paragraphsIndex) {
935 paragraph = Dispatch.call(paragraphs, "Item",
936 new Variant(paragraphsIndex)).toDispatch();
937 range = Dispatch.get(paragraph, "Range").toDispatch();
938 ret = Dispatch.get(range, "Text").toString();
939 }
940 return ret;
941 }
942
943 /**
944 * 设置页眉文字
945 *
946 * @param cont
947 * @return
948 *
949 * Sub AddHeaderText() '设置页眉或页脚中的文字 '由 Headers、Footers 和
950 * HeaderFooter 属性返回 HeaderFooter 对象。下列示例更改当前页眉中的文字。 With
951 * ActiveDocument.ActiveWindow.View .SeekView =
952 * wdSeekCurrentPageHeader Selection.HeaderFooter.Range.Text =
953 * "Header text" .SeekView = wdSeekMainDocument End With End Sub
954 */
955 public void setHeaderContent(String cont) {
956 Dispatch activeWindow = Dispatch.get(doc, "ActiveWindow").toDispatch();
957 Dispatch view = Dispatch.get(activeWindow, "View").toDispatch();
958 // Dispatch seekView = Dispatch.get(view, "SeekView").toDispatch();
959 Dispatch.put(view, "SeekView", new Variant(9)); // wdSeekCurrentPageHeader-9
960
961 Dispatch headerFooter = Dispatch.get(selection, "HeaderFooter")
962 .toDispatch();
963 Dispatch range = Dispatch.get(headerFooter, "Range").toDispatch();
964 Dispatch.put(range, "Text", new Variant(cont));
965 // String content = Dispatch.get(range, "Text").toString();
966 Dispatch font = Dispatch.get(range, "Font").toDispatch();
967
968 Dispatch.put(font, "Name", new Variant("宋体 (中文正文)"));
969 Dispatch.put(font, "Bold", new Variant(false));
970 // Dispatch.put(font, "Italic", new Variant(true));
971 // Dispatch.put(font, "Underline", new Variant(true));
972 Dispatch.put(font, "Size", 9);
973
974 Dispatch.put(view, "SeekView", new Variant(0)); // wdSeekMainDocument-0恢复视图;
975 }
976 }
浙公网安备 33010602011771号