mirror of
https://github.com/mappu/miqt.git
synced 2024-12-23 09:28:36 +00:00
576 lines
18 KiB
Go
576 lines
18 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"go/format"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
RootWindowName = ""
|
|
DefaultGridMargin = 11
|
|
DefaultSpacing = 6
|
|
IconCounter = 0
|
|
)
|
|
|
|
func collectClassNames_Widget(u *UiWidget) []string {
|
|
var ret []string
|
|
if u.Name != "" {
|
|
ret = append(ret, u.Name+" *qt."+u.Class)
|
|
}
|
|
for _, w := range u.Widgets {
|
|
ret = append(ret, collectClassNames_Widget(&w)...)
|
|
}
|
|
if u.Layout != nil {
|
|
ret = append(ret, u.Layout.Name+" *qt."+u.Layout.Class)
|
|
for _, li := range u.Layout.Items {
|
|
if li.Widget != nil {
|
|
ret = append(ret, collectClassNames_Widget(li.Widget)...)
|
|
}
|
|
if li.Spacer != nil {
|
|
ret = append(ret, li.Spacer.Name+" *qt.QSpacerItem")
|
|
}
|
|
}
|
|
}
|
|
for _, a := range u.Actions {
|
|
ret = append(ret, a.Name+" *qt.QAction")
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func generateString(s *UiString, parentClass string) string {
|
|
if s.Notr || parentClass == "" {
|
|
return strconv.Quote(s.Value)
|
|
}
|
|
return `qt.` + parentClass + `_Tr(` + strconv.Quote(s.Value) + `)`
|
|
}
|
|
|
|
// qwidgetName creates the T.QWidget name that MIQT needs to access the base class.
|
|
func qwidgetName(name string, class string) string {
|
|
if name == "" {
|
|
return "nil"
|
|
}
|
|
if class == "QWidget" {
|
|
return name // It's already the right type
|
|
}
|
|
return name + ".QWidget"
|
|
}
|
|
|
|
func normalizeEnumName(s string) string {
|
|
if strings.HasPrefix(s, `Qt::`) {
|
|
s = s[4:]
|
|
}
|
|
|
|
return `qt.` + strings.Replace(s, `::`, `__`, -1)
|
|
}
|
|
|
|
func renderIcon(iconVal *UiIcon, ret *strings.Builder) string {
|
|
|
|
iconName := fmt.Sprintf("icon%d", IconCounter)
|
|
IconCounter++
|
|
|
|
ret.WriteString(iconName + " := qt.NewQIcon()\n")
|
|
|
|
// A base entry is a synonym for NormalOff. Don't need them both
|
|
if iconVal.NormalOff != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOff) + ", qt.NewQSize(), qt.QIcon__Normal, qt.QIcon__Off)\n")
|
|
} else {
|
|
ret.WriteString(iconName + ".AddFile(" + strconv.Quote(strings.TrimSpace(iconVal.Base)) + ")\n")
|
|
}
|
|
|
|
if iconVal.NormalOn != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOn) + ", qt.NewQSize(), qt.QIcon__Normal, qt.QIcon__On)\n")
|
|
}
|
|
if iconVal.ActiveOff != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOn) + ", qt.NewQSize(), qt.QIcon__Active, qt.QIcon__Off)\n")
|
|
}
|
|
if iconVal.ActiveOn != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOn) + ", qt.NewQSize(), qt.QIcon__Active, qt.QIcon__On)\n")
|
|
}
|
|
if iconVal.DisabledOff != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOn) + ", qt.NewQSize(), qt.QIcon__Disabled, qt.QIcon__Off)\n")
|
|
}
|
|
if iconVal.DisabledOn != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOn) + ", qt.NewQSize(), qt.QIcon__Disabled, qt.QIcon__On)\n")
|
|
}
|
|
if iconVal.SelectedOff != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOn) + ", qt.NewQSize(), qt.QIcon__Selected, qt.QIcon__Off)\n")
|
|
}
|
|
if iconVal.SelectedOn != nil {
|
|
ret.WriteString(iconName + ".AddFile4(" + strconv.Quote(*iconVal.NormalOn) + ", qt.NewQSize(), qt.QIcon__Selected, qt.QIcon__On)\n")
|
|
}
|
|
|
|
return iconName
|
|
}
|
|
|
|
func renderProperties(properties []UiProperty, ret *strings.Builder, targetName, parentClass string, isLayout bool) error {
|
|
|
|
contentsMargins := [4]int{DefaultGridMargin, DefaultGridMargin, DefaultGridMargin, DefaultGridMargin} // left, top, right, bottom
|
|
customContentsMargins := false
|
|
customSpacing := false
|
|
|
|
for _, prop := range properties {
|
|
setterFunc := `.Set` + strings.ToUpper(string(prop.Name[0])) + prop.Name[1:]
|
|
|
|
if prop.Name == "geometry" {
|
|
if !(prop.RectVal.X == 0 && prop.RectVal.Y == 0) {
|
|
// Set all 4x properties
|
|
ret.WriteString(`ui.` + targetName + `.SetGeometry(qt.NewQRect(` + fmt.Sprintf("%d, %d, %d, %d", prop.RectVal.X, prop.RectVal.Y, prop.RectVal.Width, prop.RectVal.Height) + "))\n")
|
|
|
|
} else if !(prop.RectVal.Width == 0 && prop.RectVal.Height == 0) {
|
|
// Only width/height were supplied
|
|
ret.WriteString(`ui.` + targetName + `.Resize(` + fmt.Sprintf("%d, %d", prop.RectVal.Width, prop.RectVal.Height) + ")\n")
|
|
|
|
}
|
|
|
|
} else if prop.Name == "leftMargin" {
|
|
contentsMargins[0] = mustParseInt(*prop.NumberVal)
|
|
customContentsMargins = true
|
|
|
|
} else if prop.Name == "topMargin" {
|
|
contentsMargins[1] = mustParseInt(*prop.NumberVal)
|
|
customContentsMargins = true
|
|
|
|
} else if prop.Name == "rightMargin" {
|
|
contentsMargins[2] = mustParseInt(*prop.NumberVal)
|
|
customContentsMargins = true
|
|
|
|
} else if prop.Name == "bottomMargin" {
|
|
contentsMargins[3] = mustParseInt(*prop.NumberVal)
|
|
customContentsMargins = true
|
|
|
|
} else if prop.StringVal != nil {
|
|
// "windowTitle", "title", "text"
|
|
ret.WriteString(`ui.` + targetName + setterFunc + `(` + generateString(prop.StringVal, parentClass) + ")\n")
|
|
|
|
} else if prop.NumberVal != nil {
|
|
// "currentIndex"
|
|
if prop.Name == "spacing" {
|
|
customSpacing = true
|
|
}
|
|
ret.WriteString(`ui.` + targetName + setterFunc + `(` + *prop.NumberVal + ")\n")
|
|
|
|
} else if prop.BoolVal != nil {
|
|
// "childrenCollapsible"
|
|
ret.WriteString(`ui.` + targetName + setterFunc + `(` + formatBool(*prop.BoolVal) + ")\n")
|
|
|
|
} else if prop.EnumVal != nil {
|
|
// "frameShape"
|
|
|
|
// Newer versions of Qt Designer produce the fully qualified enum
|
|
// names (A::B::C) but miqt changed to use the short names. Need to
|
|
// detect the case and convert it to match
|
|
ret.WriteString(`ui.` + targetName + setterFunc + `(` + normalizeEnumName(*prop.EnumVal) + ")\n")
|
|
|
|
} else if prop.SetVal != nil {
|
|
// QDialogButtonBox::"standardButtons"
|
|
// <set>QDialogButtonBox::Cancel|QDialogButtonBox::Save</set>
|
|
|
|
parts := strings.Split(*prop.SetVal, `|`)
|
|
for i, p := range parts {
|
|
parts[i] = normalizeEnumName(p)
|
|
}
|
|
|
|
emit := "0"
|
|
if len(parts) > 0 {
|
|
emit = strings.Join(parts, `|`)
|
|
}
|
|
ret.WriteString(`ui.` + targetName + setterFunc + `(` + emit + ")\n")
|
|
|
|
} else if prop.IconVal != nil {
|
|
iconName := renderIcon(prop.IconVal, ret)
|
|
ret.WriteString(`ui.` + targetName + setterFunc + `(` + iconName + ")\n")
|
|
|
|
} else {
|
|
ret.WriteString("/* miqt-uic: no handler for " + targetName + " property '" + prop.Name + "' */\n")
|
|
}
|
|
}
|
|
|
|
if customContentsMargins || isLayout {
|
|
ret.WriteString(`ui.` + targetName + `.SetContentsMargins(` + fmt.Sprintf("%d, %d, %d, %d", contentsMargins[0], contentsMargins[1], contentsMargins[2], contentsMargins[3]) + ")\n")
|
|
}
|
|
|
|
if !customSpacing && isLayout {
|
|
// Layouts must specify spacing, unless, we specified it already
|
|
ret.WriteString(`ui.` + targetName + `.SetSpacing(` + fmt.Sprintf("%d", DefaultSpacing) + ")\n")
|
|
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func generateWidget(w UiWidget, parentName string, parentClass string) (string, error) {
|
|
ret := strings.Builder{}
|
|
|
|
ctor := constructorFunctionFor(w.Class)
|
|
|
|
ret.WriteString(`
|
|
ui.` + w.Name + ` = qt.` + ctor + `(` + qwidgetName(parentName, parentClass) + `)
|
|
ui.` + w.Name + `.SetObjectName(` + strconv.Quote(w.Name) + `)
|
|
`)
|
|
if RootWindowName == "" {
|
|
RootWindowName = `ui.` + w.Name
|
|
}
|
|
|
|
// Properties
|
|
|
|
err := renderProperties(w.Properties, &ret, w.Name, parentClass, false)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Attributes
|
|
|
|
for _, attr := range w.Attributes {
|
|
if parentClass == "QTabWidget" && attr.Name == "title" {
|
|
ret.WriteString(parentName + `.SetTabText(` + parentName + ".IndexOf(ui." + w.Name + "), " + generateString(attr.StringVal, parentClass) + ")\n")
|
|
|
|
} else if w.Class == "QDockWidget" && parentClass == "QMainWindow" && attr.Name == "dockWidgetArea" {
|
|
ret.WriteString(parentName + `.AddDockWidget(qt.DockWidgetArea(` + *attr.NumberVal + `), ui.` + w.Name + `)` + "\n")
|
|
|
|
} else if w.Class == "QToolBar" && parentClass == "QMainWindow" && attr.Name == "toolBarArea" {
|
|
ret.WriteString(parentName + `.AddToolBar(` + normalizeEnumName(*attr.EnumVal) + `, ui.` + w.Name + `)` + "\n")
|
|
|
|
} else if parentClass == "QTabWidget" && attr.Name == "icon" {
|
|
// This will be handled when we call .AddTab() on the parent QTabWidget
|
|
|
|
} else {
|
|
ret.WriteString("/* miqt-uic: no handler for " + w.Name + " attribute '" + attr.Name + "' */\n")
|
|
|
|
}
|
|
}
|
|
|
|
// Layout
|
|
|
|
if w.Layout != nil {
|
|
ctor := constructorFunctionFor(w.Layout.Class)
|
|
|
|
ret.WriteString(`
|
|
ui.` + w.Layout.Name + ` = qt.` + ctor + `(` + qwidgetName("ui."+w.Name, w.Class) + `)
|
|
ui.` + w.Layout.Name + `.SetObjectName(` + strconv.Quote(w.Layout.Name) + `)
|
|
`)
|
|
|
|
// Layout->Properties
|
|
|
|
err := renderProperties(w.Layout.Properties, &ret, w.Layout.Name, parentClass, true) // Always emit spacing/padding calls
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Layout->Items
|
|
|
|
for i, child := range w.Layout.Items {
|
|
|
|
// A layout item is either a widget, or a spacer
|
|
|
|
if child.Spacer != nil {
|
|
ret.WriteString("/* miqt-uic: no handler for spacer */\n")
|
|
}
|
|
|
|
if child.Widget != nil {
|
|
|
|
// Layout items have the parent as the real QWidget parent and are
|
|
// separately assigned to the layout afterwards
|
|
|
|
nest, err := generateWidget(*child.Widget, `ui.`+w.Name, w.Class)
|
|
if err != nil {
|
|
return "", fmt.Errorf(w.Name+"/Layout/Item[%d]: %w", i, err)
|
|
}
|
|
|
|
ret.WriteString(nest)
|
|
|
|
// Assign to layout
|
|
|
|
switch w.Layout.Class {
|
|
case `QFormLayout`:
|
|
// Row and Column are always populated.
|
|
rowPos := fmt.Sprintf("%d", *child.Row)
|
|
var colPos string
|
|
if *child.Column == 0 {
|
|
colPos = `qt.QFormLayout__LabelRole`
|
|
} else if *child.Column == 1 {
|
|
colPos = `qt.QFormLayout__FieldRole`
|
|
} else {
|
|
ret.WriteString("/* miqt-uic: QFormLayout does not understand column index */\n")
|
|
continue
|
|
}
|
|
|
|
// For QFormLayout it's SetWidget
|
|
ret.WriteString(`
|
|
ui.` + w.Layout.Name + `.SetWidget(` + rowPos + `, ` + colPos + `, ` + qwidgetName(`ui.`+child.Widget.Name, child.Widget.Class) + `)
|
|
`)
|
|
|
|
case `QGridLayout`:
|
|
if child.ColSpan != nil || child.RowSpan != nil {
|
|
// If either are present, use full four-value AddWidget3
|
|
rowSpan := 1
|
|
if child.RowSpan != nil {
|
|
rowSpan = *child.RowSpan
|
|
}
|
|
colSpan := 1
|
|
if child.ColSpan != nil {
|
|
colSpan = *child.ColSpan
|
|
}
|
|
|
|
ret.WriteString(`
|
|
ui.` + w.Layout.Name + `.AddWidget3(` + qwidgetName(`ui.`+child.Widget.Name, child.Widget.Class) + `, ` + fmt.Sprintf("%d, %d, %d, %d", *child.Row, *child.Column, rowSpan, colSpan) + `)
|
|
`)
|
|
|
|
} else {
|
|
// Row and Column are always present in the .ui file
|
|
// For row/column it's AddWidget2
|
|
|
|
ret.WriteString(`
|
|
ui.` + w.Layout.Name + `.AddWidget2(` + qwidgetName(`ui.`+child.Widget.Name, child.Widget.Class) + `, ` + fmt.Sprintf("%d, %d", *child.Row, *child.Column) + `)
|
|
`)
|
|
}
|
|
|
|
case "QVBoxLayout", "QHBoxLayout":
|
|
// For box layout it's AddWidget
|
|
ret.WriteString(`
|
|
ui.` + w.Layout.Name + `.AddWidget(` + qwidgetName(`ui.`+child.Widget.Name, child.Widget.Class) + `)
|
|
`)
|
|
|
|
default:
|
|
ret.WriteString("/* miqt-uic: no handler for layout '" + w.Layout.Class + "' */\n")
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Actions
|
|
|
|
for _, a := range w.Actions {
|
|
ret.WriteString(`
|
|
ui.` + a.Name + ` = qt.NewQAction(` + parentName + `)
|
|
ui.` + a.Name + `.SetObjectName(` + strconv.Quote(a.Name) + `)
|
|
`)
|
|
|
|
// QActions are translated in the parent window's context
|
|
if prop, ok := propertyByName(a.Properties, "text"); ok {
|
|
ret.WriteString("ui." + a.Name + `.SetText(` + generateString(prop.StringVal, w.Class) + `)` + "\n")
|
|
}
|
|
|
|
if prop, ok := propertyByName(a.Properties, "shortcut"); ok {
|
|
ret.WriteString("ui." + a.Name + `.SetShortcut(qt.NewQKeySequence2(` + generateString(prop.StringVal, w.Class) + `))` + "\n")
|
|
}
|
|
|
|
if prop, ok := propertyByName(a.Properties, "icon"); ok {
|
|
iconName := renderIcon(prop.IconVal, &ret)
|
|
ret.WriteString(`ui.` + a.Name + `.SetIcon(` + iconName + ")\n")
|
|
}
|
|
}
|
|
|
|
// Items
|
|
|
|
for itemNo, itm := range w.Items {
|
|
ret.WriteString("ui." + w.Name + `.AddItem("")` + "\n")
|
|
|
|
// Check for a "text" property and update the item's text
|
|
// Do this as a 2nd step so that the SetItemText can be trapped for retranslateUi()
|
|
// TODO Abstract for all SetItem{Foo} properties
|
|
for _, prop := range itm.Properties {
|
|
if prop.Name == "text" {
|
|
ret.WriteString("ui." + w.Name + `.SetItemText(` + fmt.Sprintf("%d", itemNo) + `, ` + generateString(prop.StringVal, w.Class) + `)` + "\n")
|
|
} else {
|
|
ret.WriteString("/* miqt-uic: no handler for item property '" + prop.Name + "' */\n")
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// Columns
|
|
|
|
for colNo, col := range w.Columns {
|
|
|
|
for _, prop := range col.Properties {
|
|
if prop.Name == "text" {
|
|
ret.WriteString("ui." + w.Name + ".HeaderItem().SetText(" + fmt.Sprintf("%d", colNo) + ", " + generateString(prop.StringVal, w.Class) + ")\n")
|
|
} else {
|
|
ret.WriteString("/* miqt-uic: no handler for column property '" + prop.Name + "' */\n")
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Recurse children
|
|
var (
|
|
setCentralWidget = false
|
|
setMenuBar = false
|
|
setStatusBar = false
|
|
)
|
|
|
|
for i, child := range w.Widgets {
|
|
nest, err := generateWidget(child, `ui.`+w.Name, w.Class)
|
|
if err != nil {
|
|
return "", fmt.Errorf(w.Name+"/Widgets[%d]: %w", i, err)
|
|
}
|
|
|
|
ret.WriteString(nest)
|
|
|
|
// QMainWindow CentralWidget handling
|
|
// The first listed class can be the central widget.
|
|
// TODO should it be the first child with a layout? But need to handle windows with no layout
|
|
if w.Class == `QMainWindow` && !setCentralWidget {
|
|
ret.WriteString(`ui.` + w.Name + `.SetCentralWidget(ui.` + child.Name + ") // Set central widget \n")
|
|
setCentralWidget = true
|
|
}
|
|
|
|
// QDockWidget also has something like a central widget
|
|
if w.Class == `QDockWidget` && !setCentralWidget {
|
|
ret.WriteString(`ui.` + w.Name + `.SetWidget(ui.` + child.Name + ") // Set central widget \n")
|
|
setCentralWidget = true
|
|
}
|
|
|
|
if w.Class == "QSplitter" || w.Class == "QStackedWidget" {
|
|
// We need to manually AddWidget on every child of QSplitter
|
|
if child.Class == "QWidget" {
|
|
ret.WriteString(`ui.` + w.Name + `.AddWidget(ui.` + child.Name + `)` + "\n")
|
|
} else {
|
|
ret.WriteString(`ui.` + w.Name + `.AddWidget(ui.` + child.Name + `.QWidget)` + "\n")
|
|
}
|
|
}
|
|
|
|
if w.Class == "QMainWindow" && child.Class == "QMenuBar" && !setMenuBar {
|
|
ret.WriteString(`ui.` + w.Name + `.SetMenuBar(ui.` + child.Name + `)` + "\n")
|
|
setMenuBar = true
|
|
}
|
|
if w.Class == "QMainWindow" && child.Class == "QStatusBar" && !setStatusBar {
|
|
ret.WriteString(`ui.` + w.Name + `.SetStatusBar(ui.` + child.Name + `)` + "\n")
|
|
setStatusBar = true
|
|
}
|
|
|
|
// QTabWidget->QTab handling
|
|
if w.Class == `QTabWidget` {
|
|
if icon, ok := propertyByName(child.Attributes, "icon"); ok {
|
|
// AddTab() overload with icon
|
|
iconName := renderIcon(icon.IconVal, &ret)
|
|
ret.WriteString(`ui.` + w.Name + `.AddTab2(` + qwidgetName(`ui.`+child.Name, child.Class) + `, ` + iconName + `, "")` + "\n")
|
|
|
|
} else {
|
|
// AddTab() overload without icon
|
|
ret.WriteString(`ui.` + w.Name + `.AddTab(` + qwidgetName(`ui.`+child.Name, child.Class) + `, "")` + "\n")
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// AddActions
|
|
// n.b. This must be *after* all children have been constructed, in case we
|
|
// are adding a direct child
|
|
|
|
for _, a := range w.AddActions {
|
|
if a.Name == "separator" {
|
|
// TODO how does Qt Designer disambiguate a real QAction with name="separator" ?
|
|
ret.WriteString("ui." + w.Name + ".AddSeparator()\n")
|
|
|
|
} else {
|
|
// If we are a menubar, then <addaction> refers to top-level QMenu instead of QAction
|
|
if w.Class == "QMenuBar" {
|
|
ret.WriteString("ui." + w.Name + ".AddMenu(ui." + a.Name + ")\n")
|
|
} else if w.Class == "QMenu" || w.Class == "QToolBar" {
|
|
// QMenu has its own .AddAction() implementation that takes plain string
|
|
// That's convenient, but it shadows the AddAction version that takes a QAction*
|
|
// We need to use the underlying QWidget.AddAction explicitly
|
|
ret.WriteString("ui." + w.Name + ".QWidget.AddAction(ui." + a.Name + ")\n")
|
|
} else {
|
|
ret.WriteString("ui." + w.Name + ".AddAction(ui." + a.Name + ")\n")
|
|
}
|
|
}
|
|
}
|
|
|
|
if w.Class == "QDialogButtonBox" {
|
|
// TODO make this using a native connection instead of a C++ -> Go -> C++ roundtrip
|
|
ret.WriteString(`ui.` + w.Name + `.OnAccepted(` + RootWindowName + ".Accept)\n")
|
|
ret.WriteString(`ui.` + w.Name + `.OnRejected(` + RootWindowName + ".Reject)\n")
|
|
}
|
|
|
|
return ret.String(), nil
|
|
}
|
|
|
|
func generate(packageName string, goGenerateArgs string, u UiFile) ([]byte, error) {
|
|
|
|
ret := strings.Builder{}
|
|
|
|
// Update globals for layoutdefault, if present
|
|
|
|
if u.LayoutDefault != nil {
|
|
if u.LayoutDefault.Spacing != nil {
|
|
DefaultSpacing = *u.LayoutDefault.Spacing
|
|
}
|
|
if u.LayoutDefault.Margin != nil {
|
|
DefaultGridMargin = *u.LayoutDefault.Margin
|
|
}
|
|
}
|
|
|
|
// Header
|
|
|
|
ret.WriteString(`// Generated by miqt-uic. To update this file, edit the .ui file in
|
|
// Qt Designer, and then run 'go generate'.
|
|
//
|
|
//go:` + `generate miqt-uic ` + goGenerateArgs + `
|
|
|
|
package ` + packageName + `
|
|
|
|
import (
|
|
"github.com/mappu/miqt/qt"
|
|
)
|
|
|
|
type ` + u.Class + `Ui struct {
|
|
` + strings.Join(collectClassNames_Widget(&u.Widget), "\n") + `
|
|
}
|
|
|
|
// New` + u.Class + `Ui creates all Qt widget classes for ` + u.Class + `.
|
|
func New` + u.Class + `Ui() *` + u.Class + `Ui {
|
|
ui := &` + u.Class + `Ui{}
|
|
`)
|
|
|
|
nest, err := generateWidget(u.Widget, "", "")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Don't emit any of the lines that included .Tr(), move them into the
|
|
// retranslateUi() function
|
|
var translateFunc []string
|
|
var setCurrentIndex []string
|
|
for _, line := range strings.Split(nest, "\n") {
|
|
if strings.Contains(line, `_Tr(`) {
|
|
translateFunc = append(translateFunc, line)
|
|
} else if strings.Contains(line, `.SetCurrentIndex(`) {
|
|
setCurrentIndex = append(setCurrentIndex, line)
|
|
} else {
|
|
ret.WriteString(line + "\n")
|
|
}
|
|
}
|
|
|
|
ret.WriteString("\nui.Retranslate()\n\n")
|
|
|
|
for _, sci := range setCurrentIndex {
|
|
ret.WriteString(sci + "\n")
|
|
}
|
|
|
|
ret.WriteString(`
|
|
return ui
|
|
}
|
|
|
|
// Retranslate reapplies all text translations.
|
|
func (ui *` + u.Class + `Ui) Retranslate() {
|
|
` + strings.Join(translateFunc, "\n") + `
|
|
}
|
|
|
|
`)
|
|
|
|
output := ret.String()
|
|
|
|
formatted, err := format.Source([]byte(output))
|
|
if err != nil {
|
|
// Return unformatted so it can be fixed
|
|
return []byte(output), nil
|
|
}
|
|
|
|
return formatted, nil
|
|
}
|