---
id: 974f36e12dfcece861bfda1af9303980
author: Yunjin Lee
title: 'GUI-implementering i Go uden CGo med Tcl/Tk (modernc.org/tk9.0): widgetpakning og billedgengivelse'
description: Der implementeres vinduesoprettelse, pakning af knap- og menulinjewidgets samt rendering af SVG-, PNG- og ICO-billeder i Go ved hjælp af det CGo-uafhængige krydsplatformsbibliotek modernc.org/tk9.0.
language: da
date: 2024-10-22T11:51:27.614782351Z
path: /blog/posts/creating-a-gui-with-tk-in-go-z004dd008
category: gui
lang_canonical:
ko: https://blog.naver.com/bugaku/223629101405
---
Python har som standard indbygget GUI-biblioteker som Tkinter.
For nylig er der også udviklet et [CGo-Free, Cross Platform Tk-bibliotek](https://pkg.go.dev/modernc.org/tk9.0), der gør det muligt at bruge Tcl/Tk i Go-sproget. I dag gennemgår vi dets grundlæggende brug.
## Opret Hello, Tk
Vi starter med et simpelt 'Hello, TK!'-eksempel.
```go
package main
import tk "modernc.org/tk9.0"
func main() {
tk.Pack(
tk.TButton(
tk.Txt("Hello, TK!"),
tk.Command(func() {
tk.Destroy(tk.App)
})),
tk.Ipadx(10), tk.Ipady(5), tk.Padx(15), tk.Pady(10),
)
tk.App.Wait()
}
```
---
Lad os se nærmere på ovenstående eksempelkode og dens eksekveringsresultat.
Hvis du har erfaring med Tk i Python, vil du kunne forstå strukturen, hvor widgets pakkes ind i et vindue eller pakkes direkte under vinduet. Afhængigt af widgettypen indeholder den fx labels.
_Ipadx og Ipady er forkortelser for Internal padding og justerer den indre margen af interne widgets. I dette eksempel justeres knappens margen._
Biblioteket har en Window-struktur, og variablen App administrerer det øverste vindue. Den er foruddefineret i biblioteket. Derfor har funktionen tk.App.Destroy(), som afslutter tk.App.Wait(), til opgave at lukke det øverste vindue.
Lad os nu se nogle eksempler i mappen \_examples på GitLab.
## Håndtering af SVG-filer
Følgende er et eksempel, der viser en SVG-fil i en label-widget.
```go
package main
import . "modernc.org/tk9.0"
// https://en.wikipedia.org/wiki/SVG
const svg = `
`
func main() {
Pack(Label(Image(NewPhoto(Data(svg)))),
TExit(),
Padx("1m"), Pady("2m"), Ipadx("1m"), Ipady("1m"))
App.Center().Wait()
}
```
Sådan håndterer dette bibliotek SVG:
1. Indlæs indholdet af SVG-filen som en streng (eller inkluder det direkte, som i eksemplet ovenfor).
2. Send dette indhold til funktionen Data for at konvertere det til en streng med indbyggede options (-data option).
3. De konverterede bytes sendes til funktionen NewPhoto, som returnerer en pointer til en Img-struktur, der repræsenterer et Tcl/Tk-billede.
4. Når pointeren til Img-strukturen passerer igennem funktionen Image, konverteres den til en streng, hvortil -Image option er tilføjet.
5. Strengen, der indeholder den rå værdi af strukturen, konverteres, fordi det er nødvendigt for oprettelsen af Label-widgetten.
ICO- og PNG-filer håndteres på en lignende måde.
## Håndtering af PNG-filer
```go
package main
import _ "embed"
import . "modernc.org/tk9.0"
//go:embed gopher.png
var gopher []byte
func main() {
Pack(Label(Image(NewPhoto(Data(gopher)))),
TExit(),
Padx("1m"), Pady("2m"), Ipadx("1m"), Ipady("1m"))
App.Center().Wait()
}
```
Processen for håndtering af PNG-filer er som følger:
1. Konverter den indlejrede gopher.png til en streng-type med indbyggede options.
2. Konverter den til typen *Img via funktionen NewPhoto.
3. Efter passage gennem funktionen Image konverteres den til en RAW-streng, hvorefter der oprettes en label-widget.
ICO-filer håndteres på samme måde, og den eneste forskel fra SVG-formatet er den interne behandlingsmetode i funktionen Data.
Lad os her se nærmere på "strengen med indbyggede options":
```go
type rawOption string
```
Den streng med indbyggede options, som nævnt ovenfor, er blot en formateret streng.
```go
func (w *Window) optionString(_ *Window) string {
return w.String()
}
```
Metoden optionString er en metode for Window-pointeren, og den returnerer en streng.
Til sidst skal vi kort se på den interne struktur i funktionen Data:
```go
func Data(val any) Opt {
switch x := val.(type) {
case []byte:
switch {
case bytes.HasPrefix(x, pngSig):
// ok
case bytes.HasPrefix(x, icoSig):
b := bytes.NewBuffer(x)
img, err := ico.Decode(bytes.NewReader(x))
if err != nil {
fail(err)
return rawOption("")
}
b.Reset()
if err := png.Encode(b, img); err != nil {
fail(err)
return rawOption("")
}
val = b.Bytes()
}
}
return rawOption(fmt.Sprintf(`-data %s`, optionString(val)))
}
```
Af koden fremgår det, at ICO- og PNG-filer kræver en encoding/decoding-proces.
I andre tilfælde konverteres bytes blot til en streng, og der tilføjes kun -data option for at angive, at resultatet stammer fra funktionen Data.
### Indlæsning af billeder via en menu-widget
Ved at tilføje en menu-widget til eksemplet med indlæsning af PNG- og ICO-filer kan vi lave et program, der viser det ønskede billede.
Lad os først se på et simpelt eksempel med en menu-widget.
```go
package main
import (
"fmt"
. "modernc.org/tk9.0"
"runtime"
)
func main() {
menubar := Menu()
fileMenu := menubar.Menu()
fileMenu.AddCommand(Lbl("New"), Underline(0), Accelerator("Ctrl+N"))
fileMenu.AddCommand(Lbl("Open..."), Underline(0), Accelerator("Ctrl+O"), Command(func() { GetOpenFile() }))
Bind(App, "", Command(func() { fileMenu.Invoke(1) }))
fileMenu.AddCommand(Lbl("Save As..."), Underline(5))
fileMenu.AddSeparator()
fileMenu.AddCommand(Lbl("Exit"), Underline(1), Accelerator("Ctrl+Q"), ExitHandler())
Bind(App, "", Command(func() { fileMenu.Invoke(4) }))
menubar.AddCascade(Lbl("File"), Underline(0), Mnu(fileMenu))
App.WmTitle(fmt.Sprintf("%s on %s", App.WmTitle(""), runtime.GOOS))
App.Configure(Mnu(menubar), Width("8c"), Height("6c")).Wait()
}
```
I dette eksempel har vi prøvet at oprette en menulinje og menuer, fremhæve bogstaver, bruge Command-option, binde genvejstaster og angive den initiale størrelse af applikationsvinduet.
Nu vil vi ændre Command-funktionen, der er tilknyttet GetOpenFile, så programmet indlæser og viser billeder.
Planen for programmet er som følger:
1. Begræns åbningen til kun PNG- og ICO-filer
2. Håndter den fil, der er valgt i fildialogen
3. Implementer en widget til visning af billedet
Her er koden, der afspejler denne plan:
```go
package main
import (
"fmt"
"log"
"os"
"runtime"
"strings"
. "modernc.org/tk9.0"
)
func handleFileOpen() {
s := GetOpenFile()
for _, photo := range s {
formatCheck := strings.Split(photo, ".")
format := formatCheck[len(formatCheck)-1]
if (strings.Compare(format, "png") == 0) || (strings.Compare(format, "ico") == 0) {
picFile, err := os.Open(photo)
if err != nil {
log.Println("Error while opening photo, error is: ", err)
}
pictureRawData := make([]byte, 10000*10000)
picFile.Read(pictureRawData)
imageLabel := Label(Image(NewPhoto(Data(pictureRawData))))
Pack(imageLabel,
TExit(),
Padx("1m"), Pady("2m"), Ipadx("1m"), Ipady("1m"))
}
picFile.Close()
}
}
func main() {
menubar := Menu()
fileMenu := menubar.Menu()
fileMenu.AddCommand(Lbl("Open..."), Underline(0), Accelerator("Ctrl+O"), Command(handleFileOpen))
Bind(App, "", Command(func() { fileMenu.Invoke(0) }))
fileMenu.AddCommand(Lbl("Exit"), Underline(1), Accelerator("Ctrl+Q"), ExitHandler())
Bind(App, "", Command(func() { fileMenu.Invoke(1) }))
menubar.AddCascade(Lbl("File"), Underline(0), Mnu(fileMenu))
App.WmTitle(fmt.Sprintf("%s on %s", App.WmTitle(""), runtime.GOOS))
App.Configure(Mnu(menubar), Width("10c"), Height("10c")).Wait()
}
```
Ovenstående kode fungerer på følgende måde:
1. Filudvidelsen kontrolleres med strengsammenligningsfunktionerne i pakken strings
2. Filen åbnes, læses og lukkes med pakken os
3. Det indlæste billede vises i en label-widget
## Opsummering
I denne artikel har vi med Go-sprogets Tcl/Tk-bibliotek behandlet følgende:
1. Grundlæggende struktur for en GUI-applikation
2. Håndtering af forskellige billedformater såsom SVG, PNG og ICO
3. Pakning af widgets og layoutstyring
4. Strukturen for billeddatabehandling
5. Genvejstastbinding og widget-kommandoer
Ved at bruge Go-sproget sammen med Tcl/Tk kan man lave enkle, men praktiske GUI-programmer. Med dette som udgangspunkt opfordres du til at kaste dig ud i udviklingen af mere komplekse GUI-applikationer.