精华内容
下载资源
问答
  • Python怎么替换选定区域的代码?难道没有跟Word类似的文本替换功能吗?
  • 工作中word模板处理,根据word中table的大小,替换文字以及自动改变文字的大小,适应表格,以及替换为图片。 代码如下 package com.jeecg.common.util.jacob; import com.itextpdf.awt.geom.Rectangle2D; import ...

    工作中word模板处理,根据word中table的大小,替换文字以及自动改变文字的大小,适应表格,以及替换为图片。

    代码如下

    package com.jeecg.common.util.jacob;

    import com.itextpdf.awt.geom.Rectangle2D;
    import com.jacob.activeX.ActiveXComponent;
    import com.jacob.com.Dispatch;
    import com.jacob.com.Variant;

    import java.awt.Desktop;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.UnsupportedEncodingException;
    import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;

    import javax.swing.ImageIcon;

    import org.jeecgframework.core.util.StringUtil;

    import com.jacob.com.ComFailException;
    import com.jacob.com.ComThread;
    /*
     * 利用jacob 编辑word文档
     * 
     * */
    public class WordManager {
        private boolean saveOnExit;
        /**
         * word文档
         */
        private Dispatch doc = null;

        /**
         * word运行程序对象
         */
        private ActiveXComponent word;

        /**
         * 所有word文档
         */
        private Dispatch documents;
        
        List<WordTableSet> wordTableSetList =new ArrayList<WordTableSet>();
        /**
         * 构造函数
         */
        public WordManager() {
            saveOnExit = false;
            word = new ActiveXComponent("Word.Application");
            word.setProperty("Visible", new Variant(false));
            documents = word.getProperty("Documents").toDispatch();
            
            
        }

        /**
         * 设置参数:退出时是否保存
         * 
         * @param saveOnExit
         *            true-退出时保存文件,false-退出时不保存文件
         */
        public void setSaveOnExit(boolean saveOnExit) {
            this.saveOnExit = saveOnExit;
        }

        /**
         * 得到参数:退出时是否保存
         * 
         * @return boolean true-退出时保存文件,false-退出时不保存文件
         */
        public boolean getSaveOnExit() {
            return saveOnExit;
        }

        /**
         * 打开文件
         * 
         * @param inputDoc
         *            要打开的文件,全路径
         * @return Dispatch 打开的文件
         */
        public Dispatch open(String inputDoc) {
            return Dispatch.call(documents, "Open", inputDoc).toDispatch();
        }

        /**
         * 选定内容
         * 
         * @return Dispatch 选定的范围或插入点
         */
        public Dispatch select() {
            return word.getProperty("Selection").toDispatch();
        }

        /**
         * 把选定内容或插入点向上移动
         * 
         * @param selection
         *            要移动的内容
         * @param count
         *            移动的距离
         */
        public void moveUp(Dispatch selection, int count) {
            for (int i = 0; i < count; i++)
                Dispatch.call(selection, "MoveUp");
        }

        /**
         * 把选定内容或插入点向下移动
         * 
         * @param selection
         *            要移动的内容
         * @param count
         *            移动的距离
         */
        public void moveDown(Dispatch selection, int count) {
            for (int i = 0; i < count; i++)
                Dispatch.call(selection, "MoveDown");
        }

        /**
         * 把选定内容或插入点向左移动
         * 
         * @param selection
         *            要移动的内容
         * @param count
         *            移动的距离
         */
        public void moveLeft(Dispatch selection, int count) {
            for (int i = 0; i < count; i++)
                Dispatch.call(selection, "MoveLeft");
        }

        /**
         * 把选定内容或插入点向右移动
         * 
         * @param selection
         *            要移动的内容
         * @param count
         *            移动的距离
         */
        public void moveRight(Dispatch selection, int count) {
            for (int i = 0; i < count; i++)
                Dispatch.call(selection, "MoveRight");
        }

        /**
         * 把插入点移动到文件首位置
         * 
         * @param selection
         *            插入点
         */
        public void moveStart(Dispatch selection) {
            Dispatch.call(selection, "HomeKey", new Variant(6));
        }

        /**
         * 从选定内容或插入点开始查找文本
         * 
         * @param selection
         *            选定内容
         * @param toFindText
         *            要查找的文本
         * @return boolean true-查找到并选中该文本,false-未查找到文本
         */
        public boolean find(Dispatch selection, String toFindText) {
            if (toFindText == null || toFindText.equals(""))
                return false;
            // 从selection所在位置开始查询
            Dispatch find = Dispatch.call(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();
        }
        
        /**
         * 把选定内容替换为设定文本
         * 
         * @param selection
         *            选定内容
         * @param newText
         *            替换为文本
         */
        public void replace(Dispatch selection, String newText) {
            // 设置替换文本
            Dispatch.put(selection, "Text", newText);
        }
      
        
         public  void getImgWidth(Dispatch selection,String oldText){
              Dispatch textRange = Dispatch.get(selection, "Range").toDispatch(); 
            
             Dispatch tables = Dispatch.get(doc, "Tables").toDispatch(); 
             Dispatch table = Dispatch.call(tables, "Item", new Variant(1)).toDispatch(); 
             System.out.println("Item:"+table); 
             Dispatch rows = Dispatch.get(table, "Rows").toDispatch(); 
             Dispatch columns=Dispatch.get(table,"Columns").toDispatch(); 
             System.out.println("rows:"+rows); 
             System.out.println("columns:"+columns); 
             Dispatch cell = Dispatch.call(table, "Cell",  1, 1) .toDispatch(); 
             Dispatch Range=Dispatch.get(cell,"Range").toDispatch(); 
             System.out.println("text:"+Dispatch.get(Range,"Text").toString());
    //         String data=Dispatch.get(cell,"Data").getString(); 
    //         System.out.println("data1:"+data); 
    //
    //         int n = Dispatch.get(rows, "Count").getInt(); 
    //         int c=Dispatch.get(columns, "Count").getInt(); 
    //         System.out.println("data2:"+n); 
    //         System.out.println("data3:"+c); 
             
           }
        /**
         * 替换图片
         * 
         * @param selection
         *            图片的插入点
         * @param imagePath
         *            图片文件(全路径)
         */
        public void replaceImage(Dispatch selection, String imagePath,WordTableSet set) {
            try {
                //
                Dispatch.put(selection, "Text", "");
                int tableIndex= set.getTableIndex();
                int cellRowIdx=set.getCellRowIdx();
                int cellColIdx=set.getCellColIdx();
                int oldFontSize=set.getFontSize();
                Double cellheight=set.getHeight();
                double width=0;
                double height=0;
                ImageIcon imageIcon = new ImageIcon(imagePath);
                double moveTop=0;
                int oldiconWidth = imageIcon.getIconWidth();
                int oldiconHeight = imageIcon.getIconHeight();
                System.out.println("oldIMG:======"+imagePath+oldiconWidth + "," + oldiconHeight);
                height=cellheight*0.9;
                width=((oldiconWidth*cellheight)/oldiconHeight)*0.9;
                //Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),"AddPicture", imagePath);
                moveTop=height*0.5;
                System.out.println("调整上下"+moveTop);
    //            for(int i=0;i<moveTop;i++){
    //                 Dispatch.call(selection,"MoveDown");
    //            }
             // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                        .toDispatch();

                Dispatch cell = Dispatch.call(table, "Cell", new Variant(cellRowIdx),
                        new Variant(cellColIdx)).toDispatch();
                Dispatch.call(cell, "Select");
                Dispatch picture = Dispatch.call(Dispatch.get(selection,"InLineShapes").toDispatch(),"AddPicture", imagePath).toDispatch(); // 添加图片
                Dispatch.call(picture, "Select"); // 选中图片
                
                Dispatch.put(picture, "Width", new Variant(width)); // 图片的宽度
                Dispatch.put(picture, "Height", new Variant(height)); // 图片的高度
                
                Dispatch ShapeRange = Dispatch.call(picture, "ConvertToShape").toDispatch(); // 取得图片区域
                
                Dispatch WrapFormat = Dispatch.get(ShapeRange, "WrapFormat").toDispatch(); // 取得图片的格式对象
                Dispatch.put(WrapFormat, "Type", 6); // 设置环绕格式(0 - 7)下面是参数说明
                //
                Dispatch.call(picture, "Select");
                
                Dispatch.put(ShapeRange, "top", new Variant(10));
                
                 WordTableSet newset =set;
                 newset.setSuccess(true);
                 wordTableSetList.remove(set);
                 wordTableSetList.add(newset);
                
    //                wdWrapInline 7 将形状嵌入到文字中。 
    //                wdWrapNone 3 将形状放在文字前面。请参阅 wdWrapFront 。
    //                wdWrapSquare 0 使文字环绕形状。行在形状的另一侧延续。
    //                wdWrapThrough 2 使文字环绕形状。
    //                wdWrapTight 1 使文字紧密地环绕形状。
    //                wdWrapTopBottom 4 将文字放在形状的上方和下方。
    //                wdWrapBehind 5 将形状放在文字后面。
    //                wdWrapFront 6 将形状放在文字前面。
        //          Dispatch.put(ShapeRange, "Left", new Variant(100));
            //    Dispatch.put(ShapeRange, "top", new Variant(moveTop));
                  
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            
        }
        public void replaceImage(Dispatch selection, String imagePath) {
            try {
                 
        
                //Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),"AddPicture", imagePath);
                Dispatch picture = Dispatch.call(Dispatch.get(selection,"InLineShapes").toDispatch(),"AddPicture", imagePath).toDispatch(); // 添加图片
                Dispatch.call(picture, "Select"); // 选中图片
                //Dispatch.put(picture, "Width", new Variant(100)); // 图片的宽度
                //Dispatch.put(picture, "Height", new Variant(100)); // 图片的高度
                Dispatch ShapeRange = Dispatch.call(picture, "ConvertToShape").toDispatch(); // 取得图片区域
                Dispatch WrapFormat = Dispatch.get(ShapeRange, "WrapFormat").toDispatch(); // 取得图片的格式对象
                Dispatch.put(WrapFormat, "Type", 6); // 设置环绕格式(0 - 7)下面是参数说明

    //                wdWrapInline 7 将形状嵌入到文字中。 
    //                wdWrapNone 3 将形状放在文字前面。请参阅 wdWrapFront 。
    //                wdWrapSquare 0 使文字环绕形状。行在形状的另一侧延续。
    //                wdWrapThrough 2 使文字环绕形状。
    //                wdWrapTight 1 使文字紧密地环绕形状。
    //                wdWrapTopBottom 4 将文字放在形状的上方和下方。
    //                wdWrapBehind 5 将形状放在文字后面。
    //                wdWrapFront 6 将形状放在文字前面。
            

          

            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            
        }
        /**
         * 替换表格
         * 
         * @param selection
         *            插入点
         * @param tableName
         *            表格名称,形如table$1@1、table$2@1...table$R@N,R代表从表格中的第N行开始填充,
         *            N代表word文件中的第N张表
         * @param fields
         *            表格中要替换的字段与数据的对应表
         */
        public void replaceTable(Dispatch selection, String tableName, List dataList) {
            if (dataList.size() == 1) {
                System.out.println("Empty table!");
                return;
            }
            // 要填充的列
            String[] cols = (String[]) dataList.get(0);
            // 表格序号
            String tbIndex = tableName.substring(tableName.lastIndexOf("@") + 1);
            // 从第几行开始填充
            int fromRow = Integer.parseInt(tableName.substring(
                    tableName.lastIndexOf("$") + 1, tableName.lastIndexOf("@")));
            // 所有表格
            Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
            // 要填充的表格
            Dispatch table = Dispatch.call(tables, "Item", new Variant(tbIndex))
                    .toDispatch();
            // 表格的所有行
            Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
            // 填充表格
            for (int i = 1; i < dataList.size(); i++) {
                // 某一行数据
                String[] datas = (String[]) dataList.get(i);
                // 在表格中添加一行
                if (Dispatch.get(rows, "Count").getInt() < fromRow + i - 1)
                    Dispatch.call(rows, "Add");
                // 填充该行的相关列
                for (int j = 0; j < datas.length; j++) {
                    // 得到单元格
                    Dispatch cell = Dispatch.call(table, "Cell",
                            Integer.toString(fromRow + i - 1), cols[j])
                            .toDispatch();
                    // 选中单元格
                    Dispatch.call(cell, "Select");
                    // 设置格式
                    Dispatch font = Dispatch.get(selection, "Font").toDispatch();
                    Dispatch.put(font, "Bold", "0");
                    Dispatch.put(font, "Italic", "0");
                    // 输入数据
                    Dispatch.put(selection, "Text", datas[j]);
                }
            }
        }

        /**
         * 保存文件
         * 
         * @param outputPath
         *            输出文件(包含路径)
         */
        public void save(String outputPath) {
            Dispatch.call(
                    (Dispatch) Dispatch.call(word, "WordBasic").getDispatch(),
                    "FileSaveAs", outputPath);
        }

        /**
         * 关闭文件
         * 
         * @param document
         *            要关闭的文件
         */
        public void close(Dispatch doc) {
            Dispatch.call(doc, "Close", new Variant(saveOnExit));
        }

        /**
         * 退出程序
         * 
         */
        public void quit() {
            word.invoke("Quit", new Variant[0]);
            ComThread.Release();
        }

        /**
         * 根据模板、数据生成word文件
         * 
         * @param inputPath
         *            模板文件(包含路径)
         * @param outPath
         *            输出文件(包含路径)
         * @param data
         *            数据包(包含要填充的字段、对应的数据)
         */
        public void toTableWord(String inputPath, String outPath, HashMap data) {
        
            String oldText;
            Object param;
            String newValue="";
    //        ComThread.InitSTA();
            ComThread.InitMTA(true);
            try {
                System.out.println("word替换开始时间"+ new Date());
                doc = open(inputPath);
                //获取table表格的数据
                wordTableSetList=getTableCellWidthHeight();
    //            System.out.println("word已开始");
                
                Dispatch selection = select();
                moveStart(selection);
                Iterator keys = data.keySet().iterator();
    //            System.out.println("word获取数据");
                while (keys.hasNext()) {
                    oldText = (String) keys.next();
                    
                    param = data.get(oldText);
                    if(param==null){
                        param=" ";
                    }
                       if (param instanceof Integer) {
                           int value = ((Integer) param).intValue();
                           newValue = String.valueOf(value);;
                       
                       } else if (param instanceof String) {
                           newValue= (String) param;
                        
                       } else if (param instanceof Double) {
                        double d = ((Double) param).doubleValue();
                        newValue = String.valueOf(d);;
                       } else if (param instanceof Float) {
                        float f = ((Float) param).floatValue();
                        newValue = String.valueOf(f);;
                       } else if (param instanceof Long) {
                        long l = ((Long) param).longValue();
                        newValue = String.valueOf(l);
                       } else if (param instanceof Boolean) {
                        boolean b = ((Boolean) param).booleanValue();
                        newValue = String.valueOf(b);;
                       } else if (param instanceof Date) {
                        Date d = (Date) param;
                        SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");// 设置日期格式
                        newValue = df1.format(d);
                        
                       }else if (param instanceof BigDecimal) {
                           BigInteger l = ((BigDecimal) param).toBigInteger();
                            newValue = String.valueOf(l);
                    } 
    //                System.out.println("word:"+oldText+newValue);
                    replaceTableAll(selection, oldText, newValue);
                }
                
                save(outPath);
            } catch (Exception e) {
                System.out.println("错误"+e.getMessage());
                // debug.println("toword[Java2Word]------------操作word文件失败!"+e.getMessage(),true);
            } finally {
                if (doc != null) {
                    close(doc);
                }
                quit();
                System.out.println("word替换结束时间"+ new Date());
            }
        }
        public void toWord(String inputPath, String outPath, HashMap data) {
            
            String oldText;
            Object param;
            String newValue="";
        //    ComThread.InitSTA();//单一线程启动
            ComThread.InitMTA(true);
            try {
    //            System.out.println("word替换开始");
                doc = open(inputPath);
                //获取table表格的数据
        //        wordTableSetList=getTableCellWidthHeight();
    //            System.out.println("word已开始");
                
                Dispatch selection = select();
                moveStart(selection);
                Iterator keys = data.keySet().iterator();
    //            System.out.println("word获取数据");
                while (keys.hasNext()) {
                    oldText = (String) keys.next();
                    
                    param = data.get(oldText);
                    if(param==null){
                        param=" ";
                    }
                       if (param instanceof Integer) {
                           int value = ((Integer) param).intValue();
                           newValue = String.valueOf(value);;
                       
                       } else if (param instanceof String) {
                           newValue= (String) param;
                        
                       } else if (param instanceof Double) {
                        double d = ((Double) param).doubleValue();
                        newValue = String.valueOf(d);;
                       } else if (param instanceof Float) {
                        float f = ((Float) param).floatValue();
                        newValue = String.valueOf(f);;
                       } else if (param instanceof Long) {
                        long l = ((Long) param).longValue();
                        newValue = String.valueOf(l);
                       } else if (param instanceof Boolean) {
                        boolean b = ((Boolean) param).booleanValue();
                        newValue = String.valueOf(b);;
                       } else if (param instanceof Date) {
                        Date d = (Date) param;
                        SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");// 设置日期格式
                        newValue = df1.format(d);
                        
                       }else if (param instanceof BigDecimal) {
                           BigInteger l = ((BigDecimal) param).toBigInteger();
                            newValue = String.valueOf(l);
                    } 
    //                System.out.println("word:"+oldText+newValue);
                    replaceAll(selection, oldText, newValue);
                }
                
                save(outPath);
            } catch (Exception e) {
                System.out.println("错误"+e.getMessage());
                // debug.println("toword[Java2Word]------------操作word文件失败!"+e.getMessage(),true);
            } finally {
                if (doc != null) {
                    close(doc);
                }
                quit();
            }
        }
         /** 
         * 将输入流中的数据写入字节数组 
         * @param in 
         * @return 
         */  
        public static byte[] inputStream2ByteArray(InputStream in,boolean isClose){  
            byte[] byteArray = null;  
            try {  
                int total = in.available();  
                byteArray = new byte[total];  
                in.read(byteArray);  
            } catch (IOException e) {  
                e.printStackTrace();  
            }finally{  
                if(isClose){  
                    try {  
                        in.close();  
                    } catch (Exception e2) {  
                        System.out.println("关闭流失败");  
                    }  
                }  
            }  
            return byteArray;  
        }  
        public List<WordTableSet> getCellWidthHeightByText(Dispatch selection,String text){
            List<WordTableSet> widHeight=new ArrayList<WordTableSet>();
            
            
            for(int k = 0;k < wordTableSetList.size();k++){
                WordTableSet set = wordTableSetList.get(k);
                set.setRownum(k);
                if(text.equals(set.getOldText())&&!set.isSuccess){
                    widHeight.add(set);
                    
                }
            }
            
            return widHeight;
        }
        //获取所有表格中内容cell的宽度高度
        public  List<WordTableSet> getTableCellWidthHeight(){
             List<WordTableSet> mapList=new ArrayList<WordTableSet>();
            // 所有表格
              Dispatch tables = Dispatch.get(doc, "Tables").toDispatch(); 
              // 获取表格数目
              int tablesCount = Dispatch.get(tables,"Count").toInt();
    //          System.out.println("获取表格数目"+tablesCount);
              // 循环获取表格
              for(int i=1;i<=tablesCount;i++)
              {
               // 生产warningBean
             ///  warningBean warning = new warningBean();
               // 获取第i个表格
               Dispatch table = Dispatch.call(tables, "Item", new Variant(i)).toDispatch();
               // 获取该表格所有行
               Dispatch rows = Dispatch.call(table, "Rows").toDispatch();
               // 获取该表格所有列
               Dispatch columns = Dispatch.call(table, "Columns").toDispatch();
               // 获取该表格行数
               int rowsCount = Dispatch.get(rows,"Count").toInt();
               // 获取该表格列数
               int columnsCount = Dispatch.get(columns,"Count").toInt();
               
            //   Dispatch Range2=Dispatch.get(table,"Range").toDispatch();
             //  System.out.println( Dispatch.get(Range2,"Text").toString());
             
               // 循环遍历行
               for(int j=1;j<=rowsCount;j++)
                   for(int m=1;m<=columnsCount;m++)
                  {
              
                try {
                    WordTableSet WordTableSet = getTxtFromCell(i, j, m);
                     if(WordTableSet!=null){
                         mapList.add(WordTableSet);
                        
                     }
                } catch (UnsupportedEncodingException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
              }
            
               }
             return  mapList;
        }
        
        public WordTableSet getTxtFromCell(int tableIndex, int cellRowIdx, int cellColIdx) throws UnsupportedEncodingException {
            WordTableSet set=new WordTableSet();
            // 所有表格
              Dispatch tables = Dispatch.get(doc, "Tables").toDispatch(); 
              // 要填充的表格
              Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex)).toDispatch();
              
              Dispatch rows = Dispatch.call(table, "Rows").toDispatch();
              
              Dispatch columns = Dispatch.call(table, "Columns").toDispatch();
    //          System.out.println("表格:"+tableIndex+"行数"+cellRowIdx+"列数"+cellColIdx+"其他行列"+rows+columns);
              Map<String,String> maps=new HashMap<String,String>();
              String widHei="";
              String ret = "";
              try{
                  Dispatch cell = Dispatch.call(table, "Cell", new Variant(cellRowIdx),new Variant(cellColIdx)).toDispatch();
                 
                  Dispatch Range=Dispatch.get(cell,"Range").toDispatch();
                  Double widths=Dispatch.get(cell,"Width").toDouble();
                  Double Height=Dispatch.get(cell,"Height").toDouble();
                   String eeheight=  Dispatch.get(cell,"HeightRule").toString();
                  Dispatch font = Dispatch.get(Range, "Font").toDispatch(); 
                  int fontSize=Dispatch.get(font,"Size").toInt();
                  
                  widHei=widths+","+Height;
                  String t=Dispatch.get(Range,"Text").toString();
                  String s=new String(t.getBytes("utf-8"));
                  s=s.replace("","").trim();
                //  System.out.print(s+"    ");
                  ret=s;
                //  Dispatch.call(cell, "Select");
                //  ret = Dispatch.get(selection, "Text").toString();
                  // ret = ret.substring(0, ret.length() - 2); // 去掉最后的回车符;
                  
                  //cell里面含有图片
                  if(fontSize==9999999){
                        return null;
                       }
                  Dispatch.call(cell, "Select");
                  
            //      Dispatch selection= select();
    //              System.out.println("表格:"+tableIndex+"内容="+ret+"行数"+cellRowIdx+"列数"+cellColIdx+"宽度"+widths+""+Height+eeheight);
                  maps.put(ret, widHei);
                  set.setFontSize(fontSize);
                  set.setCellColIdx(cellColIdx);
                  set.setCellRowIdx(cellRowIdx);
                  set.setHeight(Height);
                  set.setWidth(widths);
                  set.setTableIndex(tableIndex);
                  set.setOldText(ret);
                  set.setSelection(cell);
                //没有行列
              }catch (ComFailException e){
                 return set; 
              }
              
              return set;
             }
             
        /**
         * 在指定的单元格里填写数据
         * 
         * @param tableIndex
         * @param cellRowIdx
         * @param cellColIdx
         * @param txt
         * @throws UnsupportedEncodingException 
         */
        public void putTxtToCell(Dispatch selection,
                String txt,WordTableSet set )  {
            int tableIndex= set.getTableIndex();
            int cellRowIdx=set.getCellRowIdx();
            int cellColIdx=set.getCellColIdx();
            int oldFontSize=set.getFontSize();
            Double oldHeight=set.getHeight();
            // 所有表格
            Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
            // 要填充的表格
            Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                    .toDispatch();

            Dispatch cell = Dispatch.call(table, "Cell", new Variant(cellRowIdx),
                    new Variant(cellColIdx)).toDispatch();
            Dispatch.call(cell, "Select");
           
            //字体公共参数
            double tt=0.52;
            int textLength=length(txt);
            int cellHeight=Dispatch.get(cell,"Height").toInt();
            int cellWidth=Dispatch.get(cell,"Width").toInt();
            int fontSize=0;
            int lineHeight=0;
            boolean flag=true;
            while(flag){
                for(int i=oldFontSize;i>0;i--){
                    lineHeight=i+1;
                    int hang=cellHeight/lineHeight;
                    int zhang=hang*cellWidth;
                    double texthang= textLength*i*tt;
                    if(zhang>=texthang){
                        flag=false;
                        fontSize=i;
                        break;
                     }
                }
            }
            Dispatch.put(cell, "HeightRule", new Variant(1));//0-自动wdRowHeightAuto,1-最小值wdRowHeightAtLeast, 2-固定wdRowHeightExactly     
            Dispatch alignment = Dispatch.get(selection, "ParagraphFormat")
                    .toDispatch();
            Dispatch.put(alignment, "LineSpacingRule" , new Variant(4));
            Dispatch.put(alignment, "LineSpacing" , new Variant(lineHeight));
            Dispatch font = Dispatch.get(selection, "Font").toDispatch();
            Dispatch.put(font, "Size", new Variant(fontSize));
    //        String     WordSpacing1=Dispatch.get(font, "Spacing").toString();
            Dispatch.put(selection, "Text", txt);
    //        System.out.println("字符长度==="+length(txt)+"原始字体大小="+oldFontSize+"使用字体大小="+fontSize+"内容="+txt);
            WordTableSet newset =set;
            newset.setSuccess(true);
            wordTableSetList.remove(set);
            wordTableSetList.add(newset);
            //        // 所有表格
    //        Dispatch tables1 = Dispatch.get(doc, "Tables").toDispatch();
    //        // 要填充的表格
    //        Dispatch table1 = Dispatch.call(tables1, "Item", new Variant(tableIndex))
    //                .toDispatch();
    //
    //        Dispatch cell1 = Dispatch.call(table1, "Cell", new Variant(cellRowIdx),
    //                new Variant(cellColIdx)).toDispatch();
    // 
    //        Dispatch.call(cell1, "Select");
    //    //    Dispatch paragraphs = Dispatch.get(selection, "Paragraphs").toDispatch();   
    //        Dispatch alignment1 = Dispatch.get(selection, "ParagraphFormat")
    //                .toDispatch();
    //        String     Alignment1=    Dispatch.get(alignment1, "Alignment").toString();// 默认:居左 0:居左 1:居中 2:居右 3:两端对齐 4:分散对齐
    //        String     LineSpacingRule1=Dispatch.get(alignment1, "LineSpacingRule").toString();//默认:1.0 0:1.0 1:1.5 2:2.0 3:最小值 4:固定值
    //        String     LineSpacing1=Dispatch.get(alignment1, "LineSpacing").toString();
    //       
    //        System.out.println("段落以及行距========"+Alignment1+" 行距类型"+LineSpacingRule1+" 行距 "+LineSpacing1+"字距"+WordSpacing1);
    //       
    //        Dispatch Range=Dispatch.get(cell1,"Range").toDispatch();
    //        String t=Dispatch.get(Range,"Text").toString();
    //          try {
    //            String s=new String(t.getBytes("utf-8"));
    //             System.out.println("7dadsdadassdasaddasafasaffaasfasf========"+s+cellRowIdx+cellColIdx);
    //             System.out.println("7dadsdadassdasaddasafasaffaasfasf========"+oldHeight);
    //        } catch (UnsupportedEncodingException e) {
    //            // TODO Auto-generated catch block
    //            e.printStackTrace();
    //        }
           
             
            
            
        }
        //计算字符长度
        public static int length(String value) {
            int valueLength = 0;
            String chinese = "[\u0391-\uFFE5]";
            /* 获取字段值的长度,如果含中文字符,则每个中文字符长度为2,否则为1 */
            for (int i = 0; i < value.length(); i++) {
                /* 获取一个字符 */
                String temp = value.substring(i, i + 1);
                /* 判断是否为中文字符 */
                if (temp.matches(chinese)) {
                    /* 中文字符长度为2 */
                    valueLength += 2;
                } else {
                    /* 其他字符长度为1 */
                    valueLength += 1;
                }
            }
            return valueLength;
        }

        /**
         * 全局替换
         * 
         * @param selection
         *            选定内容或起始插入点
         * @param oldText
         *            要替换的文本
         * @param newText
         *            替换为文本
         */
        public void replaceAll(Dispatch selection, String oldText, Object replaceObj) {
            // 移动到文件开头
            moveStart(selection);
            if (oldText.startsWith("table") || replaceObj instanceof List) {
                replaceTable(selection, oldText, (List) replaceObj);
            } else {
                String newText = (String) replaceObj;
                if (oldText.indexOf("image") != -1
                        || newText.lastIndexOf(".bmp") != -1
                        || newText.lastIndexOf(".png") != -1
                        || newText.lastIndexOf(".jpg") != -1
                        || newText.lastIndexOf(".gif") != -1){
                    while (find(selection, oldText)) {
                        //getImgWidth(selection,oldText);
                            
                            replaceImage(selection, newText);
                            
                        
                        Dispatch.call(selection, "MoveRight");
                    }
                    
                }else{
                    while (find(selection, oldText)) {
                        
                        
                        replace(selection, newText);
                        
                        
                        Dispatch.call(selection, "MoveRight");
                    }
                }
                    
            }
        }
        public void replaceTableAll(Dispatch selection, String oldText, Object replaceObj) {
            // 移动到文件开头
            moveStart(selection);
            if (oldText.startsWith("table") || replaceObj instanceof List) {
                replaceTable(selection, oldText, (List) replaceObj);
            } else {
                String newText = (String) replaceObj;
                if (oldText.indexOf("image") != -1
                        || newText.lastIndexOf(".bmp") != -1
                        || newText.lastIndexOf(".png") != -1
                        || newText.lastIndexOf(".jpg") != -1
                        || newText.lastIndexOf(".gif") != -1){
                    while (find(selection, oldText)) {
                        //getImgWidth(selection,oldText);
                        List<WordTableSet> setList=getCellWidthHeightByText(selection,oldText);
                        if(setList!=null&&setList.size()>0){
                            for(WordTableSet set:setList){
                                
                                replaceImage(selection, newText,set);
                            }
                           
                        }else{
                            replaceImage(selection, newText);
                        }
                        
                        Dispatch.call(selection, "MoveRight");
                    }
                    
                }else{
                    
                    while (find(selection, oldText)) {
                      
                        List<WordTableSet> setList=getCellWidthHeightByText(selection,oldText);
                        if(setList!=null&&setList.size()>0){
                            for(WordTableSet set:setList){
                              
                                   putTxtToCell(selection,newText,set); 
                               
                            
                            }

                        }else{
                            replace(selection, newText);
                        }
                    
                        Dispatch.call(selection, "MoveRight");
                    }
                    
                }
                    
            }
        }
        
        public static void main(String[] args) throws Exception {
            WordManager j = new WordManager();
            String inputPath = "E:/111.doc";
            String outPath = "E:/111d.doc";
            HashMap<String, Object> data = new HashMap<String, Object>();
        
            //不能为空
            
    //        Map<String,Object> header = new HashMap<String, Object>();  
    //            header.put("width", 100);  
    //            header.put("height", 150);  
    //            header.put("type", "png");  
    //            header.put("content", inputStream2ByteArray(new FileInputStream("D:\\aa.jpg"), true));  
    //        data.put("[$图片]", "D:\\a.png");F字符长度
            String aaa="见证取样";
            data.put("${CODE}", "181501341077");
            data.put("${[0].PRO_NAME}", "sdsadsdasadasdasdsadsdd大大dddddddddddddddddddddddddddddddddddddddddddddddddddddadasdadssdsaasdadsunchengmandadadasdsddddddddddddddddddddddddddddddddddddddddadssadasasdasads");
            data.put("${[0].TEST_NO}", "增长速度噶大苏打");
            data.put("${[0].IMG1}", "E:\\1.png"); 
            
            j.toTableWord(inputPath, outPath, data);
            //System.out.print(length(aaa));
            //打开本地文件
            //Desktop.getDesktop().open(new File("D:\\tt.doc"));
        }
        
    }

    展开全文
  • 当在选定内容或区域中没有找到搜索文字时,本参数也控制接下来的操作。可以是下列 WdFindWrap 常量之一:    常量 描述  wdFindAsk 搜索完所选内容或者区域后,Microsoft Word 会显示一条消息,询问是否搜索...

    Set   myRange   =   ActiveDocument.Content  
      myRange.Find.Execute   FindText:="2",   ReplaceWith:="1",   Replace:=wdReplaceAll  
    Set   myRange   =   ActiveDocument.Content  
      myRange.Find.Execute   FindText:="2",   ReplaceWith:="1",   Replace:=wdReplaceAll  

     

    Execute   方法(Find   对象)  
                                       
       
      运行指定的查找操作。如果查找成功,则返回   True。(这说明其是同步执行)  
       
      语法  
       
      expression.Execute(FindText,   MatchCase,   MatchWholeWord,   MatchWildcards,  MatchSoundsLike,   MatchAllWordForms,   Forward,   Wrap,   Format,   ReplaceWith,   Replace,  MatchKashida,   MatchDiacritics,   MatchAlefHamza,   MatchControl)  
       
      expression     必需。该表达式返回   Find   对象。  
       
      FindText     Variant   类型,可选。指定需查找的文本。可用空字符串   ("")   查找格式。也可通过指定适当的字符代码查找特殊字符。例如,“^p”对应段落标记,“^t”对应制表符。如果需要使用特殊字符列表,请参阅查找替换特殊字符和文档元素示例。  
       
      如果   MatchWildcards   为   True,则可以指定通配符及其他高级搜索条件。例如,“*(ing)”   将查找以“ing”结尾的所有单词。详细内容,请参阅通配符搜索示例。  
       
      若要搜索符号字符,可键入   (^)   字符,零(0),然后键入符号字符的代码。例如,“^0151”对应一条长划线(—)。  
       
      MatchCase     Variant   类型,可选。如果是   True,则查找文本需区分大小写。相当于“编辑”菜单“查找和替换”对话框中的“区分大小写”复选框。  
       
      MatchWholeWord       Variant   类型,可选。如果为   True,则只查找匹配的完整单词,而并非作为一个长单词的一部分的文字。相当于“编辑”菜单“查找和替换”对话框中的“全字匹配”复选框。  
       
      MatchWildcards     Variant   类型,可选。如果为   True,则查找的文字包含特殊搜索操作符。相当于“编辑”菜单“查找和替换”对话框中的“使用通配符”复选框。  
       
      MatchSoundsLike     Variant   类型,可选。如果为   True,则查找与待查找文字发音相近的单词。相当于“编辑”菜单“查找和替换”对话框中的“同音”复选框。  
       
      MatchAllWordForms     Variant   类型,可选。如果为   True,则查找文字的所有形式(例如,“  sit”   将包含“sitting”和“sat”)。相当于“编辑”菜单“查找和替换”对话框中的“查找单词的各种形式”复选框。  
       
      Forward     Variant   类型,可选。如果为   True,则向下(向文档尾部)搜索。  
       
      Wrap     Variant   类型,可选。如果搜索从不是文档开头的位置开始,并到达文档末尾(如   Forward   设置为   False,则相反),用本参数控制接下来的操作。当在选定内容或区域中没有找到搜索文字时,本参数也控制接下来的操作。可以是下列   WdFindWrap   常量之一:  
       
      常量   描述    
      wdFindAsk   搜索完所选内容或者区域后,Microsoft   Word   会显示一条消息,询问是否搜索文档的其他部分。    
      wdFindContinue   到达搜索区域的开始或者结尾时,继续执行查找操作。    
      wdFindStop   到达搜索范围的开始或者结尾时,停止执行查找操作。    
       
       
      Format     Variant   类型,可选。   如果为   True,则查找格式而非文字。    
       
      ReplaceWith     Variant   类型,可选。替换文字。要删除由   Find   参数指定的文字,可使用空字符串   ("")。与   Find   参数相似,本参数也可以指定特殊的字符和高级搜索条件。要将图形对象或者其他非文本项指定为替换内容,可将这些项目置于“剪贴板”上,然后将   ReplaceWith   指定为“  ^c”。  
       
      Replace     Variant   类型,可选。指定执行替换的个数:一个、全部或者不替换。可为下列  WdReplace   常量之一:wdReplaceAll、wdReplaceNone   或   wdReplaceOne。  
       
      MatchKashida     Variant   类型,可选。如果为   True,则查找结果应与阿拉伯语文档中区分  kashidas   的文本相匹配。由于选择或安装的语言支持不同(例如,美国英语),此参数可能不可用。  
       
      MatchDiacritics     Variant   类型,可选。如果为   True,则查找结果应与区分音调符号的语言文本相匹配。由于选择或安装的语言支持不同(例如,美国英语),此参数可能不可用。  
       
      MatchAlefHamza     Variant   类型,可选。如果为   True,则在阿拉伯语文档中,查找内容应与区分   Alef   Hamzas   的文本相匹配。由于选择或安装的语言支持不同(例如,美国英语),此参数可能不可用。  
       
      MatchControl     Variant   类型,可选。如果为   True,则在从右到左运用语言的文档中,查找内容应区分双向控制字符。由于选择或安装的语言支持不同(例如,美国英语),此参数可能不可用。  
       
      说明  
       
      除非另外指定,否则替换文本将沿用文档中被替换文本的格式。例如,如果用“xyz”替换“abc”,那么粗体“abc”将被粗体字符串“xyz”所替换。  
       
      同样,如果   MatchCase   为   False,那么查找到的大写文本将被大写的替换文本替换,而无论搜索文本和替换文本是否大小写。上例中,“ABC”将被“XYZ”替换。

    转载于:https://www.cnblogs.com/effort-rookie/archive/2013/03/11/2953955.html

    展开全文
  • Word VBA教程:查找并替换文字或格式

    万次阅读 2018-08-18 10:48:54
    通过Find 和Replacement对象可实现查找和替换功能。Selection 和Range对象可以使用 Find对象。从 Selection 或 Range对象访问 Find对象时,查找操作会略有不同。 查找并选定文字 如果从 Selection对象访问 Find...

    通过Find 和Replacement对象可实现查找和替换功能。Selection 和Range对象可以使用 Find对象。从 Selection 或 Range对象访问 Find对象时,查找操作会略有不同。

    查找并选定文字

    如果从 Selection对象访问 Find对象,当找到搜索条件时,就会更改所选内容。下列示例选定下一个出现的“Hello”。如果到达文档结尾时仍未找到“Hello”,则停止搜索。

     

    With Selection.Find

        .Forward = True

        .Wrap = wdFindStop

        .Text = "Hello"

        .Execute

    End With

    Find对象包含与“查找和替换”对话框中的选项相关的属性(在“编辑”菜单上选择“查找”可显示该对话框)。可以设置 Find对象单独的属性或使用Execute方法的参数,如下例所示。

     

    Selection.Find.Execute FindText:="Hello", _

        Forward:=True, Wrap:=wdFindStop

    查找文字,但不更改所选内容

    如果从 Range对象访问 Find对象,则找到搜索条件时,不更改所选内容,但是会重新定义 Range对象。下列示例在活动文档中查找第一个出现的“blue”。如果找到该单词,则重新定义该区域,并将加粗格式应用于单词“blue”。

     

    With ActiveDocument.Content.Find

        .Text = "blue"

        .Forward = True

        .Execute

        If .Found = True Then .Parent.Bold = True

    End With

    下列示例使用 Execute方法的参数,执行结果与上例相同。

     

    Set myRange = ActiveDocument.Content

    myRange.Find.Execute FindText:="blue", Forward:=True

    If myRange.Find.Found = True Then myRange.Bold = True

    使用 Replacement对象

    Replacement对象代表查找和替换操作的替换条件。Replacement对象的属性和方法对应于“查找和替换”对话框中的选项(单击“编辑”菜单中的“查找”或“替换”命令可显示该对话框)。

    可通过 Find对象使用 Replacement对象。下列示例将所有单词“hi”替换为“hello”。由于 Find对象是通过 Selection对象访问的,所以当找到搜索条件时,会更改所选内容。

     

    With Selection.Find

        .ClearFormatting

        .Text = "hi"

        .Replacement.ClearFormatting

        .Replacement.Text = "hello"

        .Execute Replace:=wdReplaceAll, Forward:=True, _

            Wrap:=wdFindContinue

    End With

    下列示例取消活动文档中的加粗格式。Find对象的Bold属性为 True,而 Replacement对象的该属性为 False。若要查找并替换格式,可将查找和替换文字设为空字符串 (""),并将 Execute方法的 Format参数设为 True。由于从 Range对象访问 Find对象,所选内容将保持不变(Content属性返回一个 Range对象)。

     

    With ActiveDocument.Content.Find

        .ClearFormatting

        .Font.Bold = True

        With .Replacement

            .ClearFormatting

            .Font.Bold = False

        End With

        .Execute FindText:="", ReplaceWith:="", _

            Format:=True, Replace:=wdReplaceAll

    End With

     

    展开全文
  • c#对word操作的查找替换功能

    千次阅读 2009-10-19 13:07:00
    wdFindAsk 搜索完选定内容或者区域后,Microsoft Word 会显示一条消息,询问是否搜索文档的其他部分。 wdFindContinue 到达搜索区域的开始或者结尾时,继续执行查找操作。 wdFindStop 到达搜索区域的开始...

    expression.Execute(FindText,   MatchCase,   MatchWholeWord,   MatchWildcards,   MatchSoundsLike,   MatchAllWordForms,   Forward,   Wrap,   Format,   ReplaceWith,   Replace,   MatchKashida,   MatchDiacritics,   MatchAlefHamza,   MatchControl)
    expression           必需。该表达式返回   Find   对象。

    FindText         Variant   类型,可选。指定需搜索的文本。可用空字符串   ( " ")   搜索格式,也可通过指定相应的字符代码搜索特殊字符。例如,“^p”对应段落标记,“^t”对应制表符。有关可以使用的特殊字符列表,请参阅查找和替换文 本或其他项。

    MatchCase           Variant   类型,可选。如果为   True,则指定查找文本区分大小写。相当于“编辑”菜单“查找和替换”对话框中的“区分大小写”复选框。

    MatchWholeWord           Variant   类型,可选。如果为   True,则查找操作只定位于完全匹配的单词,而并非长单词中的部分文字。相当于“查找和替换”对话框中的“全字匹配”复选框。

    MatchWildcards           Variant   类型,可选。如果为   True,则查找的文字包含特殊搜索操作符。相当于“查找和替换”对话框中的“使用通配符”复选框。

    MatchSoundsLike           Variant   类型,可选。如果为   True,则查找操作定位于与要查找的文字发音相近的单词。相当于“查找和替换”对话框中的“同音”复选框。

    MatchAllWordForms           Variant   类型,可选。如果为   True,则查找操作定位于要查找的文字的所有形式(例如,查找“sit”的同时,还查找“sitting”和“sat”),相当于“查找和替换”对话框 中的“查找单词的各种形式”复选框。

    Forward           Variant   类型,可选。如果为   True,则向下(向文档尾部)搜索。

    Wrap         Variant   类型,可选。如果搜索从不是文档的起始位置开始,并已搜索到文档的末尾(如   Forward   设置为   False,则相反),用本参数控制接下来的操作。当存在选定内容或区域,而又没有在该选定内容或区域中找到搜索文字时,也可用本参数控制接下来的操作。 可取下列   WdFindWrap   常量之一。

    WdFindWrap   可以是下列   WdFindWrap   常量之一:  
    wdFindAsk   搜索完选定内容或者区域后,Microsoft   Word   会显示一条消息,询问是否搜索文档的其他部分。  
    wdFindContinue   到达搜索区域的开始或者结尾时,继续执行查找操作。  
    wdFindStop   到达搜索区域的开始或者结尾时,停止执行查找操作。  

    Format           Variant   类型,可选。如果为   True,则查找操作定位于格式或带格式的文本,而不是查找文本。

    ReplaceWith           Variant   类型,可选。替换文字。若要删除由   Find   参数指定的文字,可使用空字符串   ( " ")。与   Find   参数相似,本参数也可以指定特殊的字符和高级搜索条件。若要将图形对象或者其他非文本项指定为替换内容,可将这些项置于“剪贴板”上,然后将   ReplaceWith   指定为“^c”。

    Replace         Variant   类型,可选。指定执行替换的个数:一个、全部或者不替换。可取下列   WdReplace   常量之一。

    WdReplace   可以是下列   WdReplace   常量之一:  
    wdReplaceAll  
    wdReplaceNone  
    wdReplaceOne  

    MatchKashida           Variant   类型,可选。如果为   True,则查找结果应与阿拉伯语文档中区分   kashidas   的文本相匹配。由于选择或安装的语言支持不同(例如,英语(美国)),此参数可能不可用。

    MatchDiacritics           Variant   类型,可选。如果为   True,则查找操作在从右向左的语言的文档中按照匹配音调符号来匹配文字。由于选择或安装的语言支持不同(例如,英语(美国)),此参数可能不可用。

    MatchAlefHamza           Variant   类型,可选。如果为   True,则在阿拉伯语文档中,查找内容应与区分   Alef   Hamzas   的文本相匹配。由于选择或安装的语言支持不同(例如,英语(美国)),此参数可能不可用。

    MatchControl           Variant   类型,可选。如果为   True,则在从右向左的语言的文档中,查找内容应与区分双向控制字符的文本相匹配。由于选择或安装的语言支持不同(例如,英语(美国)),此参数可能不可用。

    说明
    如果   MatchWildcards   为   True,可为   FindText   参数指定通配符和其他高级搜索准则,例如,“*(ing)”查找任何以“ing”结尾的单词。

    若要搜索符号字符,可键入脱字符号   (^)、零   (0),然后键入符号字符的代码。例如,“^0151”对应一条长划线   (—)。

    除非另外指定,否则替换文本将沿用文档中被替换文本的格式。例如,如果用“xyz”替换字符串“abc”,那么加粗“abc”将被加粗字符串“xyz”所替换。

    另外,如果   MatchCase   为   False,那么查找到的大写文本将被大写的替换文本替换,而无论搜索文本和替换文本是否大小写。上例中,“ABC”将被“XYZ”替换。

     

     

    Replace         Variant   类型,可选。指定执行替换的个数:一个、全部或者不替换。可取下列   WdReplace   常量之一。

    WdReplace   可以是下列   WdReplace   常量之一:  
    wdReplaceAll  
    wdReplaceNone  
    wdReplaceOne  

    这样赋值就可以了
    object   Replace=Microsoft.Office.Interop.Word.WdReplace.wdReplaceAll;

     

     

     

    mWordapp.ActiveWindow.ActivePane.Selection.Find.Execute("check word", novalue, novalue, novalue, novalue, novalue, novalue, novalue, novalue, "replace word", Word.WdReplace.wdReplaceAll, novalue, novalue, novalue, novalue)

    展开全文
  • 比如要替换掉所有的以//DEL开头的行   //DEL*^13{1} 替换为什么也不输入  ([^11^13]){1} 匹配一个换段符(^13,在文档里面是直接键入ENTER得到)或者一个段内换行符(^11,在文档里面键入SHIFT+ENTER得到)...
  • 1.如何在word选定区域中去掉所有的汉字 在下面区域中想要保留数字作为数据,如何去掉汉字: 进入查找页面,输入 [一-龥](中括号一定要有!),点击高级替换 把使用通配符选择上: 点击确定,即可去掉: 2.如何...
  • word使用技巧大全

    热门讨论 2011-03-18 20:37:53
    ★在Word2002中选择多个文档区域 15 ★禁用智能标记 15 ★WORD字体随身携带 15 ★为WORD文本加注解 16 ★快速输入特定的短语 16 ★特殊符号的输入 17 ★使用通配符进行模糊替换 17 ★Word文档与RTF文档的互换问题 17...
  • word技巧

    千次阅读 2018-03-01 21:40:22
    word 高效经典教程(整理版)目录一分钟驾驭word 高效经典教程(整理版)... 6A、基础知识... 61、度量单位... 62、WORD中文字字号与磅的对应关系... 63、字体文件格式... 7B、文本编辑... 71、快速移动文档... 72、...
  • 在“文件”的“打开”对话框中,选定文件名后右击,选择“打印”可不打开文件而快速打印Word文档。  9. 选定多边形后右击,选择弹出菜单中的“编辑顶点”,按Ctrl不放,单击连线可增加顶点,单击顶点则删除该顶点...
  • 计算机类009-Word的快捷键集锦.doc (2页) 本资源提供全文预览,点击全文预览即可... Ctrl+/ 快速选定整个表格Ctrl+S保存当前文档Ctrl+F2打印预览Ctrl+U给所选内容加下划线Ctrl+P打印文档Ctrl+W关闭当前文档F1Word ...
  • word 快捷键

    2018-06-12 12:19:26
    选定加粗的字体, 之后点击右上角的 查找 下拉 的高级查找 , 之后 点击格式 ,之后选择 加粗 , 之后把所选的文字全部删去,之后点击查找就可以了 2.保存样式: 3.快速设置标题1、标题2: ctrl+alt+1/2 ...
  • word使用技巧

    2014-01-14 10:53:09
    说明:“^c”的意思就是指令WordXP以剪贴板中的内容替换“查找内容”框中的内 容。按此原理,“^c”还可替换包括回车符在内的任何可以复制到剪贴板的可视内容,甚至Excel表格。 三招去掉页眉那条
  • Word2010练习题一、选择题1.使用Word 2010建立的文档,其默认扩展名为( )。A. TXTB. XLSXC. DOCXD. PNG2.通常情况下,下列选项中不能用于启动Word 2010的操作是( )。A.双击Windows桌面上的Word 2010快捷方式图标B....
  • Word快捷键大全

    2017-07-01 15:44:23
    Word软件对于我们办公来说,是不可缺少的办公软件,因为没有它我们可能无法进行许多任务。所以现在的文员和办公室工作的人,最基础的就是会熟悉的使用Office办公软件。 在此,为提高大家Word使用水平,Office办公...
  • word 2016 操作界面:由 文件 按钮,快速访问工具栏、标题栏、功能区(选项卡和命令组)、标尺、共享,页面区域、滚动条、状态栏组成; ## 不同版本之间的兼容问题 ### 出现兼容问题的原因 ### 保存不同版本文件...
  • Word文本编辑

    2020-06-10 16:21:07
    1.单击选定栏是选中一行,双击是选中一段,三击是选中全文。 2.全选快捷键:Ctrl+A。 3.撤销快捷键:Ctrl+Z。(可以多步撤销) 剪切和复制 1.剪切快捷键:Ctrl+X 2.复制快捷键:Ctrl+c 3.粘贴快捷键,Ctrl+v 4
  • 1、即时取消 Word 的后台打印当我们刚刚编辑完一篇文档按了打印命令后,后来又不想打印当前的文档了,那么怎样才能即时取消后台打印任务呢?一般来说,大家在发出打印任务后,程序会自动将打印任务设置为后台打印,...
  • 职称计算机辅导:巧用word中多级列表 word巧用多级列表功能编号技巧,实际上多级列表与加项目符号或编号列表相似,但是多级列表中每段的项目符号或编号根据段落的缩进范围而变化。多级列表是在段落缩进的基础上使用...
  • Word用法

    2009-10-28 00:53:00
    说明:“^c”的意思就是指令WordXP以剪贴板中的内容替换“查找内容”框中的内 容。按此原理,“^c”还可替换包括回车符在内的任何可以复制到剪贴板的可视内容,甚至Excel表格。 三招去掉页眉那...
  • word应用

    2008-12-03 16:39:00
    把文字替换成图片首先把图片复制到 剪贴...说明:“^c”的意思就是指令WordXP以剪贴板中的内容替换“查找内容”框中的内 容。按此原理,“^c”还可替换包括回车符在内的任何可以复制到剪贴板的可视内容,甚至Excel表格。
  • Word常用技巧

    2019-06-25 08:54:23
      文章包括一些Word常用技巧,为日常学习、工作中总结,之后会陆续更新完善。(实例以 Word2013 环境为基础) 1 Word从非第一页编辑页码 鼠标放在目标页码(编辑后成为第一页)首行。 打开“页面布局”→“分隔...
  • WORD技巧

    2008-02-22 08:53:22
    把文字替换成图片 ...说明:“^c”的意思就是指令Word XP以剪贴板中的内容替换“查找内容”框中的内 容。按此原理,“^c”还可替换包括回车符在内的任何可以复制到剪贴板的可视内容,甚至Excel表...
  • java word操作总结

    千次阅读 2014-09-19 09:36:43
    java word操作总结
  • WORD经典实用!

    千次阅读 2016-07-21 17:30:31
    WORD经典实用!较全面!
  • VC++ 操作Word(使用微软office控件)

    千次阅读 2019-03-04 23:25:33
    你可以实现诸如:Word文件打印、传送数据到Word文档、发送E-MAIL、自动产生表格、Excel数据统计、圆饼图,直方图显示、自动报表生成、播放幻灯、doc,txt,HTML,rtf文件转换、中文简繁体转换、拼音或笔画排序.........
  • 多选题1、Word文档中,不能实现选定全文内容的操作是____。A.按Shift+A键 B.在文档左侧用鼠标连续三次单击C.按Alt+A键 D.将光标移至文档首,再在文尾档按Shift+单击2、Word文档中,要将其中一部分内容复制到文中...
  • Word快捷键

    2020-03-19 13:51:44
    Word中显示和使用窗口的快捷键 切换到下一个窗口。 Alt+Tab 切换到上一个窗口。 Alt+Shift+Tab 关闭活动窗口。 Ctrl+W 或 Ctrl+F4 在将活动窗口最大化后再还原其大小。 Alt+F5 从程序窗口中的一个任务...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,741
精华内容 2,296
关键字:

word选定区域替换