baliance.com/gooxml/document不支持读取word文档中的表格内容，不支持doc格式，仅支持docx格式

╰半夏微凉° 2022-11-15 12:56 216阅读 0赞

package main
    
    import (
    	"fmt"
    	"log"
    
    	"baliance.com/gooxml/document"
    )
    
    
    func main() {
    	readWord3()
    }
    
    func readWord3() {
    	doc, err := document.Open("./test2.docx")
    	if err != nil {
    		log.Fatalf("error opening document: %s", err)
    	}
    	//doc.Paragraphs()得到包含文档所有的段落的切片
    	for i, para := range doc.Paragraphs() {
    		//run为每个段落相同格式的文字组成的片段
    		fmt.Println("-----------第", i, "段-------------")
    		for j, run := range para.Runs() {
    			fmt.Print("\t-----------第", j, "格式片段-------------")
    			fmt.Print(run.Text())
    
    		}
    		fmt.Println()
    	}
    }
    
    func readWord(wordFilePath string) {
    	doc, err := document.Open(wordFilePath)
    	if err != nil {
    		log.Fatalf("error opening document: %s", err)
    	}
    	//doc.Paragraphs()得到包含文档所有的段落的切片
    	for i, para := range doc.Paragraphs() {
    		//run为每个段落相同格式的文字组成的片段
    		fmt.Println("-----------第", i, "段-------------")
    		for j, run := range para.Runs() {
    			fmt.Print("\t-----------第", j, "格式片段-------------")
    			fmt.Print(run.Text())
    
    		}
    		fmt.Println()
    	}
    }

package main
    
    import (
    	"fmt"
    	"io"
    	"log"
    	"os"
    	"strings"
    
    	"baliance.com/gooxml/document"
    	"github.com/lxn/walk"
    )
    
    type MyMainWindow struct {
    	*walk.MainWindow
    	edit *walk.TextEdit
    }
    
    func main() {
    	readWord("TEST.docx")
    	return
    	mw := &MyMainWindow{}
    	err := MainWindow{
    		AssignTo: &mw.MainWindow, //窗口重定向至mw，重定向后可由重定向变量控制控件
    		//Icon:     "test.ico",     //窗体图标
    		Title:    "XXXXXXX工具",      //标题
    		MinSize:  Size{Width: 150, Height: 200},
    		Size:     Size{300, 400},
    		Layout:   VBox{}, //样式，纵向
    		Children: []Widget{ //控件组
    			TextEdit{
    				AssignTo: &mw.edit,
    			},
    			PushButton{
    				Text:      "打开",
    				OnClicked: mw.selectFile, //点击事件响应函数
    			},
    			PushButton{
    				Text:      "生成",
    				OnClicked: mw.saveFile,
    			},
    		},
    	}.Create() //创建
    
    	if err != nil {
    		fmt.Fprintln(os.Stderr, err)
    		os.Exit(1)
    	}
    
    	mw.Run() //运行
    }
    
    func (mw *MyMainWindow) selectFile() {
    
    	dlg := new(walk.FileDialog)
    	dlg.Title = "选择文件"
    	dlg.Filter = "word文件 (*.doc)|*.doc|word文件 (*.docx)|*.docx"
    
    	mw.edit.SetText("") //通过重定向变量设置TextEdit的Text
    	if ok, err := dlg.ShowOpen(mw); err != nil {
    		mw.edit.AppendText("Error : File Open\r\n")
    		return
    	} else if !ok {
    		mw.edit.AppendText("Cancel\r\n")
    		return
    	}
    	s := fmt.Sprintf("%s", dlg.FilePath)
    	mw.edit.AppendText(s)
    }
    
    func (mw *MyMainWindow) saveFile() {
    
    	dlg := new(walk.FileDialog)
    	dlg.Title = "另存为"
    
    	if ok, err := dlg.ShowSave(mw); err != nil {
    		fmt.Fprintln(os.Stderr, err)
    		return
    	} else if !ok {
    		fmt.Fprintln(os.Stderr, "Cancel")
    		return
    	}
    
    	data := mw.edit.Text()
    	readWord(data)
    	filename := dlg.FilePath
    	f, err := os.Open(filename)
    	if err != nil {
    		f, _ = os.Create(filename)
    	} else {
    		f.Close()
    		//打开文件，参数：文件路径及名称，打开方式，控制权限
    		f, err = os.OpenFile(filename, os.O_WRONLY, 0x666)
    	}
    	if len(data) == 0 {
    		f.Close()
    		return
    	}
    	io.Copy(f, strings.NewReader(data))
    	f.Close()
    }
    
    func readWord2(wordFilePath string) {
    	doc, err := document.Open(wordFilePath)
    	if err != nil {
    		log.Fatalf("error opening document: %s", err)
    	}
    	//doc.Paragraphs()得到包含文档所有的段落的切片
    	for i, para := range doc.Paragraphs() {
    		//run为每个段落相同格式的文字组成的片段
    		fmt.Println("-----------第", i, "段-------------")
    		for j, run := range para.Runs() {
    			fmt.Print("\t-----------第", j, "格式片段-------------")
    			fmt.Print(run.Text())
    
    		}
    		fmt.Println()
    	}
    }

