fix: 被git ignore意外忽略的文件

.gitignore

 *.pro.user
 .idea
 pc/vendor
-moc*
+pc/gui/comp/moc*
 *.autosave
-rcc*
+pc/gui/qml/rcc*
 qml.rcc
 gui-plugin.so
 .env
 /demo
 *.pb.go
-deploy
\ No newline at end of file
+pc/deploy
\ No newline at end of file

pc/go.sum

@@ -9,6 +9,7 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
 github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
+github.com/peterq/pan-light v0.0.0-20190510064049-f484f3c3e893 h1:KBS0VnMndErSB/ytAsV5DBMrUM9dg+P8W0OLcUqpsIY=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

qt/tool-chain/cmd/moc/test/qtmoc_imports.go

+package qtmoc
+
+import _ "github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub"

qt/tool-chain/cmd/moc/test/sub/b/b.go

+package b
+
+import "github.com/peterq/pan-light/qt/core"
+
+type StructSubGoB struct{}
+type StructSubMocB struct{ core.QObject }

qt/tool-chain/cmd/moc/test/sub/bgo/bgo.go

+package bgo
+
+type StructSubGoBGo struct{}

qt/tool-chain/cmd/moc/test/sub/c/c.go

+package c
+
+import "github.com/peterq/pan-light/qt/core"
+
+type StructSubGoC struct{}
+type StructSubMocC struct{ core.QObject }

qt/tool-chain/cmd/moc/test/sub/cgo/cgo.go

+package cgo
+
+type StructSubGoCGo struct{}

qt/tool-chain/cmd/moc/test/sub/d/d.go

+package d
+
+import "github.com/peterq/pan-light/qt/core"
+
+type StructSubGoD struct{}
+type StructSubMocD struct{ core.QObject }

qt/tool-chain/cmd/moc/test/sub/dgo/dgo.go

+package dgo
+
+type StructSubGoDGo struct{}

qt/tool-chain/cmd/moc/test/sub/sub.go

+package sub
+
+import (
+	"github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/subsub"
+
+	"a" //vendor
+	"github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/b"
+	abc "github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/c"
+	. "github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/d"
+
+	"ago" //vendor
+	"github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/bgo"
+	abcgo "github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/cgo"
+	. "github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/dgo"
+)
+
+//TODO:  duplicate struct name issue
+
+type SubTestStruct struct {
+	subsubcustom.SubSubTestStruct
+
+	_ func() `constructor:"Init"`
+
+	_ func(string)        `signal:"someSignal"`
+	_ func(string) string `slot:"someSlot"`
+	_ string              `property:"someProperty"`
+
+	_ func(StructSameGo)  `signal:"sameSignal"`
+	_ func(*StructSameGo) `signal:"sameSignalR"`
+
+	_ func(b.StructSubGoB)  `signal:"subSignalb1"`
+	_ func(*b.StructSubGoB) `signal:"subSignalb1R"`
+
+	_ func(b.StructSubMocB)  `signal:"subSignalb2"`
+	_ func(*b.StructSubMocB) `signal:"subSignalb2R"`
+
+	_ func(bgo.StructSubGoBGo)  `signal:"subSignalb3"`
+	_ func(*bgo.StructSubGoBGo) `signal:"subSignalb3R"`
+
+	_ func(abc.StructSubGoC)  `signal:"subSignalc1"`
+	_ func(*abc.StructSubGoC) `signal:"subSignalc1R"`
+
+	_ func(abc.StructSubMocC)  `signal:"subSignalc2"`
+	_ func(*abc.StructSubMocC) `signal:"subSignalc2R"`
+
+	_ func(abcgo.StructSubGoCGo)  `signal:"subSignalc3"`
+	_ func(*abcgo.StructSubGoCGo) `signal:"subSignalc3R"`
+
+	_ func(StructSubGoD)  `signal:"subSignald1"`
+	_ func(*StructSubGoD) `signal:"subSignald1R"`
+
+	_ func(StructSubMocD)  `signal:"subSignald2"`
+	_ func(*StructSubMocD) `signal:"subSignald2R"`
+
+	_ func(StructSubGoDGo)  `signal:"subSignald3"`
+	_ func(*StructSubGoDGo) `signal:"subSignald3R"`
+}
+
+type SubTestStructNotUsed struct {
+	subsubcustom.SubSubTestStruct
+
+	_ func(a.StructSubGoA)  `signal:"vendorSignal1"`
+	_ func(*a.StructSubGoA) `signal:"vendorSignal1R"`
+
+	_ func(a.StructSubMocA)  `signal:"vendorSignal2"`
+	_ func(*a.StructSubMocA) `signal:"vendorSignal2R"`
+
+	_ func(ago.StructSubGoAGo)  `signal:"vendorSignal3"`
+	_ func(*ago.StructSubGoAGo) `signal:"vendorSignal3R"`
+}
+
+func (s *SubTestStruct) Init() {
+	s.SubSubConstructorProperty++
+}
+
+type StructSameGo struct {
+	somestring string
+}

