go_dreamfactory/cmd/v2/ui/app_testcase.go

package ui

import (
	"fmt"
	"go_dreamfactory/cmd/v2/lib/common"
	"go_dreamfactory/cmd/v2/model"
	"go_dreamfactory/cmd/v2/service/observer"
	"go_dreamfactory/cmd/v2/ui/formview"
	"go_dreamfactory/comm"
	"go_dreamfactory/modules/hero"
	"go_dreamfactory/modules/task"
	"go_dreamfactory/modules/user"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/layout"
	"fyne.io/fyne/v2/theme"
	"fyne.io/fyne/v2/widget"
	"github.com/sirupsen/logrus"
)

// register views
var (
	viewRegister = map[string]MyCaseView{
		//user
		ff(comm.ModuleUser, user.UserSubTypeModifyName): &formview.UserModifynameView{},
		//task
		ff(comm.ModuleTask, task.TaskSubTypeList):          &formview.TaskListView{},
		ff(comm.ModuleTask, task.TaskSubTypeReceive):       &formview.TaskReceiveView{},
		ff(comm.ModuleTask, task.TaskSubTypeActiveList):    &formview.TaskActiveListView{},
		ff(comm.ModuleTask, task.TaskSubTypeActiveReceive): &formview.TaskActiveReceiveView{},
		// hero
		ff(comm.ModuleHero, hero.HeroSubTypeList):  &formview.HeroListView{},
		ff(comm.ModuleHero, hero.StrengthenUplv):   &formview.HeroStrengthenUplvView{},
		ff(comm.ModuleHero, hero.StrengthenUpStar): &formview.HeroStrengthenUpStarView{},
	}
)

type appTester struct {
	appAdapter
}

func (a *appTester) GetAppName() string {
	return common.TOOLBAR_TESTER
}

func (a *appTester) disEnabled(t *model.TestCase) bool {
	return !t.Enabled
}

func (a *appTester) LazyInit(obs observer.Observer) error {
	a.tabItem = container.NewTabItemWithIcon(common.TOOLBAR_TESTER, theme.AccountIcon(), nil)

	content := container.NewMax()
	title := widget.NewLabel(common.APP_TESTCASE_TITLE)
	intro := widget.NewLabel("")
	intro.Wrapping = fyne.TextWrapWord
	caseContent := container.NewBorder(
		container.NewVBox(title, widget.NewSeparator(), intro), nil, nil, nil, content)

	setNav := func(t *model.TestCase) {
		viewKey := fmt.Sprintf("%s.%s", t.MainType, t.SubType)
		title.SetText(fmt.Sprintf("%s : %s", common.APP_TESTCASE_LABEL_PATH, viewKey))
		intro.SetText(t.Desc)
		content.Objects = []fyne.CanvasObject{}

		if view, ok := viewRegister[viewKey]; ok {
			view.Init()
			resLog := widget.NewMultiLineEntry()
			obs.AddListener(observer.EVENT_APP_LOG, observer.Listener{
				OnNotify: func(data interface{}, args ...interface{}) {
					if data == nil {
						return
					}
					resLog.SetText(data.(string))
				},
			})

			resLog.Wrapping = fyne.TextWrapBreak
			formReq := view.CreateForm(t)
			// required! Refresh updates the widget
			formReq.Refresh()
			formCard := widget.NewCard("", "", formReq)
			pos := widget.NewLabel("")
			clearBtn := widget.NewButtonWithIcon(common.APP_TESTCASE_BTN_CLEARLOG, theme.DeleteIcon(), func() {
				resLog.SetText("")
			})
			resPanel := container.NewBorder(container.NewHBox(clearBtn, layout.NewSpacer(), pos), nil, nil, nil, resLog)

			panel := container.NewVSplit(
				formCard,
				resPanel,
			)
			content.Objects = append(content.Objects, panel)
		} else {
			logrus.WithFields(logrus.Fields{"mainType": t.MainType, "subType": t.SubType}).Warn("no view")
		}

		content.Refresh()
	}
	split := container.NewHSplit(a.makeNav(setNav), caseContent)
	split.Offset = 0.2
	a.tabItem.Content = split
	return nil
}

func (a *appTester) makeNav(setNav func(testCase *model.TestCase)) fyne.CanvasObject {
	tree := &widget.Tree{
		ChildUIDs: func(uid string) (c []widget.TreeNodeID) {
			return CaseIndex[uid]
		},
		IsBranch: func(uid string) bool {
			children, ok := CaseIndex[uid]
			return ok && len(children) > 0
		},
		CreateNode: func(branch bool) fyne.CanvasObject {
			return widget.NewLabel("(empty)")
		},
		UpdateNode: func(uid string, branch bool, obj fyne.CanvasObject) {
			t, ok := CaseNav[uid]
			if !ok {
				logrus.WithField("id", uid).Warnf("Missing tutorial panel")
				return
			}
			if a.disEnabled(t) {
				obj.(*widget.Label).TextStyle = fyne.TextStyle{Italic: true}
				if branch {
					obj.(*widget.Label).SetText(fmt.Sprintf("%s(dis)", t.MainType))
				} else {
					obj.(*widget.Label).SetText(fmt.Sprintf("%s(dis)", t.SubType))
				}
			} else {
				obj.(*widget.Label).TextStyle = fyne.TextStyle{}
				if branch {
					obj.(*widget.Label).SetText(t.MainType)
				} else {
					obj.(*widget.Label).SetText(t.SubType)
				}

			}
		},
		OnSelected: func(uid string) {
			if t, ok := CaseNav[uid]; ok {
				logrus.WithFields(logrus.Fields{"mainType": t.MainType, "subType": t.SubType}).Debug("select")
				if a.disEnabled(t) {
					return
				}
				if t.SubType == "" {
					return
				}

				setNav(t)
			}
		},
	}
	return container.NewBorder(nil, nil, nil, nil, tree)
}