// Copyright 2013 The Walk Authors. All rights reserved.
    // Use of this source code is governed by a BSD-style
    // license that can be found in the LICENSE file.
    
    package main
    
    import (
    	"fmt"
    	"log"
    	"time"
    
    	"github.com/lxn/walk"
    
    	. "github.com/lxn/walk/declarative"
    )
    
    func main() {
    	walk.AppendToWalkInit(func() {
    		walk.FocusEffect, _ = walk.NewBorderGlowEffect(walk.RGB(0, 63, 255))
    		walk.InteractionEffect, _ = walk.NewDropShadowEffect(walk.RGB(63, 63, 63))
    		walk.ValidationErrorEffect, _ = walk.NewBorderGlowEffect(walk.RGB(255, 0, 0))
    	})
    
    	var mw *walk.MainWindow
    	var outTE *walk.TextEdit
    
    	animal := new(Animal)
    
    	if _, err := (MainWindow{
    		AssignTo: &mw,
    		Title:    "Walk Data Binding Example",
    		MinSize:  Size{300, 200},
    		Layout:   VBox{},
    		Children: []Widget{
    			PushButton{
    				Text: "Edit Animal",
    				OnClicked: func() {
    					if cmd, err := RunAnimalDialog(mw, animal); err != nil {
    						log.Print(err)
    					} else if cmd == walk.DlgCmdOK {
    						outTE.SetText(fmt.Sprintf("%+v", animal))
    					}
    				},
    			},
    			Label{
    				Text: "animal:",
    			},
    			TextEdit{
    				AssignTo: &outTE,
    				ReadOnly: true,
    				Text:     fmt.Sprintf("%+v", animal),
    			},
    		},
    	}.Run()); err != nil {
    		log.Fatal(err)
    	}
    }
    
    type Animal struct {
    	Name          string
    	ArrivalDate   time.Time
    	SpeciesId     int
    	Speed         int
    	Sex           Sex
    	Weight        float64
    	PreferredFood string
    	Domesticated  bool
    	Remarks       string
    	Patience      time.Duration
    }
    
    func (a *Animal) PatienceField() *DurationField {
    	return &DurationField{&a.Patience}
    }
    
    type Species struct {
    	Id   int
    	Name string
    }
    
    func KnownSpecies() []*Species {
    	return []*Species{
    		{1, "Dog"},
    		{2, "Cat"},
    		{3, "Bird"},
    		{4, "Fish"},
    		{5, "Elephant"},
    	}
    }
    
    type DurationField struct {
    	p *time.Duration
    }
    
    func (*DurationField) CanSet() bool       { return true }
    func (f *DurationField) Get() interface{} { return f.p.String() }
    func (f *DurationField) Set(v interface{}) error {
    	x, err := time.ParseDuration(v.(string))
    	if err == nil {
    		*f.p = x
    	}
    	return err
    }
    func (f *DurationField) Zero() interface{} { return "" }
    
    type Sex byte
    
    const (
    	SexMale Sex = 1 + iota
    	SexFemale
    	SexHermaphrodite
    )
    
    func RunAnimalDialog(owner walk.Form, animal *Animal) (int, error) {
    	var dlg *walk.Dialog
    	var db *walk.DataBinder
    	var acceptPB, cancelPB *walk.PushButton
    
    	return Dialog{
    		AssignTo:      &dlg,
    		Title:         Bind("'Animal Details' + (animal.Name == '' ? '' : ' - ' + animal.Name)"),
    		DefaultButton: &acceptPB,
    		CancelButton:  &cancelPB,
    		DataBinder: DataBinder{
    			AssignTo:       &db,
    			Name:           "animal",
    			DataSource:     animal,
    			ErrorPresenter: ToolTipErrorPresenter{},
    		},
    		MinSize: Size{300, 300},
    		Layout:  VBox{},
    		Children: []Widget{
    			Composite{
    				Layout: Grid{Columns: 2},
    				Children: []Widget{
    					Label{
    						Text: "Name:",
    					},
    					LineEdit{
    						Text: Bind("Name"),
    					},
    
    					Label{
    						Text: "Arrival Date:",
    					},
    					DateEdit{
    						Date: Bind("ArrivalDate"),
    					},
    
    					Label{
    						Text: "Species:",
    					},
    					ComboBox{
    						Value:         Bind("SpeciesId", SelRequired{}),
    						BindingMember: "Id",
    						DisplayMember: "Name",
    						Model:         KnownSpecies(),
    					},
    
    					Label{
    						Text: "Speed:",
    					},
    					Slider{
    						Value: Bind("Speed"),
    					},
    
    					RadioButtonGroupBox{
    						ColumnSpan: 2,
    						Title:      "Sex",
    						Layout:     HBox{},
    						DataMember: "Sex",
    						Buttons: []RadioButton{
    							{Text: "Male", Value: SexMale},
    							{Text: "Female", Value: SexFemale},
    							{Text: "Hermaphrodite", Value: SexHermaphrodite},
    						},
    					},
    
    					Label{
    						Text: "Weight:",
    					},
    					NumberEdit{
    						Value:    Bind("Weight", Range{0.01, 9999.99}),
    						Suffix:   " kg",
    						Decimals: 2,
    					},
    
    					Label{
    						Text: "Preferred Food:",
    					},
    					ComboBox{
    						Editable: true,
    						Value:    Bind("PreferredFood"),
    						Model:    []string{"Fruit", "Grass", "Fish", "Meat"},
    					},
    
    					Label{
    						Text: "Domesticated:",
    					},
    					CheckBox{
    						Checked: Bind("Domesticated"),
    					},
    
    					VSpacer{
    						ColumnSpan: 2,
    						Size:       8,
    					},
    
    					Label{
    						ColumnSpan: 2,
    						Text:       "Remarks:",
    					},
    					TextEdit{
    						ColumnSpan: 2,
    						MinSize:    Size{100, 50},
    						Text:       Bind("Remarks"),
    					},
    
    					Label{
    						ColumnSpan: 2,
    						Text:       "Patience:",
    					},
    					LineEdit{
    						ColumnSpan: 2,
    						Text:       Bind("PatienceField"),
    					},
    				},
    			},
    			Composite{
    				Layout: HBox{},
    				Children: []Widget{
    					HSpacer{},
    					PushButton{
    						AssignTo: &acceptPB,
    						Text:     "OK",
    						OnClicked: func() {
    							if err := db.Submit(); err != nil {
    								log.Print(err)
    								return
    							}
    
    							dlg.Accept()
    						},
    					},
    					PushButton{
    						AssignTo:  &cancelPB,
    						Text:      "Cancel",
    						OnClicked: func() { dlg.Cancel() },
    					},
    				},
    			},
    		},
    	}.Run(owner)
    }

github.com/lxn/walk   这个包可以较好地支持桌面GUI