qt/tool-chain/cmd/moc/test/sub/subb.go

+package sub
+
+import (
+	"github.com/peterq/pan-light/qt/core"
+
+	_ "github.com/peterq/pan-light/qt/tool-chain/cmd/moc/test/sub/subsub"
+)
+
+var SomeType *someType
+
+type someType struct {
+	core.QObject
+
+	_ bool   `property:"someBool,auto"`
+	_ string `property:"someString,auto"`
+
+	_ func(string) `signal:"someSignal,auto"`
+	_ func(string) `slot:"someSlot,auto"`
+
+	_ bool   `property:"someBoolB"`
+	_ string `property:"someStringB"`
+
+	_ func(string) `signal:"someSignalB"`
+	_ func(string) `slot:"someSlotB"`
+
+	_ string `property:"someSubProp,->(subsubcustom.SubSubTestStructInstance.subsubProperty)"`
+	_ string `property:"someSubPropA,<-(subsubcustom.SubSubTestStructInstance.subsubProperty)"`
+
+	_ func(string) `signal:"someSignalC,->(subsubcustom.SubSubTestStructInstance.subPropertySignal)"`
+	_ func(string) `slot:"someSlotC,->(subsubcustom.SubSubTestStructInstance.subPropertySlot)"`
+
+	_ func(string) `signal:"SomeSignalD,<-(subsubcustom.SubSubTestStructInstance.subPropertySignal)"`
+	_ func(string) `slot:"SomeSlotD,<-(subsubcustom.SubSubTestStructInstance.subPropertySlot)"`
+}
+
+func (t *someType) isSomeBool() bool     { return true }
+func (t *someType) setSomeBool(bool)     {}
+func (t *someType) someBoolChanged(bool) {}
+
+func (t *someType) someString() string       { return "test" }
+func (t *someType) setSomeString(string)     {}
+func (t *someType) someStringChanged(string) {}
+
+func (t *someType) someSignal(string) {}
+func (t *someType) someSlot(string)   {}
+
+type someOtherType struct {
+	core.QObject
+
+	_ func() `constructor:"init"`
+
+	_ bool   `property:"someBool,->(SomeType)"`
+	_ string `property:"someString,->(SomeType)"`
+
+	_ bool   `property:"someBoolA,->(SomeType.someBool)"`
+	_ string `property:"someStringA,->(SomeType.someString)"`
+
+	_ bool   `property:"someBoolB,<-(SomeType)"`
+	_ string `property:"someStringB,<-(SomeType)"`
+
+	_ bool   `property:"someBoolC,<-(SomeType.someBool)"`
+	_ string `property:"someStringC,<-(SomeType.someString)"`
+
+	_ func(string) `signal:"someSignal,->(SomeType)"`
+	_ func(string) `signal:"someSlot,->(SomeType)"`
+
+	_ func(string) `signal:"someSignalA,->(SomeType.someSignal)"`
+	_ func(string) `signal:"someSlotA,->(SomeType.someSlot)"`
+
+	_ func(string) `signal:"someSignalB,<-(SomeType)"`
+	_ func(string) `signal:"someSlotB,<-(SomeType)"`
+
+	_ func(string) `signal:"someSignalC,<-(SomeType.someSignal)"`
+	_ func(string) `signal:"someSlotC,<-(SomeType.someSlot)"`
+}
+
+func (t *someOtherType) init() { SomeType = NewSomeType(nil) }
+
+func (t *someOtherType) someSignalB(string) {}
+func (t *someOtherType) someSlotB(string)   {}
+
+func (t *someOtherType) someSignalC(string) {}
+func (t *someOtherType) someSlotC(string)   {}
+
+type someOtherTypeOut struct {
+	core.QObject
+
+	_ func() `constructor:"init"`
+
+	_ bool   `property:"someBool,->(this.c)"`
+	_ string `property:"someString,->(this.c)"`
+
+	_ bool   `property:"someBoolA,->(this.c.someBool)"`
+	_ string `property:"someStringA,->(this.c.someString)"`
+
+	_ func(string) `signal:"someSignal,->(this.c)"`
+	_ func(string) `signal:"someSlot,->(this.c)"`
+
+	_ func(string) `signal:"someSignalA,->(this.c.someSignal)"`
+	_ func(string) `signal:"someSlotA,->(this.c.someSlot)"`
+
+	c *someType
+}
+
+func (t *someOtherTypeOut) init() { t.c = NewSomeType(nil) }
+
+type someOtherTypeIn struct {
+	core.QObject
+
+	_ func() `constructor:"init"`
+
+	_ bool   `property:"someBool,<-(this.c)"`
+	_ string `property:"someString,<-(this.c)"`
+
+	_ bool   `property:"someBoolA,<-(this.c.someBool)"`
+	_ string `property:"someStringA,<-(this.c.someString)"`
+
+	_ func(string) `signal:"someSignal,<-(this.c)"`
+	_ func(string) `slot:"someSlot,<-(this.c)"`
+
+	_ func(string) `signal:"someSignalA,<-(this.c.someSignal)"`
+	_ func(string) `slot:"someSlotA,<-(this.c.someSlot)"`
+
+	_ func(string) `signal:"SomeSignalB,<-(this.c.someSignal)"`
+	_ func(string) `slot:"SomeSlotB,<-(this.c.someSlot)"`
+
+	c *someType
+}
+
+func (t *someOtherTypeIn) init() { t.c = NewSomeType(nil) }
+
+func (t *someOtherTypeIn) someSignal(string) {}
+func (t *someOtherTypeIn) someSlot(string)   {}
+
+func (t *someOtherTypeIn) someSignalA(string) {}
+func (t *someOtherTypeIn) someSlotA(string)   {}

