使用Go语言构建GUI应用：组件管理与并发解耦的最佳实践

package main

import (
    "fmt"
    "time"
    // "github.com/mattn/go-gtk/gtk" // 实际使用时需要导入Go-GTK库
)

// GuiEvent 定义GUI可能向应用发送的事件类型
type GuiEvent int

const (
    ButtonEvent GuiEvent = iota // 按钮点击事件
    CloseEvent                  // 窗口关闭事件
    // ... 其他GUI事件
)

// AppCommand 定义应用可能向GUI发送的命令类型
type AppCommand int

const (
    UpdateText AppCommand = iota // 更新某个文本组件的命令
    QuitApp                       // 退出GUI应用的命令
    // ... 其他应用命令
)

// GuiMessage 结构体封装GUI向应用发送的消息
type GuiMessage struct {
    Type    GuiEvent    // 事件类型
    Payload interface{} // 事件携带的数据，例如按钮ID、输入框内容
}

// AppMessage 结构体封装应用向GUI发送的命令
type AppMessage struct {
    Type    AppCommand    // 命令类型
    Payload interface{} // 命令携带的数据，例如要更新的文本内容
}

// GuiManager 负责管理GUI窗口和所有组件，并处理通信
type GuiManager struct {
    // 实际GTK组件的引用将在这里声明，用于本地管理
    // 例如：
    // window *gtk.Window
    // button *gtk.Button
    // entry  *gtk.Entry

    appToGui chan AppMessage // 应用逻辑向GUI发送命令的通道
    guiToApp chan GuiMessage // GUI向应用逻辑发送事件的通道
}

// NewGuiManager 创建并初始化GuiManager
func NewGuiManager(appToGui chan AppMessage, guiToApp chan GuiMessage) *GuiManager {
    return &GuiManager{
        appToGui: appToGui,
        guiToApp: guiToApp,
    }
}

// Run 方法启动GUI事件循环。它应该在一个独立的goroutine中运行。
func (gm *GuiManager) Run() {
    // 1. 初始化GTK库 (gtk.Init(nil))
    // 2. 创建主窗口 (gm.window = gtk.NewWindow(gtk.WINDOW_TOPLEVEL))
    // 3. 创建并布局所有GUI组件 (gm.button = gtk.NewButton("Click Me"))
    // 4. 为组件绑定事件处理器，并在事件发生时通过guiToApp通道发送GuiMessage
    //    例如：
    //    gm.button.Connect("clicked", func() {
    //        gm.guiToApp <- GuiMessage{Type: ButtonEvent, Payload: "Button 1 Clicked"}
    //    })
    //    gm.window.Connect("destroy", func() {
    //        gm.guiToApp <- GuiMessage{Type: CloseEvent}
    //    })

    fmt.Println("GUI: GUI Manager started. Waiting for commands or events...")

    // 5. 启动GTK主循环，并在其中监听appToGui通道的命令
    //    实际GTK应用中，gtk.Main()会阻塞，所以需要在一个select循环中处理通道消息
    //    或者在GTK事件循环中通过定时器检查通道
    //    这里我们用一个模拟的select循环来展示
    for {
        select {
        case cmd := <-gm.appToGui:
            switch cmd.Type {
            case UpdateText:
                fmt.Printf("GUI: Received command to update text: %v\n", cmd.Payload)
                // 实际操作：更新 gm.entry.SetText(cmd.Payload.(string))
            case QuitApp:
                fmt.Println("GUI: Received command to quit. Shutting down GUI.")
                // 实际操作：gtk.MainQuit()
                return // 退出GUI goroutine
            }
        case <-time.After(2 * time.Second): // 模拟GUI内部的周期性事件或用户操作
            // 实际中这里是GTK事件循环在处理用户输入
            fmt.Println("GUI: (Simulated) User clicked a button!")
            gm.guiToApp <- GuiMessage{Type: ButtonEvent, Payload: "Simulated Button Click"}
        }
    }
}

func main() {
    // 创建双向通信通道
    appToGui := make(chan AppMessage)
    guiToApp := make(chan GuiMessage)

    // 创建GUI管理器实例
    guiManager := NewGuiManager(appToGui, guiToApp)

    // 在一个独立的goroutine中启动GUI事件循环
    go guiManager.Run()

    fmt.Println("App: Application logic started.")

    // 模拟应用逻辑向GUI发送命令
    go func() {
        time.Sleep(1 * time.Second)
        appToGui <- AppMessage{Type: UpdateText, Payload: "Hello from App!"}
        time.Sleep(3 * time.Second)
        appToGui <- AppMessage{Type: UpdateText, Payload: "Another update!"}
        time.Sleep(7 * time.Second) // 确保GUI有时间发送几次模拟事件
        appToGui <- AppMessage{Type: QuitApp} // 通知GUI退出
    }()

    // 模拟应用逻辑接收GUI事件
    for {
        select {
        case msg := <-guiToApp:
            switch msg.Type {
            case ButtonEvent:
                fmt.Printf("App: Received GUI event: %v with payload: %v\n", msg.Type, msg.Payload)
                // 根据事件类型和数据执行业务逻辑
            case CloseEvent:
                fmt.Println("App: Received GUI close event. Exiting application.")
                return // 退出主应用
            }
        case <-time.After(10 * time.Second): // 设置一个超时，防止应用无限等待
            fmt.Println("App: Timeout, exiting application.")
            return
        }
    }
}