693 lines
18 KiB
Go
693 lines
18 KiB
Go
//go:build windows
|
||
|
||
package gui
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
_ "embed"
|
||
"fmt"
|
||
"image/png"
|
||
"os"
|
||
"path/filepath"
|
||
"runtime"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
"unsafe"
|
||
|
||
"github.com/lxn/walk"
|
||
. "github.com/lxn/walk/declarative"
|
||
"github.com/lxn/win"
|
||
"golang.org/x/sys/windows"
|
||
|
||
"mysql-tunnel/internal/app"
|
||
"mysql-tunnel/internal/config"
|
||
"mysql-tunnel/internal/logger"
|
||
)
|
||
|
||
//go:embed logo.png
|
||
var logoPNG []byte
|
||
|
||
func init() {
|
||
runtime.LockOSThread()
|
||
}
|
||
|
||
func Run(configFlag string) int {
|
||
hideConsoleIfStandalone()
|
||
path := strings.TrimSpace(configFlag)
|
||
if path == "" {
|
||
path = "config.yaml"
|
||
}
|
||
if resolved, err := config.ResolveConfigPath(path); err == nil {
|
||
path = resolved
|
||
} else if path == "config.yaml" {
|
||
path = config.DefaultSavePath()
|
||
} else if abs, err := filepath.Abs(path); err == nil {
|
||
path = abs
|
||
}
|
||
if err := runWindow(config.LoadOrEmpty(path)); err != nil {
|
||
fmt.Fprintln(os.Stderr, err)
|
||
return 1
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type ui struct {
|
||
mw *walk.MainWindow
|
||
ni *walk.NotifyIcon
|
||
|
||
listenHost *walk.LineEdit
|
||
listenPort *walk.NumberEdit
|
||
localUser *walk.LineEdit
|
||
localPass *walk.LineEdit
|
||
tunnelURL *walk.LineEdit
|
||
encodeB64 *walk.CheckBox
|
||
tlsSkip *walk.CheckBox
|
||
remoteHost *walk.LineEdit
|
||
remotePort *walk.NumberEdit
|
||
remoteUser *walk.LineEdit
|
||
remotePass *walk.LineEdit
|
||
remoteDB *walk.LineEdit
|
||
charset *walk.LineEdit
|
||
timeout *walk.NumberEdit
|
||
maxConn *walk.NumberEdit
|
||
logLevel *walk.ComboBox
|
||
logSQL *walk.CheckBox
|
||
logFile *walk.LineEdit
|
||
status *walk.TextEdit
|
||
saveBtn *walk.PushButton
|
||
testBtn *walk.PushButton
|
||
startBtn *walk.PushButton
|
||
stopBtn *walk.PushButton
|
||
pathLabel *walk.Label
|
||
hint *walk.StatusBarItem
|
||
logoView *walk.ImageView
|
||
appIcon *walk.Icon
|
||
appBmp *walk.Bitmap
|
||
|
||
cfgPath string
|
||
|
||
mu sync.Mutex
|
||
running bool
|
||
busy bool
|
||
cancel context.CancelFunc
|
||
log *logger.Logger
|
||
exiting bool
|
||
hidOnce bool
|
||
}
|
||
|
||
func runWindow(cfg *config.Config) error {
|
||
u := &ui{cfgPath: cfg.Path}
|
||
if err := u.build(cfg); err != nil {
|
||
return err
|
||
}
|
||
defer u.dispose()
|
||
u.mw.Run()
|
||
return nil
|
||
}
|
||
|
||
func (u *ui) dispose() {
|
||
u.stopServer()
|
||
if u.ni != nil {
|
||
_ = u.ni.Dispose()
|
||
}
|
||
}
|
||
|
||
func (u *ui) build(cfg *config.Config) error {
|
||
logFile := relativeLogFile(cfg)
|
||
levels := []string{"debug", "info", "warn", "error"}
|
||
levelIdx := 1
|
||
for i, s := range levels {
|
||
if s == cfg.LogLevel {
|
||
levelIdx = i
|
||
break
|
||
}
|
||
}
|
||
|
||
if err := (MainWindow{
|
||
AssignTo: &u.mw,
|
||
Title: "MySQL Tunnel",
|
||
MinSize: Size{Width: 780, Height: 560},
|
||
Size: Size{Width: 840, Height: 620},
|
||
Layout: VBox{Margins: Margins{Left: 12, Top: 10, Right: 12, Bottom: 8}, Spacing: 8},
|
||
StatusBarItems: []StatusBarItem{
|
||
{AssignTo: &u.hint, Text: "就绪", Width: 800},
|
||
},
|
||
Children: []Widget{
|
||
Composite{
|
||
Layout: HBox{Spacing: 10, MarginsZero: true},
|
||
Children: []Widget{
|
||
ImageView{
|
||
AssignTo: &u.logoView,
|
||
MinSize: Size{Width: 40, Height: 40},
|
||
MaxSize: Size{Width: 40, Height: 40},
|
||
Mode: ImageViewModeZoom,
|
||
},
|
||
Composite{
|
||
Layout: VBox{MarginsZero: true, Spacing: 2},
|
||
Children: []Widget{
|
||
Label{Text: "MySQL Tunnel", Font: Font{Family: "Segoe UI", PointSize: 13, Bold: true}},
|
||
Label{AssignTo: &u.pathLabel, Text: cfg.Path},
|
||
},
|
||
},
|
||
HSpacer{},
|
||
},
|
||
},
|
||
Composite{
|
||
Layout: HBox{Spacing: 10, MarginsZero: true},
|
||
Children: []Widget{
|
||
Composite{
|
||
StretchFactor: 1,
|
||
MinSize: Size{Width: 380},
|
||
Layout: VBox{MarginsZero: true, Spacing: 8},
|
||
Children: []Widget{
|
||
GroupBox{
|
||
Title: "本机监听（影刀连这里）",
|
||
Layout: Grid{Columns: 2, Spacing: 6},
|
||
Children: []Widget{
|
||
fieldLabel("地址"),
|
||
LineEdit{AssignTo: &u.listenHost, Text: cfg.ListenHost},
|
||
fieldLabel("端口"),
|
||
NumberEdit{AssignTo: &u.listenPort, Value: float64(cfg.ListenPort), MinValue: 1, MaxValue: 65535, Decimals: 0, MinSize: Size{Width: 90}},
|
||
fieldLabel("本机用户"),
|
||
LineEdit{AssignTo: &u.localUser, Text: cfg.LocalUsername},
|
||
fieldLabel("本机密码"),
|
||
LineEdit{AssignTo: &u.localPass, Text: cfg.LocalPassword, PasswordMode: true},
|
||
},
|
||
},
|
||
GroupBox{
|
||
Title: "HTTP 隧道",
|
||
StretchFactor: 1,
|
||
Layout: Grid{Columns: 2, Spacing: 6},
|
||
Children: []Widget{
|
||
fieldLabel("URL"),
|
||
LineEdit{AssignTo: &u.tunnelURL, Text: cfg.TunnelURL},
|
||
CheckBox{AssignTo: &u.encodeB64, Text: "SQL Base64（WAF）", Checked: cfg.EncodeBase64, ColumnSpan: 2},
|
||
CheckBox{AssignTo: &u.tlsSkip, Text: "跳过 TLS 证书校验（仅排障）", Checked: cfg.TLSInsecureSkipVerify, ColumnSpan: 2},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
Composite{
|
||
StretchFactor: 1,
|
||
MinSize: Size{Width: 380},
|
||
Layout: VBox{MarginsZero: true, Spacing: 8},
|
||
Children: []Widget{
|
||
GroupBox{
|
||
Title: "远程 MySQL（PHP 主机访问）",
|
||
Layout: Grid{Columns: 2, Spacing: 6},
|
||
Children: []Widget{
|
||
fieldLabel("主机"),
|
||
LineEdit{AssignTo: &u.remoteHost, Text: cfg.RemoteHost},
|
||
fieldLabel("端口"),
|
||
NumberEdit{AssignTo: &u.remotePort, Value: float64(nonzero(cfg.RemotePort, 3306)), MinValue: 1, MaxValue: 65535, Decimals: 0, MinSize: Size{Width: 90}},
|
||
fieldLabel("用户名"),
|
||
LineEdit{AssignTo: &u.remoteUser, Text: cfg.RemoteUsername},
|
||
fieldLabel("密码"),
|
||
LineEdit{AssignTo: &u.remotePass, Text: cfg.RemotePassword, PasswordMode: true},
|
||
fieldLabel("默认库"),
|
||
LineEdit{AssignTo: &u.remoteDB, Text: cfg.RemoteDatabase},
|
||
fieldLabel("字符集"),
|
||
LineEdit{AssignTo: &u.charset, Text: orDefault(cfg.RemoteCharset, "utf8mb4")},
|
||
},
|
||
},
|
||
GroupBox{
|
||
Title: "选项",
|
||
StretchFactor: 1,
|
||
Layout: Grid{Columns: 2, Spacing: 6},
|
||
Children: []Widget{
|
||
fieldLabel("超时（秒）"),
|
||
NumberEdit{AssignTo: &u.timeout, Value: float64(timeoutSec(cfg)), MinValue: 1, MaxValue: 600, Decimals: 0, MinSize: Size{Width: 90}},
|
||
fieldLabel("最大连接"),
|
||
NumberEdit{AssignTo: &u.maxConn, Value: float64(nonzero(cfg.MaxConnections, 5)), MinValue: 1, MaxValue: 256, Decimals: 0, MinSize: Size{Width: 90}},
|
||
fieldLabel("日志级别"),
|
||
ComboBox{AssignTo: &u.logLevel, Model: levels, CurrentIndex: levelIdx, Editable: false},
|
||
fieldLabel("日志文件"),
|
||
LineEdit{AssignTo: &u.logFile, Text: logFile},
|
||
CheckBox{AssignTo: &u.logSQL, Text: "记录 SQL（仍会脱敏）", Checked: cfg.LogSQL, ColumnSpan: 2},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
Composite{
|
||
Layout: HBox{Spacing: 8},
|
||
Children: []Widget{
|
||
PushButton{AssignTo: &u.saveBtn, Text: "保存", MinSize: Size{Width: 88}},
|
||
PushButton{AssignTo: &u.testBtn, Text: "测试连接", MinSize: Size{Width: 88}},
|
||
PushButton{AssignTo: &u.startBtn, Text: "启动", MinSize: Size{Width: 88}},
|
||
PushButton{AssignTo: &u.stopBtn, Text: "停止", Enabled: false, MinSize: Size{Width: 88}},
|
||
HSpacer{},
|
||
},
|
||
},
|
||
GroupBox{
|
||
Title: "运行日志",
|
||
StretchFactor: 1,
|
||
MinSize: Size{Height: 140},
|
||
Layout: VBox{MarginsZero: true},
|
||
Children: []Widget{
|
||
TextEdit{AssignTo: &u.status, ReadOnly: true, VScroll: true, MaxLength: 64 * 1024},
|
||
},
|
||
},
|
||
},
|
||
}).Create(); err != nil {
|
||
return err
|
||
}
|
||
|
||
if u.saveBtn != nil {
|
||
u.saveBtn.Clicked().Attach(u.onSave)
|
||
}
|
||
if u.testBtn != nil {
|
||
u.testBtn.Clicked().Attach(u.onTest)
|
||
}
|
||
if u.startBtn != nil {
|
||
u.startBtn.Clicked().Attach(u.onStart)
|
||
}
|
||
if u.stopBtn != nil {
|
||
u.stopBtn.Clicked().Attach(u.onStop)
|
||
u.stopBtn.SetEnabled(false)
|
||
}
|
||
u.appendStatus("填写后点「保存」，再「测试连接」。通过后点「启动」，影刀连 本机地址:端口。")
|
||
u.appendStatus("最小化或关闭窗口会藏到系统托盘（监听可继续）。托盘左键打开，右键退出。")
|
||
for _, w := range cfg.Warnings {
|
||
u.appendStatus("注意: " + w)
|
||
}
|
||
|
||
if err := u.applyBranding(); err != nil {
|
||
return err
|
||
}
|
||
|
||
ni, err := walk.NewNotifyIcon(u.mw)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
u.ni = ni
|
||
if u.appIcon != nil {
|
||
_ = ni.SetIcon(u.appIcon)
|
||
_ = u.mw.SetIcon(u.appIcon)
|
||
}
|
||
_ = ni.SetToolTip("MySQL Tunnel")
|
||
_ = ni.SetVisible(true)
|
||
ni.MouseDown().Attach(func(x, y int, button walk.MouseButton) {
|
||
if button == walk.LeftButton {
|
||
u.showWindow()
|
||
}
|
||
})
|
||
|
||
showAct := walk.NewAction()
|
||
_ = showAct.SetText("打开窗口")
|
||
showAct.Triggered().Attach(u.showWindow)
|
||
exitAct := walk.NewAction()
|
||
_ = exitAct.SetText("退出")
|
||
exitAct.Triggered().Attach(u.onExit)
|
||
if menu := ni.ContextMenu(); menu != nil {
|
||
_ = menu.Actions().Add(showAct)
|
||
_ = menu.Actions().Add(exitAct)
|
||
}
|
||
|
||
// Minimize → tray (not taskbar). Close also → tray unless exiting.
|
||
u.mw.SizeChanged().Attach(func() {
|
||
hwnd := win.HWND(u.mw.Handle())
|
||
if win.IsIconic(hwnd) {
|
||
u.hideToTray()
|
||
}
|
||
})
|
||
u.mw.Closing().Attach(func(canceled *bool, reason walk.CloseReason) {
|
||
u.mu.Lock()
|
||
exiting := u.exiting
|
||
u.mu.Unlock()
|
||
if exiting {
|
||
return
|
||
}
|
||
*canceled = true
|
||
u.hideToTray()
|
||
})
|
||
return nil
|
||
}
|
||
|
||
func (u *ui) hideToTray() {
|
||
if u.mw == nil {
|
||
return
|
||
}
|
||
u.mw.Hide()
|
||
hwnd := win.HWND(u.mw.Handle())
|
||
win.ShowWindow(hwnd, win.SW_HIDE)
|
||
if u.ni != nil && !u.hidOnce {
|
||
u.hidOnce = true
|
||
_ = u.ni.ShowInfo("MySQL Tunnel", "已放到系统托盘。左键打开窗口，右键退出。")
|
||
}
|
||
}
|
||
|
||
func (u *ui) showWindow() {
|
||
if u.mw == nil {
|
||
return
|
||
}
|
||
u.mw.Show()
|
||
hwnd := win.HWND(u.mw.Handle())
|
||
win.ShowWindow(hwnd, win.SW_RESTORE)
|
||
win.SetForegroundWindow(hwnd)
|
||
}
|
||
|
||
func (u *ui) onExit() {
|
||
u.mu.Lock()
|
||
u.exiting = true
|
||
u.mu.Unlock()
|
||
u.stopServer()
|
||
if u.ni != nil {
|
||
_ = u.ni.SetVisible(false)
|
||
}
|
||
u.mw.Close()
|
||
}
|
||
|
||
func (u *ui) collect() (*config.Config, error) {
|
||
c := config.Defaults()
|
||
c.Path = u.cfgPath
|
||
c.ListenHost = strings.TrimSpace(lineText(u.listenHost))
|
||
c.ListenPort = numValue(u.listenPort, config.DefaultListenPort)
|
||
c.LocalUsername = strings.TrimSpace(lineText(u.localUser))
|
||
c.LocalPassword = lineText(u.localPass)
|
||
c.TunnelURL = strings.TrimSpace(lineText(u.tunnelURL))
|
||
c.EncodeBase64 = boxChecked(u.encodeB64)
|
||
c.TLSInsecureSkipVerify = boxChecked(u.tlsSkip)
|
||
c.RemoteHost = strings.TrimSpace(lineText(u.remoteHost))
|
||
c.RemotePort = numValue(u.remotePort, 3306)
|
||
c.RemoteUsername = strings.TrimSpace(lineText(u.remoteUser))
|
||
c.RemotePassword = lineText(u.remotePass)
|
||
c.RemoteDatabase = strings.TrimSpace(lineText(u.remoteDB))
|
||
c.RemoteCharset = strings.TrimSpace(lineText(u.charset))
|
||
c.RequestTimeout = time.Duration(numValue(u.timeout, config.DefaultTimeoutSec)) * time.Second
|
||
c.MaxConnections = numValue(u.maxConn, config.DefaultMaxConnections)
|
||
if u.logLevel != nil {
|
||
c.LogLevel = strings.ToLower(strings.TrimSpace(u.logLevel.Text()))
|
||
}
|
||
if c.LogLevel == "" {
|
||
c.LogLevel = config.DefaultLogLevel
|
||
}
|
||
c.LogSQL = boxChecked(u.logSQL)
|
||
c.LogFile = strings.TrimSpace(lineText(u.logFile))
|
||
if c.LogFile == "" {
|
||
c.LogFile = config.DefaultLogFile
|
||
}
|
||
if err := c.Validate(); err != nil {
|
||
return &c, err
|
||
}
|
||
c.ResolvePaths()
|
||
return &c, nil
|
||
}
|
||
|
||
func (u *ui) onSave() {
|
||
c, err := u.collect()
|
||
if err != nil {
|
||
u.appendStatus("保存失败: " + err.Error())
|
||
walk.MsgBox(u.mw, "MySQL Tunnel", err.Error(), walk.MsgBoxIconError)
|
||
return
|
||
}
|
||
if err := config.Save(u.cfgPath, c); err != nil {
|
||
u.appendStatus("保存失败: " + err.Error())
|
||
walk.MsgBox(u.mw, "MySQL Tunnel", err.Error(), walk.MsgBoxIconError)
|
||
return
|
||
}
|
||
u.appendStatus("已保存 " + u.cfgPath)
|
||
for _, w := range c.Warnings {
|
||
u.appendStatus("注意: " + w)
|
||
}
|
||
}
|
||
|
||
func (u *ui) onTest() {
|
||
c, err := u.collect()
|
||
if err != nil {
|
||
u.appendStatus("无法测试: " + err.Error())
|
||
walk.MsgBox(u.mw, "MySQL Tunnel", "无法测试:\n"+err.Error(), walk.MsgBoxIconError)
|
||
return
|
||
}
|
||
u.setBusy(true)
|
||
u.setHint("正在测试隧道…")
|
||
u.appendStatus("正在测试 " + config.RedactedTunnelURL(c.TunnelURL) + " …")
|
||
go func() {
|
||
defer func() {
|
||
if rec := recover(); rec != nil {
|
||
u.mw.Synchronize(func() {
|
||
msg := fmt.Sprintf("测试异常: %v", rec)
|
||
u.appendStatus(msg)
|
||
u.setHint("测试异常")
|
||
walk.MsgBox(u.mw, "测试结果", msg, walk.MsgBoxIconError)
|
||
u.setBusy(false)
|
||
})
|
||
}
|
||
}()
|
||
log, _ := logger.New(c.LogFile, c.LogLevel, c.LogSQL)
|
||
r := app.Test(context.Background(), c, log)
|
||
if log != nil {
|
||
_ = log.Close()
|
||
}
|
||
u.mw.Synchronize(func() {
|
||
u.appendStatus(strings.ReplaceAll(r.Text(), "\n", "\r\n"))
|
||
icon := walk.MsgBoxIconError
|
||
hint := "测试未通过"
|
||
if r.OK() {
|
||
icon = walk.MsgBoxIconInformation
|
||
hint = "测试通过"
|
||
u.appendStatus("测试通过，可以启动监听。")
|
||
} else {
|
||
u.appendStatus("测试未通过。")
|
||
}
|
||
u.setHint(hint)
|
||
walk.MsgBox(u.mw, "测试结果", strings.ReplaceAll(r.Text(), "\r\n", "\n"), icon)
|
||
u.setBusy(false)
|
||
})
|
||
}()
|
||
}
|
||
|
||
func (u *ui) onStart() {
|
||
u.mu.Lock()
|
||
if u.running {
|
||
u.mu.Unlock()
|
||
return
|
||
}
|
||
u.mu.Unlock()
|
||
c, err := u.collect()
|
||
if err != nil {
|
||
u.appendStatus("无法启动: " + err.Error())
|
||
walk.MsgBox(u.mw, "MySQL Tunnel", err.Error(), walk.MsgBoxIconError)
|
||
return
|
||
}
|
||
log, err := logger.New(c.LogFile, c.LogLevel, c.LogSQL)
|
||
if err != nil {
|
||
u.appendStatus("日志: " + err.Error())
|
||
return
|
||
}
|
||
ctx, cancel := context.WithCancel(context.Background())
|
||
u.mu.Lock()
|
||
u.cancel = cancel
|
||
u.log = log
|
||
u.running = true
|
||
u.mu.Unlock()
|
||
u.refreshButtons()
|
||
u.appendStatus(fmt.Sprintf("正在监听 %s:%d 影刀用户=%s", c.ListenHost, c.ListenPort, c.LocalUsername))
|
||
u.appendStatus("隧道: " + config.RedactedTunnelURL(c.TunnelURL))
|
||
if u.ni != nil {
|
||
_ = u.ni.SetToolTip(fmt.Sprintf("MySQL Tunnel · %s:%d", c.ListenHost, c.ListenPort))
|
||
}
|
||
go func() {
|
||
err := app.Serve(ctx, c, log)
|
||
u.mw.Synchronize(func() {
|
||
u.mu.Lock()
|
||
u.running = false
|
||
u.cancel = nil
|
||
if u.log != nil {
|
||
_ = u.log.Close()
|
||
u.log = nil
|
||
}
|
||
u.mu.Unlock()
|
||
if err != nil && ctx.Err() == nil {
|
||
u.appendStatus("监听结束: " + logger.RedactError(err))
|
||
} else {
|
||
u.appendStatus("监听已停止")
|
||
}
|
||
if u.ni != nil {
|
||
_ = u.ni.SetToolTip("MySQL Tunnel")
|
||
}
|
||
u.refreshButtons()
|
||
})
|
||
}()
|
||
}
|
||
|
||
func (u *ui) onStop() {
|
||
u.stopServer()
|
||
}
|
||
|
||
func (u *ui) stopServer() {
|
||
u.mu.Lock()
|
||
cancel := u.cancel
|
||
u.mu.Unlock()
|
||
if cancel != nil {
|
||
cancel()
|
||
}
|
||
}
|
||
|
||
func (u *ui) setBusy(b bool) {
|
||
u.mu.Lock()
|
||
u.busy = b
|
||
u.mu.Unlock()
|
||
u.refreshButtons()
|
||
}
|
||
|
||
func (u *ui) refreshButtons() {
|
||
u.mu.Lock()
|
||
running, busy := u.running, u.busy
|
||
u.mu.Unlock()
|
||
if u.saveBtn != nil {
|
||
u.saveBtn.SetEnabled(!busy)
|
||
}
|
||
if u.testBtn != nil {
|
||
u.testBtn.SetEnabled(!busy)
|
||
if busy {
|
||
_ = u.testBtn.SetText("测试中…")
|
||
} else {
|
||
_ = u.testBtn.SetText("测试连接")
|
||
}
|
||
}
|
||
if u.startBtn != nil {
|
||
u.startBtn.SetEnabled(!running && !busy)
|
||
}
|
||
if u.stopBtn != nil {
|
||
u.stopBtn.SetEnabled(running)
|
||
}
|
||
}
|
||
|
||
func (u *ui) setHint(s string) {
|
||
if u.hint == nil {
|
||
return
|
||
}
|
||
_ = u.hint.SetText(s)
|
||
}
|
||
|
||
func (u *ui) appendStatus(line string) {
|
||
line = strings.ReplaceAll(strings.TrimRight(line, "\r\n"), "\n", "\r\n")
|
||
if u.status != nil {
|
||
prev := u.status.Text()
|
||
if prev != "" {
|
||
prev += "\r\n"
|
||
}
|
||
text := prev + time.Now().Format("15:04:05") + " " + line
|
||
_ = u.status.SetText(text)
|
||
end := len([]rune(text))
|
||
u.status.SetTextSelection(end, end)
|
||
}
|
||
first := line
|
||
if i := strings.Index(first, "\r\n"); i >= 0 {
|
||
first = first[:i]
|
||
}
|
||
if len([]rune(first)) > 80 {
|
||
first = string([]rune(first)[:80]) + "…"
|
||
}
|
||
u.setHint(first)
|
||
}
|
||
|
||
func relativeLogFile(cfg *config.Config) string {
|
||
if cfg == nil || cfg.LogFile == "" {
|
||
return config.DefaultLogFile
|
||
}
|
||
if !filepath.IsAbs(cfg.LogFile) {
|
||
return filepath.ToSlash(cfg.LogFile)
|
||
}
|
||
rel, err := filepath.Rel(filepath.Dir(cfg.Path), cfg.LogFile)
|
||
if err != nil {
|
||
return cfg.LogFile
|
||
}
|
||
return filepath.ToSlash(rel)
|
||
}
|
||
|
||
func lineText(e *walk.LineEdit) string {
|
||
if e == nil {
|
||
return ""
|
||
}
|
||
return e.Text()
|
||
}
|
||
|
||
func numValue(e *walk.NumberEdit, def int) int {
|
||
if e == nil {
|
||
return def
|
||
}
|
||
v := int(e.Value())
|
||
if v == 0 {
|
||
return def
|
||
}
|
||
return v
|
||
}
|
||
|
||
func boxChecked(b *walk.CheckBox) bool {
|
||
return b != nil && b.Checked()
|
||
}
|
||
|
||
func nonzero(v, def int) int {
|
||
if v == 0 {
|
||
return def
|
||
}
|
||
return v
|
||
}
|
||
|
||
func orDefault(s, def string) string {
|
||
if strings.TrimSpace(s) == "" {
|
||
return def
|
||
}
|
||
return s
|
||
}
|
||
|
||
func fieldLabel(text string) Label {
|
||
return Label{Text: text, Alignment: AlignHFarVCenter, MinSize: Size{Width: 72}}
|
||
}
|
||
|
||
func (u *ui) applyBranding() error {
|
||
if len(logoPNG) == 0 {
|
||
return nil
|
||
}
|
||
img, err := png.Decode(bytes.NewReader(logoPNG))
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
if ico, err := walk.NewIconFromImage(img); err == nil {
|
||
u.appIcon = ico
|
||
if u.mw != nil {
|
||
_ = u.mw.SetIcon(ico)
|
||
}
|
||
}
|
||
if bmp, err := walk.NewBitmapFromImage(img); err == nil {
|
||
u.appBmp = bmp
|
||
if u.logoView != nil {
|
||
_ = u.logoView.SetImage(bmp)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func timeoutSec(cfg *config.Config) int {
|
||
if cfg == nil || cfg.RequestTimeout <= 0 {
|
||
return config.DefaultTimeoutSec
|
||
}
|
||
return int(cfg.RequestTimeout.Seconds())
|
||
}
|
||
|
||
func hideConsoleIfStandalone() {
|
||
var pids [16]uint32
|
||
n, _, _ := procGetConsoleProcessList.Call(uintptr(unsafe.Pointer(&pids[0])), uintptr(len(pids)))
|
||
if n == 0 || n > 1 {
|
||
return
|
||
}
|
||
hwnd, _, _ := procGetConsoleWindow.Call()
|
||
if hwnd == 0 {
|
||
return
|
||
}
|
||
procShowWindow.Call(hwnd, 0)
|
||
}
|
||
|
||
var (
|
||
user32 = windows.NewLazySystemDLL("user32.dll")
|
||
kernel32 = windows.NewLazySystemDLL("kernel32.dll")
|
||
procShowWindow = user32.NewProc("ShowWindow")
|
||
procGetConsoleWindow = kernel32.NewProc("GetConsoleWindow")
|
||
procGetConsoleProcessList = kernel32.NewProc("GetConsoleProcessList")
|
||
)
|