1040 lines
30 KiB
Go
1040 lines
30 KiB
Go
package gui
|
|
|
|
import (
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"net/url"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"time"
|
|
|
|
"gioui.org/app"
|
|
"gioui.org/layout"
|
|
"gioui.org/op"
|
|
"gioui.org/op/clip"
|
|
"gioui.org/op/paint"
|
|
"gioui.org/text"
|
|
"gioui.org/unit"
|
|
"gioui.org/widget"
|
|
"gioui.org/widget/material"
|
|
"vpn-client/internal/config"
|
|
"vpn-client/internal/subscription"
|
|
"vpn-client/internal/vless"
|
|
"vpn-client/internal/vpn"
|
|
"vpn-client/internal/wireguard"
|
|
)
|
|
|
|
type tabID string
|
|
|
|
const (
|
|
tabDashboard tabID = "dashboard"
|
|
tabVLESS tabID = "vless"
|
|
tabWireGuard tabID = "wireguard"
|
|
tabSubscriptions tabID = "subscriptions"
|
|
)
|
|
|
|
var (
|
|
bgColor = rgb(0x0A, 0x0F, 0x1F)
|
|
panelColor = rgb(0x12, 0x19, 0x2E)
|
|
panelAltColor = rgb(0x16, 0x22, 0x3B)
|
|
accentColor = rgb(0x58, 0xE1, 0xC1)
|
|
accentSoftColor = rgb(0x5E, 0x9D, 0xFF)
|
|
textColor = rgb(0xF4, 0xF7, 0xFB)
|
|
mutedColor = rgb(0x9C, 0xA9, 0xC2)
|
|
dangerColor = rgb(0xFF, 0x7C, 0x7C)
|
|
warningColor = rgb(0xFF, 0xC8, 0x57)
|
|
successColor = rgb(0x6E, 0xF0, 0xAE)
|
|
borderColor = rgb(0x24, 0x31, 0x4D)
|
|
)
|
|
|
|
type ui struct {
|
|
window *app.Window
|
|
theme *material.Theme
|
|
|
|
tab tabID
|
|
|
|
statusState *config.ConnectionState
|
|
configs *config.Configs
|
|
subs *config.Subscriptions
|
|
|
|
message string
|
|
messageColor color.NRGBA
|
|
busy bool
|
|
|
|
async chan func()
|
|
|
|
tabButtons map[tabID]*widget.Clickable
|
|
|
|
refreshBtn widget.Clickable
|
|
disconnectBtn widget.Clickable
|
|
openLogsBtn widget.Clickable
|
|
addConfigBtn widget.Clickable
|
|
addSubBtn widget.Clickable
|
|
testURLBtn widget.Clickable
|
|
addWGManualBtn widget.Clickable
|
|
addWGFileBtn widget.Clickable
|
|
|
|
vlessConnectBtns []widget.Clickable
|
|
vlessDeleteBtns []widget.Clickable
|
|
vlessPingBtns []widget.Clickable
|
|
|
|
wgConnectBtns []widget.Clickable
|
|
wgDeleteBtns []widget.Clickable
|
|
|
|
subUpdateBtns []widget.Clickable
|
|
subDeleteBtns []widget.Clickable
|
|
subTestBtns []widget.Clickable
|
|
|
|
contentList layout.List
|
|
vlessList layout.List
|
|
wgList layout.List
|
|
subList layout.List
|
|
|
|
configNameEditor widget.Editor
|
|
configURLEditor widget.Editor
|
|
subNameEditor widget.Editor
|
|
subURLEditor widget.Editor
|
|
testURLEditor widget.Editor
|
|
wgNameEditor widget.Editor
|
|
wgConfigEditor widget.Editor
|
|
wgFileNameEditor widget.Editor
|
|
wgFilePathEditor widget.Editor
|
|
}
|
|
|
|
func Run(window *app.Window) error {
|
|
model := newUI(window)
|
|
|
|
var ops op.Ops
|
|
for {
|
|
switch evt := window.Event().(type) {
|
|
case app.DestroyEvent:
|
|
return evt.Err
|
|
case app.FrameEvent:
|
|
model.applyAsync()
|
|
gtx := app.NewContext(&ops, evt)
|
|
model.handleClicks(gtx)
|
|
model.layout(gtx)
|
|
evt.Frame(gtx.Ops)
|
|
}
|
|
}
|
|
}
|
|
|
|
func newUI(window *app.Window) *ui {
|
|
th := material.NewTheme()
|
|
th.Palette = material.Palette{
|
|
Bg: bgColor,
|
|
Fg: textColor,
|
|
ContrastBg: accentSoftColor,
|
|
ContrastFg: textColor,
|
|
}
|
|
|
|
model := &ui{
|
|
window: window,
|
|
theme: th,
|
|
tab: tabDashboard,
|
|
async: make(chan func(), 128),
|
|
tabButtons: map[tabID]*widget.Clickable{
|
|
tabDashboard: new(widget.Clickable),
|
|
tabVLESS: new(widget.Clickable),
|
|
tabWireGuard: new(widget.Clickable),
|
|
tabSubscriptions: new(widget.Clickable),
|
|
},
|
|
contentList: layout.List{Axis: layout.Vertical},
|
|
vlessList: layout.List{Axis: layout.Vertical},
|
|
wgList: layout.List{Axis: layout.Vertical},
|
|
subList: layout.List{Axis: layout.Vertical},
|
|
}
|
|
|
|
model.configNameEditor.SingleLine = true
|
|
model.configURLEditor.SingleLine = true
|
|
model.subNameEditor.SingleLine = true
|
|
model.subURLEditor.SingleLine = true
|
|
model.testURLEditor.SingleLine = true
|
|
model.wgNameEditor.SingleLine = true
|
|
model.wgFileNameEditor.SingleLine = true
|
|
model.wgFilePathEditor.SingleLine = true
|
|
|
|
model.configNameEditor.Submit = true
|
|
model.configURLEditor.Submit = true
|
|
model.subNameEditor.Submit = true
|
|
model.subURLEditor.Submit = true
|
|
model.testURLEditor.Submit = true
|
|
model.wgNameEditor.Submit = true
|
|
model.wgConfigEditor.Submit = true
|
|
model.wgFileNameEditor.Submit = true
|
|
model.wgFilePathEditor.Submit = true
|
|
|
|
model.configURLEditor.SetText("vless://")
|
|
model.testURLEditor.SetText("vless://")
|
|
model.refresh()
|
|
|
|
return model
|
|
}
|
|
|
|
func (u *ui) applyAsync() {
|
|
for {
|
|
select {
|
|
case fn := <-u.async:
|
|
fn()
|
|
default:
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (u *ui) handleClicks(gtx layout.Context) {
|
|
for id, btn := range u.tabButtons {
|
|
for btn.Clicked(gtx) {
|
|
u.tab = id
|
|
}
|
|
}
|
|
|
|
for u.refreshBtn.Clicked(gtx) {
|
|
u.refresh()
|
|
}
|
|
for u.disconnectBtn.Clicked(gtx) {
|
|
u.runAction("Disconnecting...", func() error {
|
|
return vpn.Disconnect(config.LogsDir)
|
|
})
|
|
}
|
|
for u.openLogsBtn.Clicked(gtx) {
|
|
u.openLogs()
|
|
}
|
|
for u.addConfigBtn.Clicked(gtx) {
|
|
u.addVLESSConfig()
|
|
}
|
|
for u.addSubBtn.Clicked(gtx) {
|
|
u.addSubscription()
|
|
}
|
|
for u.testURLBtn.Clicked(gtx) {
|
|
u.testURL()
|
|
}
|
|
for u.addWGManualBtn.Clicked(gtx) {
|
|
u.addWireGuardManual()
|
|
}
|
|
for u.addWGFileBtn.Clicked(gtx) {
|
|
u.addWireGuardFromFile()
|
|
}
|
|
|
|
for i := range u.vlessConnectBtns {
|
|
for u.vlessConnectBtns[i].Clicked(gtx) {
|
|
if i < len(u.configs.VLESS) {
|
|
name := u.configs.VLESS[i].Name
|
|
u.runAction("Connecting to "+name+"...", func() error {
|
|
return vless.Connect(name, config.LogsDir, config.XrayDir)
|
|
})
|
|
}
|
|
}
|
|
for u.vlessDeleteBtns[i].Clicked(gtx) {
|
|
if i < len(u.configs.VLESS) {
|
|
name := u.configs.VLESS[i].Name
|
|
u.deleteVLESSConfig(name)
|
|
}
|
|
}
|
|
for u.vlessPingBtns[i].Clicked(gtx) {
|
|
if i < len(u.configs.VLESS) {
|
|
cfg := u.configs.VLESS[i]
|
|
u.runAction("Testing "+cfg.Name+"...", func() error {
|
|
ok, latency, err := vless.PingServer(cfg.URL, 4*time.Second)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !ok {
|
|
return fmt.Errorf("server is unreachable")
|
|
}
|
|
return fmt.Errorf("latency %.0f ms", latency)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
for i := range u.wgConnectBtns {
|
|
for u.wgConnectBtns[i].Clicked(gtx) {
|
|
if i < len(u.configs.WireGuard) {
|
|
name := u.configs.WireGuard[i].Name
|
|
u.runAction("Connecting WireGuard "+name+"...", func() error {
|
|
return wireguard.Connect(name, config.LogsDir)
|
|
})
|
|
}
|
|
}
|
|
for u.wgDeleteBtns[i].Clicked(gtx) {
|
|
if i < len(u.configs.WireGuard) {
|
|
name := u.configs.WireGuard[i].Name
|
|
u.deleteWireGuardConfig(name)
|
|
}
|
|
}
|
|
}
|
|
|
|
for i := range u.subUpdateBtns {
|
|
for u.subUpdateBtns[i].Clicked(gtx) {
|
|
if i < len(u.subs.Subscriptions) {
|
|
name := u.subs.Subscriptions[i].Name
|
|
u.runAction("Updating "+name+"...", func() error {
|
|
return subscription.UpdateSubscription(name, config.LogsDir)
|
|
})
|
|
}
|
|
}
|
|
for u.subDeleteBtns[i].Clicked(gtx) {
|
|
if i < len(u.subs.Subscriptions) {
|
|
name := u.subs.Subscriptions[i].Name
|
|
u.deleteSubscription(name)
|
|
}
|
|
}
|
|
for u.subTestBtns[i].Clicked(gtx) {
|
|
if i < len(u.subs.Subscriptions) {
|
|
name := u.subs.Subscriptions[i].Name
|
|
u.runAction("Testing configs from "+name+"...", func() error {
|
|
return u.testSubscriptionConfigs(name)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (u *ui) runAction(progress string, fn func() error) {
|
|
if u.busy {
|
|
return
|
|
}
|
|
|
|
u.busy = true
|
|
u.message = progress
|
|
u.messageColor = warningColor
|
|
u.window.Invalidate()
|
|
|
|
go func() {
|
|
err := fn()
|
|
u.async <- func() {
|
|
u.busy = false
|
|
if err != nil {
|
|
if strings.HasPrefix(err.Error(), "latency ") {
|
|
u.message = err.Error()
|
|
u.messageColor = successColor
|
|
} else {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
}
|
|
} else {
|
|
u.message = "Action completed."
|
|
u.messageColor = successColor
|
|
}
|
|
u.refresh()
|
|
u.window.Invalidate()
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (u *ui) refresh() {
|
|
state, _ := vpn.GetStatus()
|
|
cfgs, err := config.LoadConfigs()
|
|
if err != nil || cfgs == nil {
|
|
cfgs = &config.Configs{}
|
|
}
|
|
subs, err := config.LoadSubscriptions()
|
|
if err != nil || subs == nil {
|
|
subs = &config.Subscriptions{}
|
|
}
|
|
|
|
u.statusState = state
|
|
u.configs = cfgs
|
|
u.subs = subs
|
|
u.ensureButtons()
|
|
}
|
|
|
|
func (u *ui) ensureButtons() {
|
|
u.vlessConnectBtns = ensureClickables(u.vlessConnectBtns, len(u.configs.VLESS))
|
|
u.vlessDeleteBtns = ensureClickables(u.vlessDeleteBtns, len(u.configs.VLESS))
|
|
u.vlessPingBtns = ensureClickables(u.vlessPingBtns, len(u.configs.VLESS))
|
|
u.wgConnectBtns = ensureClickables(u.wgConnectBtns, len(u.configs.WireGuard))
|
|
u.wgDeleteBtns = ensureClickables(u.wgDeleteBtns, len(u.configs.WireGuard))
|
|
u.subUpdateBtns = ensureClickables(u.subUpdateBtns, len(u.subs.Subscriptions))
|
|
u.subDeleteBtns = ensureClickables(u.subDeleteBtns, len(u.subs.Subscriptions))
|
|
u.subTestBtns = ensureClickables(u.subTestBtns, len(u.subs.Subscriptions))
|
|
}
|
|
|
|
func ensureClickables(list []widget.Clickable, count int) []widget.Clickable {
|
|
if len(list) >= count {
|
|
return list[:count]
|
|
}
|
|
return append(list, make([]widget.Clickable, count-len(list))...)
|
|
}
|
|
|
|
func (u *ui) addVLESSConfig() {
|
|
name := strings.TrimSpace(u.configNameEditor.Text())
|
|
rawURL := strings.TrimSpace(u.configURLEditor.Text())
|
|
if name == "" || rawURL == "" {
|
|
u.message = "Name and VLESS URL are required."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
if _, err := url.Parse(rawURL); err != nil {
|
|
u.message = "The VLESS URL is not valid."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
cfgs, err := config.LoadConfigs()
|
|
if err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
for _, item := range cfgs.VLESS {
|
|
if item.Name == name {
|
|
u.message = "A config with this name already exists."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
}
|
|
|
|
cfgs.VLESS = append(cfgs.VLESS, config.VLESSConfig{
|
|
Name: name,
|
|
URL: rawURL,
|
|
Protocol: "VLESS",
|
|
})
|
|
if err := config.SaveConfigs(cfgs); err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
u.configNameEditor.SetText("")
|
|
u.configURLEditor.SetText("vless://")
|
|
u.message = "VLESS config added."
|
|
u.messageColor = successColor
|
|
u.refresh()
|
|
}
|
|
|
|
func (u *ui) deleteVLESSConfig(name string) {
|
|
cfgs, err := config.LoadConfigs()
|
|
if err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
filtered := cfgs.VLESS[:0]
|
|
found := false
|
|
for _, item := range cfgs.VLESS {
|
|
if item.Name == name {
|
|
found = true
|
|
continue
|
|
}
|
|
filtered = append(filtered, item)
|
|
}
|
|
cfgs.VLESS = filtered
|
|
if !found {
|
|
u.message = "Config was already removed."
|
|
u.messageColor = warningColor
|
|
return
|
|
}
|
|
if err := config.SaveConfigs(cfgs); err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
u.message = "Config removed."
|
|
u.messageColor = successColor
|
|
u.refresh()
|
|
}
|
|
|
|
func (u *ui) addSubscription() {
|
|
name := strings.TrimSpace(u.subNameEditor.Text())
|
|
rawURL := strings.TrimSpace(u.subURLEditor.Text())
|
|
if name == "" || rawURL == "" {
|
|
u.message = "Subscription name and URL are required."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
if _, err := url.Parse(rawURL); err != nil {
|
|
u.message = "The subscription URL is not valid."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
subs, err := config.LoadSubscriptions()
|
|
if err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
for _, item := range subs.Subscriptions {
|
|
if item.Name == name {
|
|
u.message = "A subscription with this name already exists."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
}
|
|
|
|
subs.Subscriptions = append(subs.Subscriptions, config.Subscription{
|
|
Name: name,
|
|
URL: rawURL,
|
|
})
|
|
if err := config.SaveSubscriptions(subs); err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
u.subNameEditor.SetText("")
|
|
u.subURLEditor.SetText("")
|
|
u.message = "Subscription added."
|
|
u.messageColor = successColor
|
|
u.refresh()
|
|
}
|
|
|
|
func (u *ui) deleteSubscription(name string) {
|
|
subs, err := config.LoadSubscriptions()
|
|
if err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
filtered := subs.Subscriptions[:0]
|
|
found := false
|
|
for _, item := range subs.Subscriptions {
|
|
if item.Name == name {
|
|
found = true
|
|
continue
|
|
}
|
|
filtered = append(filtered, item)
|
|
}
|
|
subs.Subscriptions = filtered
|
|
if !found {
|
|
u.message = "Subscription was already removed."
|
|
u.messageColor = warningColor
|
|
return
|
|
}
|
|
if err := config.SaveSubscriptions(subs); err != nil {
|
|
u.message = err.Error()
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
u.message = "Subscription removed."
|
|
u.messageColor = successColor
|
|
u.refresh()
|
|
}
|
|
|
|
func (u *ui) testURL() {
|
|
rawURL := strings.TrimSpace(u.testURLEditor.Text())
|
|
if rawURL == "" {
|
|
u.message = "Paste a VLESS URL to test."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
u.runAction("Testing custom URL...", func() error {
|
|
ok, latency, err := vless.PingServer(rawURL, 4*time.Second)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !ok {
|
|
return fmt.Errorf("server is unreachable")
|
|
}
|
|
return fmt.Errorf("latency %.0f ms", latency)
|
|
})
|
|
}
|
|
|
|
func (u *ui) openLogs() {
|
|
path := filepath.Clean(config.LogsDir)
|
|
var cmd *exec.Cmd
|
|
switch runtime.GOOS {
|
|
case "windows":
|
|
cmd = exec.Command("explorer", path)
|
|
case "darwin":
|
|
cmd = exec.Command("open", path)
|
|
default:
|
|
cmd = exec.Command("xdg-open", path)
|
|
}
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
u.message = "Could not open logs folder."
|
|
u.messageColor = dangerColor
|
|
return
|
|
}
|
|
|
|
u.message = "Logs folder opened."
|
|
u.messageColor = successColor
|
|
}
|
|
|
|
func (u *ui) layout(gtx layout.Context) layout.Dimensions {
|
|
fill(gtx, bgColor)
|
|
|
|
return layout.UniformInset(unit.Dp(24)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return u.contentList.Layout(gtx, 1, func(gtx layout.Context, _ int) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(u.layoutHeader),
|
|
layout.Rigid(spacerH(18)),
|
|
layout.Rigid(u.layoutStatusBanner),
|
|
layout.Rigid(spacerH(18)),
|
|
layout.Flexed(1, u.layoutBody),
|
|
)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (u *ui) layoutHeader(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Spacing: layout.SpaceBetween, Alignment: layout.Middle}.Layout(
|
|
gtx,
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.Label(u.theme, unit.Sp(15), "GIO DESKTOP")
|
|
lbl.Color = accentColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H3(u.theme, "Go VPN Client")
|
|
lbl.Color = textColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.Body1(u.theme, "A modern control surface for VLESS, subscriptions, and live connection state.")
|
|
lbl.Color = mutedColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Alignment: layout.Middle}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.refreshBtn, "Refresh", accentSoftColor)
|
|
}),
|
|
layout.Rigid(spacerW(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.openLogsBtn, "Logs", panelAltColor)
|
|
}),
|
|
)
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (u *ui) layoutStatusBanner(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelColor, func(gtx layout.Context) layout.Dimensions {
|
|
inset := layout.UniformInset(unit.Dp(18))
|
|
return inset.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
connected := u.statusState != nil && u.statusState.Connected
|
|
statusText := "Offline"
|
|
statusColor := warningColor
|
|
details := "No active tunnel. Open the VLESS or WireGuard tab and press Connect on a saved config."
|
|
|
|
if connected {
|
|
statusText = "Connected"
|
|
statusColor = successColor
|
|
details = fmt.Sprintf("%s via %s", u.statusState.ConfigName, strings.ToUpper(u.statusState.ConfigType))
|
|
}
|
|
|
|
return layout.Flex{Spacing: layout.SpaceBetween, Alignment: layout.Middle}.Layout(
|
|
gtx,
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.Body1(u.theme, "Connection status")
|
|
lbl.Color = mutedColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H4(u.theme, statusText)
|
|
lbl.Color = statusColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.Body1(u.theme, details)
|
|
lbl.Color = textColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
msg := u.message
|
|
if msg == "" {
|
|
msg = "Ready."
|
|
}
|
|
lbl := material.Body2(u.theme, msg)
|
|
lbl.Color = u.messageColor
|
|
if lbl.Color == (color.NRGBA{}) {
|
|
lbl.Color = mutedColor
|
|
}
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.disconnectBtn, "Disconnect", dangerColor)
|
|
}),
|
|
)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (u *ui) layoutBody(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(u.layoutTabs),
|
|
layout.Rigid(spacerH(16)),
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
switch u.tab {
|
|
case tabVLESS:
|
|
return u.layoutVLESS(gtx)
|
|
case tabWireGuard:
|
|
return u.layoutWireGuard(gtx)
|
|
case tabSubscriptions:
|
|
return u.layoutSubscriptions(gtx)
|
|
default:
|
|
return u.layoutDashboard(gtx)
|
|
}
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (u *ui) layoutTabs(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutTab(gtx, tabDashboard, "Overview")
|
|
}),
|
|
layout.Rigid(spacerW(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutTab(gtx, tabVLESS, "VLESS")
|
|
}),
|
|
layout.Rigid(spacerW(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutTab(gtx, tabWireGuard, "WireGuard")
|
|
}),
|
|
layout.Rigid(spacerW(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutTab(gtx, tabSubscriptions, "Subscriptions")
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (u *ui) layoutTab(gtx layout.Context, id tabID, label string) layout.Dimensions {
|
|
bg := panelAltColor
|
|
fg := mutedColor
|
|
if u.tab == id {
|
|
bg = accentSoftColor
|
|
fg = textColor
|
|
}
|
|
return u.buttonLike(gtx, u.tabButtons[id], label, bg, fg, unit.Dp(16), unit.Dp(10))
|
|
}
|
|
|
|
func (u *ui) layoutDashboard(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Spacing: layout.SpaceBetween}.Layout(
|
|
gtx,
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
return u.metricCard(gtx, "VLESS configs", fmt.Sprintf("%d", len(u.configs.VLESS)), accentColor)
|
|
}),
|
|
layout.Rigid(spacerW(12)),
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
return u.metricCard(gtx, "WireGuard configs", fmt.Sprintf("%d", len(u.configs.WireGuard)), accentSoftColor)
|
|
}),
|
|
layout.Rigid(spacerW(12)),
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
return u.metricCard(gtx, "Subscriptions", fmt.Sprintf("%d", len(u.subs.Subscriptions)), successColor)
|
|
}),
|
|
)
|
|
}),
|
|
layout.Rigid(spacerH(16)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(18)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H5(u.theme, "Quick latency probe")
|
|
lbl.Color = textColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(spacerH(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutEditor(gtx, &u.testURLEditor, "Paste a VLESS URL")
|
|
}),
|
|
layout.Rigid(spacerH(12)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.testURLBtn, "Test URL", accentColor)
|
|
}),
|
|
)
|
|
})
|
|
})
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (u *ui) layoutVLESS(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(18)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H5(u.theme, "Add VLESS config")
|
|
lbl.Color = textColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(spacerH(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutEditor(gtx, &u.configNameEditor, "Display name")
|
|
}),
|
|
layout.Rigid(spacerH(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutEditor(gtx, &u.configURLEditor, "VLESS URL")
|
|
}),
|
|
layout.Rigid(spacerH(12)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.addConfigBtn, "Save config", accentColor)
|
|
}),
|
|
)
|
|
})
|
|
})
|
|
}),
|
|
layout.Rigid(spacerH(16)),
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(18)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return u.vlessList.Layout(gtx, len(u.configs.VLESS), func(gtx layout.Context, i int) layout.Dimensions {
|
|
cfg := u.configs.VLESS[i]
|
|
return layout.Inset{Bottom: unit.Dp(12)}.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelAltColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(16)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H6(u.theme, cfg.Name)
|
|
lbl.Color = textColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
meta := material.Body2(u.theme, cfg.Protocol)
|
|
meta.Color = accentColor
|
|
return meta.Layout(gtx)
|
|
}),
|
|
layout.Rigid(spacerH(6)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
value := material.Body2(u.theme, trimForPreview(cfg.URL, 96))
|
|
value.Color = mutedColor
|
|
return value.Layout(gtx)
|
|
}),
|
|
layout.Rigid(spacerH(12)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.vlessConnectBtns[i], "Connect", accentColor)
|
|
}),
|
|
layout.Rigid(spacerW(8)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.vlessPingBtns[i], "Ping", accentSoftColor)
|
|
}),
|
|
layout.Rigid(spacerW(8)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.vlessDeleteBtns[i], "Delete", dangerColor)
|
|
}),
|
|
)
|
|
}),
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (u *ui) layoutSubscriptions(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(18)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H5(u.theme, "Add subscription")
|
|
lbl.Color = textColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(spacerH(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutEditor(gtx, &u.subNameEditor, "Subscription name")
|
|
}),
|
|
layout.Rigid(spacerH(10)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutEditor(gtx, &u.subURLEditor, "Subscription URL")
|
|
}),
|
|
layout.Rigid(spacerH(12)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.addSubBtn, "Save subscription", accentColor)
|
|
}),
|
|
)
|
|
})
|
|
})
|
|
}),
|
|
layout.Rigid(spacerH(16)),
|
|
layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(18)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return u.subList.Layout(gtx, len(u.subs.Subscriptions), func(gtx layout.Context, i int) layout.Dimensions {
|
|
sub := u.subs.Subscriptions[i]
|
|
return layout.Inset{Bottom: unit.Dp(12)}.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return u.card(gtx, panelAltColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(16)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H6(u.theme, sub.Name)
|
|
lbl.Color = textColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
value := material.Body2(u.theme, trimForPreview(sub.URL, 92))
|
|
value.Color = mutedColor
|
|
return value.Layout(gtx)
|
|
}),
|
|
layout.Rigid(spacerH(12)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.subUpdateBtns[i], "Update configs", accentColor)
|
|
}),
|
|
layout.Rigid(spacerW(8)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
return u.layoutButton(gtx, &u.subDeleteBtns[i], "Delete", dangerColor)
|
|
}),
|
|
)
|
|
}),
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (u *ui) metricCard(gtx layout.Context, label, value string, glow color.NRGBA) layout.Dimensions {
|
|
return u.card(gtx, panelColor, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.UniformInset(unit.Dp(18)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(
|
|
gtx,
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.Body2(u.theme, strings.ToUpper(label))
|
|
lbl.Color = mutedColor
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
layout.Rigid(spacerH(8)),
|
|
layout.Rigid(func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.H4(u.theme, value)
|
|
lbl.Color = glow
|
|
return lbl.Layout(gtx)
|
|
}),
|
|
)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (u *ui) layoutEditor(gtx layout.Context, ed *widget.Editor, hint string) layout.Dimensions {
|
|
return u.card(gtx, panelAltColor, func(gtx layout.Context) layout.Dimensions {
|
|
border := clip.RRect{
|
|
Rect: image.Rectangle{Max: gtx.Constraints.Min},
|
|
SE: 14, SW: 14, NW: 14, NE: 14,
|
|
}
|
|
_ = border
|
|
return layout.UniformInset(unit.Dp(14)).Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return material.Editor(u.theme, ed, hint).Layout(gtx)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (u *ui) layoutButton(gtx layout.Context, btn *widget.Clickable, label string, bg color.NRGBA) layout.Dimensions {
|
|
return u.buttonLike(gtx, btn, label, bg, textColor, unit.Dp(14), unit.Dp(10))
|
|
}
|
|
|
|
func (u *ui) buttonLike(gtx layout.Context, btn *widget.Clickable, label string, bg, fg color.NRGBA, hPad, vPad unit.Dp) layout.Dimensions {
|
|
return btn.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
min := image.Pt(gtx.Dp(unit.Dp(96)), gtx.Dp(unit.Dp(40)))
|
|
if gtx.Constraints.Min.X < min.X {
|
|
gtx.Constraints.Min.X = min.X
|
|
}
|
|
if gtx.Constraints.Min.Y < min.Y {
|
|
gtx.Constraints.Min.Y = min.Y
|
|
}
|
|
|
|
rr := gtx.Dp(unit.Dp(14))
|
|
defer clip.RRect{Rect: image.Rectangle{Max: gtx.Constraints.Min}, NW: rr, NE: rr, SW: rr, SE: rr}.Push(gtx.Ops).Pop()
|
|
paint.Fill(gtx.Ops, bg)
|
|
return layout.Inset{
|
|
Top: vPad,
|
|
Bottom: vPad,
|
|
Left: hPad,
|
|
Right: hPad,
|
|
}.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Center.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
|
|
lbl := material.Label(u.theme, unit.Sp(14), label)
|
|
lbl.Color = fg
|
|
lbl.Alignment = text.Middle
|
|
return lbl.Layout(gtx)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
func (u *ui) card(gtx layout.Context, bg color.NRGBA, content layout.Widget) layout.Dimensions {
|
|
return layout.Stack{}.Layout(
|
|
gtx,
|
|
layout.Expanded(func(gtx layout.Context) layout.Dimensions {
|
|
rr := gtx.Dp(unit.Dp(20))
|
|
defer clip.RRect{Rect: image.Rectangle{Max: gtx.Constraints.Max}, NW: rr, NE: rr, SW: rr, SE: rr}.Push(gtx.Ops).Pop()
|
|
paint.Fill(gtx.Ops, bg)
|
|
return layout.Dimensions{Size: gtx.Constraints.Max}
|
|
}),
|
|
layout.Stacked(content),
|
|
)
|
|
}
|
|
|
|
func fill(gtx layout.Context, c color.NRGBA) {
|
|
defer clip.Rect{Max: gtx.Constraints.Max}.Push(gtx.Ops).Pop()
|
|
paint.Fill(gtx.Ops, c)
|
|
}
|
|
|
|
func spacerH(v unit.Dp) layout.Widget {
|
|
return func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Spacer{Height: v}.Layout(gtx)
|
|
}
|
|
}
|
|
|
|
func spacerW(v unit.Dp) layout.Widget {
|
|
return func(gtx layout.Context) layout.Dimensions {
|
|
return layout.Spacer{Width: v}.Layout(gtx)
|
|
}
|
|
}
|
|
|
|
func trimForPreview(value string, limit int) string {
|
|
if len(value) <= limit {
|
|
return value
|
|
}
|
|
return value[:limit-3] + "..."
|
|
}
|
|
|
|
func rgb(r, g, b uint8) color.NRGBA {
|
|
return color.NRGBA{R: r, G: g, B: b, A: 255}
|
|
}
|