---
id: 974f36e12dfcece861bfda1af9303980
author: Yunjin Lee
title: 'CGo-fri Go Tcl/Tk (modernc.org/tk9.0) GUI-implementering: pakking av widgeter og bildegjengivelse'
description: CGo-avhengighetsfritt krysplattformbibliotek modernc.org/tk9.0 brukes til å implementere vindusopprettelse, pakking av knapp- og menylinjekomponenter samt gjengivelse av SVG-, PNG- og ICO-bilder i Go.
language: "no"
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 GUI-biblioteker som Tkinter innebygd som standard.
Nylig er også [CGo-Free, Cross Platform Tk-biblioteket](https://pkg.go.dev/modernc.org/tk9.0) utviklet, som gjør det mulig å bruke Tcl/Tk i Go-språket. I dag skal vi se på de grunnleggende bruksmåtene.
## Lage Hello, Tk
Vi starter med et enkelt '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()
}
```
---
La oss se nærmere på eksempelkoden og kjøreresultatet.
For den som har erfaring med Tk i Python, vil strukturen der widgeter pakkes inn i et vindu, eller pakkes direkte under vinduet, være kjent. Avhengig av widgettypen, inngår for eksempel etiketter i denne strukturen.
_Ipadx og Ipady er forkortelser for Internal padding og styrer den indre marginen til widgeter. I dette eksempelet justeres marginen til knappen._
Biblioteket har en Window-struktur, og variabelen App administrerer hovedvinduet. Denne er forhåndsdefinert i biblioteket. Funksjonen tk.App.Destroy(), som avslutter tk.App.Wait(), har derfor som oppgave å lukke hovedvinduet.
La oss nå se på noen eksempler i mappen \_examples på GitLab.
## Håndtering av SVG-filer
Følgende er et eksempel som viser en SVG-fil i en etikettwidget.
```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()
}
```
Slik håndterer dette biblioteket SVG:
1. Les innholdet i SVG-filen inn som en streng (eller inkluder det direkte, som i eksemplet over).
2. Send dette innholdet til funksjonen Data for å konvertere det til en streng med alternativer (-data-alternativet).
3. De konverterte bytene sendes til funksjonen NewPhoto, som returnerer en peker til strukturen Img som representerer et Tcl/Tk-bilde.
4. Når pekeren til strukturen Img sendes gjennom funksjonen Image, konverteres den til en streng med -Image-alternativet lagt til.
5. Grunnen til at den konverteres til en streng som inneholder RAW-verdien til strukturen, er for å kunne opprette Label-widgeten.
ICO- og PNG-filer håndteres på en lignende måte.
## Håndtering av 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()
}
```
Prosessen for PNG-filer er som følger:
1. Konverter den innebygde gopher.png til en streng av typen med alternativer.
2. Konverter til typen \*Img ved hjelp av funksjonen NewPhoto.
3. Etter å ha passert funksjonen Image, konverteres den til en RAW-streng, og deretter opprettes den som en etikettwidget.
ICO-filer behandles på samme måte, og den eneste forskjellen fra SVG-formatet ligger i hvordan funksjonen Data håndterer dem internt.
Her skal vi se nærmere på hva "strengen med alternativer" egentlig er:
```go
type rawOption string
```
Strengen med alternativer nevnt over er ganske enkelt en formatert streng.
```go
func (w *Window) optionString(_ *Window) string {
return w.String()
}
```
Metoden optionString er en metode for pekeren til Window og returnerer en streng.
Til slutt skal vi se kort på den indre strukturen til funksjonen 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)))
}
```
Av koden ser vi at ICO- og PNG-filer krever koding/dekoding.
For andre tilfeller utføres ingen spesiell konvertering; bare -data-alternativet legges til den byte-konverterte strengen for å vise at resultatet er et produkt av funksjonen Data.
### Laste inn bilder med en menywidget
Ved å legge til en menywidget i eksemplene for innlasting av PNG- og ICO-filer, kan vi lage et program som viser ønskede bilder.
La oss først se på et enkelt eksempel med menywidget.
```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 eksemplet har vi prøvd å lage en menylinje og menyer, utheve tegn, bruke Command-alternativet, binde hurtigtaster og angi den opprinnelige størrelsen på programvinduet.
Nå skal vi endre Command-funksjonen som er knyttet til GetOpenFile, slik at vi lager et program som laster inn og viser bilder.
Planen for programmet er som følger:
1. Begrens åpning til kun PNG- og ICO-filer
2. Behandle filen som er valgt i fildialogen
3. Implementere en widget for visning av bildet
Følgende er koden som reflekterer denne planen:
```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()
}
```
Koden over fungerer på følgende måte:
1. Filendelsen kontrolleres med strengsammenligningsfunksjonen i pakken strings
2. Filen åpnes, leses og lukkes ved hjelp av pakken os
3. Det innleste bildet vises i en etikettwidget
## Oppsummering
I denne artikkelen har vi, ved hjelp av Tcl/Tk-biblioteket for Go-språket, behandlet følgende:
1. Grunnleggende struktur for GUI-applikasjoner
2. Håndtering av ulike bildeformater som SVG, PNG og ICO
3. Pakking av widgeter og layoutadministrasjon
4. Strukturen for behandling av bildedata
5. Hurtigtastbinding og widget-kommandoer
Ved å kombinere Go-språket med Tcl/Tk kan man lage enkle, men praktiske GUI-programmer. Med dette som utgangspunkt oppfordres du til å utfordre deg selv med mer komplekse GUI-applikasjoner.