---
id: 974f36e12dfcece861bfda1af9303980
author: Yunjin Lee
title: 'CGo ilman toteutettu Go Tcl/Tk (modernc.org/tk9.0) GUI: widgettien pakkaaminen ja kuvien renderöinti'
description: Tässä toteutetaan Go-kielellä ikkunoiden luonti, painike- ja valikkopalkkiwidgettien pakkaaminen sekä SVG-, PNG- ja ICO-kuvien renderöinti käyttäen CGo-riippuvuuksia vailla olevaa alustojen välistä kirjastoa modernc.org/tk9.0:aa.
language: fi
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
---
Pythonissa on sisäänrakennettuna oletuksena GUI-kirjastoja, kuten Tkinter.
Viime aikoina on kehitetty myös Go-kielelle [CGo-Free, Cross Platform Tk -kirjasto](https://pkg.go.dev/modernc.org/tk9.0), jonka avulla Tcl/Tk:ta voi käyttää. Tänään tarkastellaan sen perusteita.
## Hello, Tk -sovelluksen luominen
Aloitetaan yksinkertaisella 'Hello, TK!' -esimerkillä.
```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()
}
```
---
Tarkastellaan tarkemmin yllä olevaa esimerkkikoodia ja sen suoritustulosta.
Jos olet aiemmin käyttänyt Pythonin Tk-kirjastoa, ymmärrät rakenteen, jossa widgetit pakataan (pack) ikkunan sisään tai suoraan ikkunan alle. Widgetin tyypistä riippuen esimerkiksi label-widgetit sisältyvät siihen.
_Ipadx ja Ipady ovat lyhenteitä sanoista Internal padding, ja ne säätävät sisäisten widgetien reunustaa. Tässä esimerkissä säädetään painikkeen reunusta._
Tässä kirjastossa on Window-rakenne, ja muuttuja App hallitsee päätason ikkunaa. Se on määritelty valmiiksi kirjaston sisällä. Näin ollen tk.App.Destroy()-funktio, joka lopettaa tk.App.Wait()-kutsun, sulkee päätason ikkunan.
Tarkastellaan nyt joitakin esimerkkejä GitLabin \_examples-kansiosta.
## SVG-tiedoston käsittely
Seuraavassa on esimerkki, jossa SVG-tiedosto näytetään label-widgetissä.
```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()
}
```
Tämä kirjasto käsittelee SVG-tiedostot seuraavasti:
1. Luetaan SVG-tiedoston sisältö merkkijonoksi (tai sisällytetään se suoraan, kuten yllä olevassa esimerkissä).
2. Tämä sisältö välitetään Data-funktiolle, joka muuntaa sen valinnat sisältäväksi merkkijonoksi (-data-valinta).
3. Muunnettu bittijono välitetään NewPhoto-funktiolle, joka palauttaa Img-rakenteen osoittimen, joka edustaa Tcl/Tk-kuvaa.
4. Kulkiessaan Image-funktion läpi Img-rakenteen osoitin muuttuu merkkijonoksi, johon on lisätty -Image-valinta.
5. Rakenteen RAW-arvon sisältävä merkkijono muodostetaan Label-widgetin luomista varten.
ICO- ja PNG-tiedostot käsitellään samankaltaisella tavalla.
## PNG-tiedoston käsittely
```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()
}
```
PNG-tiedoston käsittelyn vaiheet ovat seuraavat:
1. Upotettu gopher.png muunnetaan valinnat sisältäväksi merkkijonotyypiksi.
2. NewPhoto-funktion avulla se muunnetaan tyyppiin \*Img.
3. Image-funktion kautta se muunnetaan RAW-merkkijonoksi, minkä jälkeen se luodaan label-widgetiksi.
ICO-tiedosto käsitellään samalla tavalla, ja ainoa ero SVG-muotoon on Data-funktion sisäinen käsittelytapa.
Tarkastellaan tässä, mitä "valinnat sisältävä merkkijono" oikeastaan on:
```go
type rawOption string
```
Edellä mainittu valinnat sisältävä merkkijono on yksinkertaisesti muotoiltu merkkijono.
```go
func (w *Window) optionString(_ *Window) string {
return w.String()
}
```
optionString-metodi on Window-osoittimen metodi, ja se palauttaa merkkijonon.
Lopuksi tarkastellaan lyhyesti Data-funktion sisäistä rakennetta:
```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)))
}
```
Koodista nähdään, että ICO- tai PNG-tiedostot vaativat koodaus- ja dekoodausvaiheen.
Muissa tapauksissa ilman erityistä muunnosta bittijonoksi muunnettuun merkkijonoon lisätään vain -data-valinta, jolla merkitään, että kyseessä on Data-funktion tulos.
### Kuvan lataaminen valikkowidgetillä
Lisäämällä valikkowidgetin aiemmin harjoiteltuun PNG- ja ICO-tiedostojen lataamisesimerkkiin voidaan luoda sovellus, joka näyttää halutun kuvan.
Tarkastellaan ensin yksinkertaista valikkowidget-esimerkkiä.
```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()
}
```
Tässä esimerkissä kokeiltiin valikkopalkin ja valikoiden luomista, kirjainten korostamista, Command-valintaa, pikanäppäinten sidontaa sekä sovellusikkunan alkukoon asettamista.
Muokataan nyt GetOpenFile-funktiolla määritettyä Command-funktiota ja luodaan ohjelma, joka lataa ja näyttää kuvan.
Ohjelman suunnitelma on seuraava:
1. Rajoitetaan avattavat tiedostot vain PNG- ja ICO-tiedostoihin
2. Käsitellään tiedostodialogissa valittu tiedosto
3. Toteutetaan widget kuvan näyttämistä varten
Seuraavassa on koodi, joka vastaa tätä suunnitelmaa:
```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()
}
```
Yllä oleva koodi toimii seuraavasti:
1. Tarkistetaan tiedostopääte strings-paketin merkkijonovertailufunktiolla
2. Avataan, luetaan ja suljetaan tiedosto os-paketin avulla
3. Luettu kuva näytetään label-widgetissä
## Yhteenveto
Tässä artikkelissa käsiteltiin Go-kielen Tcl/Tk-kirjastoa hyödyntäen seuraavia aiheita:
1. GUI-sovelluksen perusrakenne
2. SVG-, PNG- ja ICO-muotoisten kuvien ja muiden kuvamuotojen käsittely
3. Widgetien pakkaus (pack) ja asettelun hallinta
4. Kuvadatan käsittelyn rakenne
5. Pikanäppäinten sidonta ja widgetin komennot
Go-kielen ja Tcl/Tk:n yhdistäminen mahdollistaa yksinkertaisten mutta käytännöllisten GUI-ohjelmien luomisen. Tämän pohjalta suosittelemme kokeilemaan monimutkaisempien GUI-sovellusten kehittämistä.