qt/tool-chain/cmd/moc/test/sub/subsub/subsub.go

+package subsubcustom
+
+import "github.com/peterq/pan-light/qt/gui"
+
+var SubSubTestStructInstance *SubSubTestStruct
+
+type SubSubTestStruct struct {
+	gui.QWindow
+
+	_ func() `constructor:"Init"`
+
+	_ func(string) `signal:"subPropertySignal"`
+	_ func(string) `slot:"subPropertySlot"`
+
+	_ string `property:"subsubProperty"`
+
+	SubSubConstructorProperty int
+}
+
+func (s *SubSubTestStruct) Init() {
+	SubSubTestStructInstance = s
+	s.SubSubConstructorProperty++
+}

qt/tool-chain/cmd/moc/test/sub/vendor/a/a.go

+package a
+
+import "github.com/peterq/pan-light/qt/core"
+
+type StructSubGoA struct{}
+type StructSubMocA struct{ core.QObject }

qt/tool-chain/cmd/moc/test/sub/vendor/ago/ago.go

+package ago
+
+type StructSubGoAGo struct{}

qt/tool-chain/cmd/rcc/rcc.go

+package rcc
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+
+	"github.com/peterq/pan-light/qt/tool-chain/binding/templater"
+
+	"github.com/peterq/pan-light/qt/tool-chain/cmd"
+
+	"github.com/peterq/pan-light/qt/tool-chain/utils"
+)
+
+var (
+	ResourceNames      = make(map[string]string)
+	ResourceNamesMutex = new(sync.Mutex)
+)
+
+func Rcc(path, target, tagsCustom, output_dir string) {
+	if utils.UseGOMOD(path) {
+		if !utils.ExistsDir(filepath.Join(path, "vendor")) {
+			cmd := exec.Command("go", "mod", "vendor")
+			cmd.Dir = path
+			utils.RunCmd(cmd, "go mod vendor")
+		}
+	}
+
+	rcc(path, target, tagsCustom, output_dir, true)
+}
+
+func rcc(path, target, tagsCustom, output_dir string, root bool) {
+	utils.Log.WithField("path", path).WithField("target", target).Debug("start Rcc")
+
+	//TODO: cache non go asset (*.qml, ...) hashes in rcc.go files to indentify staled assets in cached go packages
+	//TODO: pure go.rcc for wasm/js targets
+
+	if root {
+		wg := new(sync.WaitGroup)
+		defer wg.Wait()
+		allImports := cmd.GetImports(path, target, tagsCustom, 0, false, false)
+		wg.Add(len(allImports))
+		for _, path := range allImports {
+			go func(path string) {
+				rcc(path, target, tagsCustom, path, false)
+				wg.Done()
+			}(path)
+		}
+	}
+
+	files, err := ioutil.ReadDir(path)
+	if err != nil {
+		utils.Log.WithError(err).Error("failed to read dir")
+		return
+	}
+	var hasQMLFiles bool
+	for _, file := range files {
+		if !file.IsDir() && file.Name() == "qml" && !file.Mode().IsRegular() {
+			hasQMLFiles = true
+			break
+		}
+		if file.IsDir() && file.Name() == "qml" {
+			hasQMLFiles = true
+			break
+		}
+		ext := filepath.Ext(file.Name())
+		if ext == ".qrc" || ext == ".qml" {
+			hasQMLFiles = true
+			break
+		}
+	}
+	if !hasQMLFiles {
+		return
+	}
+
+	rccQrc := filepath.Join(path, "rcc.qrc")
+
+	env, tags, _, _ := cmd.BuildEnv(target, "", "")
+	if tagsCustom != "" {
+		tags = append(tags, strings.Split(tagsCustom, " ")...)
+	}
+
+	pkgCmd := utils.GoList("{{.Name}}", fmt.Sprintf("-tags=\"%v\"", strings.Join(tags, "\" \"")))
+	pkgCmd.Dir = path
+	for k, v := range env {
+		pkgCmd.Env = append(pkgCmd.Env, fmt.Sprintf("%v=%v", k, v))
+	}
+
+	pkg := strings.TrimSpace(utils.RunCmd(pkgCmd, "run go list"))
+	if pkg == "" {
+		pkg = filepath.Base(path)
+	}
+
+	rccCpp := filepath.Join(path, "rcc.cpp")
+	if output_dir != "" {
+		rccCpp = filepath.Join(output_dir, "rcc.cpp")
+		templater.CgoTemplateSafe(pkg, output_dir, target, templater.RCC, "", "", []string{"Core"})
+	} else {
+		templater.CgoTemplateSafe(pkg, path, target, templater.RCC, "", "", []string{"Core"})
+	}
+
+	if dir := filepath.Join(path, "qml"); utils.ExistsDir(dir) {
+		rcc := exec.Command(utils.ToolPath("rcc", target), "-project", "-o", rccQrc)
+		rcc.Dir = dir
+		utils.RunCmd(rcc, fmt.Sprintf("execute rcc *.qrc on %v for %v", runtime.GOOS, target))
+
+		content := utils.Load(rccQrc)
+		content = strings.Replace(content, "<file>./", "<file>qml/", -1)
+		if utils.ExistsFile(filepath.Join(path, "qtquickcontrols2.conf")) {
+			content = strings.Replace(content, "<qresource>", "<qresource>\n<file>qtquickcontrols2.conf</file>", -1)
+		}
+		utils.Save(rccQrc, content)
+	}
+
+	files, err = ioutil.ReadDir(path)
+	if err != nil {
+		utils.Log.WithError(err).Fatal("failed to read dir")
+	}
+	var fileList []string
+	for _, file := range files {
+		if !file.IsDir() && filepath.Ext(file.Name()) == ".qrc" {
+			//TODO: check for buildTags
+			fileList = append(fileList, filepath.Join(path, file.Name()))
+		}
+	}
+
+	nameCmd := utils.GoList("{{.ImportPath}}", fmt.Sprintf("-tags=\"%v\"", strings.Join(tags, "\" \"")))
+	nameCmd.Dir = path
+	for k, v := range env {
+		nameCmd.Env = append(nameCmd.Env, fmt.Sprintf("%v=%v", k, v))
+	}
+
+	name := strings.TrimSpace(utils.RunCmd(nameCmd, "run go list"))
+	for _, s := range []string{"/", ".", "-"} {
+		name = strings.Replace(name, s, "_", -1)
+	}
+	ResourceNamesMutex.Lock()
+	ResourceNames[rccCpp] = name
+	ResourceNamesMutex.Unlock()
+
+	rcc := exec.Command(utils.ToolPath("rcc", target), "-name", name, "-o", rccCpp)
+	rcc.Args = append(rcc.Args, fileList...)
+	utils.RunCmd(rcc, fmt.Sprintf("execute rcc *.cpp on %v for %v", runtime.GOOS, target))
+
+	if utils.QT_DEBUG_QML() {
+		utils.Save("debug.pro", fmt.Sprintf("RESOURCES += %v", strings.Join(fileList, " ")))
+	}
+
+	if utils.QT_DOCKER() {
+		if idug, ok := os.LookupEnv("IDUG"); ok {
+			utils.RunCmd(exec.Command("chown", "-R", idug, path), "chown files to user")
+		}
+	}
+}

server/.gitignore

 /demo
-pan-light-server.yaml
\ No newline at end of file
+pan-light-server.yaml
+cmd/data
+static/
\ No newline at end of file