---
id: e55cbf5b5116abf3a5fc62c1af99e19b
author: Yunjin Lee
title: Implementierung eines Bildbetrachters auf Basis einer Mehrfachdatei-Listbox mit Go und Tcl/Tk 9.0
description: Wir implementieren einen GUI-Bildbetrachter, indem wir in modernc.org/tk9.0 Tcl-Listbox-Befehlsbindungen und virtuelle Ereignishandler hinzufügen, sodass das Öffnen mehrerer Bilddateien, das Umschalten der Auswahl und das Löschen von Listenelementen möglich wird.
language: de
date: 2024-11-19T11:51:05.279238471Z
path: /blog/posts/creating-a-image-viewer-with-tk-in-go-z279238471Z
category: gui
---

Im letzten Beitrag haben wir die CGo-freie Tcl/Tk-Bibliothek kurz vorgestellt.
In diesem Beitrag wollen wir das Beispiel des letzten Mal aufgreifen und daraus einen Bildbetrachter entwickeln.

## Planung des Bildbetrachters

1. Dem Bildanzeiger aus dem letzten Beitrag fehlte eine Funktion zum Löschen von Bildern, sodass das Fenster bei dem Laden mehrerer Bilder zu klein wurde.
   Lassen Sie uns nicht mehr benötigte Labels löschen.
2. Wenn der Bildanzeiger mehrere Bilder auflisten soll, erstellen wir dafür eine Liste.
3. Es ist empfehlenswert, mehrere Bilder auf einmal zu laden.
4. Außerdem implementieren wir das Entfernen von Bildern aus der Liste, die nicht mehr angezeigt werden sollen.
5. Lassen Sie uns eine Funktion schaffen, mit der ein bestimmtes Bild aus mehreren Bildern ausgewählt und angezeigt werden kann.

## Modifizierte Tcl/Tk 9.0 Bibliothek

Die bestehende Bibliothek bietet nur eine unzureichende Implementierung der Listbox, weshalb es schwierig ist, eine Bildliste anzuzeigen.
Laden wir die modifizierte Bibliothek herunter.
Falls die Git CLI nicht installiert ist, können Sie die Bibliothek auch als Tarball- oder Zip-Datei herunterladen.

```bash
git clone https://github.com/gg582/tk9.0
```

Zunächst betrachten wir einige der hinzugefügten Funktionen.

Bevor wir die neuen Funktionen betrachten, wollen wir anhand der Destroy-Funktion in tk.go, Zeile 1017, kurz den Aufbau der bestehenden Funktionen nachvollziehen.

```go
func Destroy(options ...Opt) {
	evalErr(fmt.Sprintf("destroy %s", collect(options...)))
}
```

Diese Funktion ist implementiert, indem die Aktion im Tcl-Skriptformat an die Funktion evalErr übergeben wird.
Das bedeutet, dass zur Umsetzung einer gewünschten Funktion lediglich der entsprechende Befehl im Tcl-Skriptformat übergeben werden muss.

Als Beispiel implementieren wir eine Methode zum Hinzufügen eines Eintrags zu einer Listbox.
Zunächst betrachten wir im offiziellen Handbuch den Befehl insert, der unter den für die Listbox verfügbaren Befehlen zu finden ist.

[insert-Befehl](https://www.tcl.tk/man/tcl8.6/TkCmd/listbox.htm#M29)

Laut der Beschreibung des insert-Befehls fügt insert die aufgelisteten Elemente an einem bestimmten Index ein.
Um dies umzusetzen, können wir somit folgenden Code schreiben:

```go
func (l *ListboxWidget) AddItem(index int, items string) {
	evalErr(fmt.Sprintf("%s insert %d %s", l.fpath, index, items))
}
```

Nachdem wir nun das grobe Implementierungsprinzip verstanden haben, erläutern wir zunächst die zusätzlichen Funktionen für die Listbox.

### Liste: Einfügen/Löschen

```go
package main
import . "modernc.org/tk9.0"

func main() {
    length := 3
    l := Listbox()
    l.AddItem(0, "item1 item2 item3")
    b1 := TButton(Txt("Delete Multiple Items, index (0-1)"), Command( func(){
        if length >= 2 {
            l.DeleteItems(0,1)
            length-=2
        }
    }))
    b2 := TButton(Txt("Delete One Item, index (0)"), Command( func () {
        if length > 0 {
            l.DeleteOne(0)
            length-=1
        }
    }))
    Pack(TExit(),l,b1,b2)
    App.Wait()
}

```

Im obigen Programm fügt AddItem die durch Leerzeichen getrennten, unterschiedlichen Elemente der Reihe nach ab Index 0 ein.
item1 bis item3 erhalten dabei der Reihe nach die Indizes 0, 1 und 2.
Wie das Löschen von Einträgen funktioniert, erfahren wir, indem wir das Beispiel ausführen.

### Liste: Ausgewählte Einträge abrufen

Nun rufen wir die in der Listbox ausgewählten Einträge ab und überprüfen sie.

```go
package main

import . "modernc.org/tk9.0"

func main() {
    l := Listbox()
    l.SelectMode("multiple")
    l.AddItem(0, "item1 item2 item3")
    btn := TButton(Txt("Print Selected"), Command( func() {
        sel := l.Selected()
        for _, i := range sel {
            println(l.GetOne(i))
        }
    }))

    Pack(TExit(), l, btn)
    App.Wait()
}
```

Die Methode Selected ruft die Indizes aller aktuell in der Listbox ausgewählten Einträge ab.
Die Methode GetOne liefert den Wert des Eintrags zum jeweiligen Index.
Das Ergebnis lässt sich an der Konsolenausgabe erkennen.
Ergänzend sei erwähnt, dass die ähnliche Methode Get einen Start- und einen Endindex entgegennimmt und alle Werte im Bereich zurückgibt.

Als Nächstes ändern wir die Farben der Listbox.

Betrachten wir zunächst das folgende Beispiel.

```go
package main

import . "modernc.org/tk9.0"

func main() {
    l := Listbox()
    l.Background("blue")
    l.Foreground("yellow")
    l.SelectBackground("black")
    l.SelectForeground("white")
    l.Height(20)
    l.Width(6)
    l.AddItem(0, "item1 item2 item3")
    l.ItemForeground(0,"red")
    l.ItemBackground(0,"green")
    l.ItemSelectBackground(0,"white")
    l.ItemSelectForeground(0,"black")
    l.Relief("ridged")
    Pack(TExit(),l)
    App.Wait()
}
```

![Ergebnis der Farbanwendung](/assets/images/go-tk-imageviewer/listbox_color.png)

Wie im Code angegeben, ist die Höhe gewachsen.
Außerdem ist zu sehen, dass die Farben korrekt angewendet wurden.
Da hier eine Option festgelegt ist, die nur für bestimmte Einträge eine andere Farbe setzt, ist zu erkennen, dass nur die erste Zeile in einer anderen Farbe dargestellt wird.

Mit der Methode Relief kann man außerdem, auch wenn der Unterschied gering ist, den Stil des Widget-Rahmens zwischen flat, groove, raise, ridge, solid und sunken ändern.

## Beispiel eines Bildbetrachters

Nun wollen wir mithilfe der zuvor erlernten Widgets einen Bildbetrachter erstellen.
Das Beispielprogramm lautet wie folgt.

```go
package main

import (
    "fmt"
    "log"
    "os"
    "runtime"
    "strings"
    "path"

    . "modernc.org/tk9.0"
)

var pbuttons []*TButtonWidget
var extensions []FileType
var pbutton *TButtonWidget = nil
var listbox, listbox2 *ListboxWidget
var cur *LabelWidget = nil
var imagesLoaded []*LabelWidget
func PhotoName(fileName string) string {
        fileName = path.Base(fileName)
        return fileName[:len(fileName)-len(path.Ext(fileName))]
}

func handleFileOpen() {
    res := GetOpenFile(Multiple(true),Filetypes(extensions)) //다중 선택을 활성화하고 필터를 켭니다.
    s := make([]string,0,1000)
    for _, itm := range res {
        if itm != "" {
            tmp := strings.Split(itm," ")
            s = append(s,tmp...)
        }
    }

    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))))
                        imagesLoaded = append(imagesLoaded,imageLabel)
            var deleteTestButton *TButtonWidget
            deleteTestButton = TButton(
                Txt("Unshow Image"),
            Command(func() {
                GridForget(imageLabel.Window)
                GridForget(deleteTestButton.Window)
            }))

            pbuttons = append(pbuttons,deleteTestButton)

                        listbox.AddItem(len(imagesLoaded)-1,PhotoName(photo))
                        listbox2.AddItem(len(imagesLoaded)-1,PhotoName(photo))
            picFile.Close()
        }
    }
}

func DeleteSelected () {
    s:=listbox.Selected()
    if len(s) == 0 {
        return
        }
    for _, i := range s {
        listbox.DeleteOne(i)
        listbox2.DeleteOne(i)
        if len(imagesLoaded)-1>i {
            continue
        }
        if cur == imagesLoaded[i] {
            pbutton = nil
            cur = nil
        }
        Destroy(imagesLoaded[i])
        Destroy(pbuttons[i])
                imagesLoaded = append(imagesLoaded[:i],imagesLoaded[i+1:]...)
        pbuttons = append(pbuttons[:i], pbuttons[i+1:]...)
    }
}

func SelectImage() {
        s:=listbox2.Selected()
        if len(s) == 0 {
                return
        }

    if len(imagesLoaded) -1 < s[0] {
        return
    }
    if imagesLoaded[s[0]] == nil {
        return
    }
    if cur != nil {
            GridForget(cur.Window)
    }
    if pbutton != nil {
        GridForget(pbutton.Window)
    }

        Grid(imagesLoaded[s[0]], Row(0), Column(2))
    Grid(pbuttons[s[0]], Row(0), Column(3))
    cur = imagesLoaded[s[0]]
    pbutton = pbuttons[s[0]]
}

func SelectIndex(index int) {

    if len(imagesLoaded) -1 <index {
        return
    }
    if imagesLoaded[index] == nil {
        return
    }
    if cur != nil {
            GridForget(cur.Window)
    }
    if pbutton != nil {
        GridForget(pbutton.Window)
    }

        Grid(imagesLoaded[index], Row(0), Column(2))
    Grid(pbuttons[index], Row(0), Column(3))
    cur = imagesLoaded[index]
    pbutton = pbuttons[index]
}

func main() {
    menubar := Menu()
    //DefaultTheme("awdark","themes/awthemes-10.4.0")
    //테마를 사용하고 싶을 때에는 테마 명과 경로를 지정해 줍니다.
    fileMenu := menubar.Menu()
    extensions = make([]FileType,0,1)
    extensions = append(extensions, FileType{ "Supported Images", []string {".png",".ico"}, "" } )
    //필터에 png와 ico를 넣어 줍니다.
    fileMenu.AddCommand(Lbl("Open..."), Underline(0), Accelerator("Ctrl+O"), Command(func () {
        handleFileOpen()
        SelectIndex(len(imagesLoaded)-1)
    } ))
    Bind(App, "<Control-o>", Command(func() { fileMenu.Invoke(0) }))
    fileMenu.AddCommand(Lbl("Exit"), Underline(1), Accelerator("Ctrl+Q"), ExitHandler())
    Bind(App, "<Control-q>", Command(func() { fileMenu.Invoke(1) }))
    menubar.AddCascade(Lbl("File"), Underline(0), Mnu(fileMenu))
        imagesLoaded = make([]*LabelWidget, 0, 10000)
    pbuttons = make([]*TButtonWidget,0,10000)
    var scrollx, scroll, scroll2, scrollx2 *TScrollbarWidget
        listbox = Listbox(Yscrollcommand(func(e *Event) { e.ScrollSet(scroll)}) , Xscrollcommand( func(e *Event) { e.ScrollSet(scrollx)}))
        listbox2 = Listbox(Yscrollcommand(func(e *Event) { e.ScrollSet(scroll2)}), Xscrollcommand(func(e *Event) { e.ScrollSet(scrollx2)}))
        listbox.SelectMode("multiple")
        listbox2 = Listbox()
        listbox.Background("white")
        listbox.SelectBackground("blue")
        listbox.SelectForeground("yellow")
        listbox2.Background("grey")
        listbox2.SelectBackground("green")
    listbox2.SelectForeground("blue")
    listbox2.SelectBackground("brown")
        listbox.Height(5)
        listbox.Width(4)
        listbox2.Height(5)
        listbox2.Width(4)
        delBtn := Button(Txt("Delete"), Command(func () { DeleteSelected() }))
        selBtn := Button(Txt("Select"), Command(func () { SelectImage() }))
        scroll = TScrollbar(Command(func(e *Event) { e.Yview(listbox) }))
        scrollx = TScrollbar(Orient("horizontal"),Command(func(e *Event) { e.Xview(listbox) }))
    scroll2 = TScrollbar(Command(func(e *Event) { e.Yview(listbox2) }))
        scrollx2 = TScrollbar(Orient("horizontal"),Command(func(e *Event) { e.Xview(listbox2) }))
        Grid(listbox,Row(1),Column(0), Sticky("nes"))
        Grid(scroll,Row(1),Column(1), Sticky("nes"))
    Grid(scrollx,Row(2),Column(0),  Sticky("nes"))
        Grid(delBtn,Row(3),Column(0), Sticky("nes"))
        Grid(listbox2,Row(1),Column(2), Sticky("nes"))
        Grid(scroll2,Row(1),Column(3), Sticky("nes"))
    Grid(scrollx2,Row(2),Column(2), Sticky("nes"))
        Grid(selBtn,Row(3),Column(2), Sticky("nes"))
    App.WmTitle(fmt.Sprintf("%s on %s", App.WmTitle(""), runtime.GOOS))
    App.Configure(Mnu(menubar), Width("80c"), Height("60c")).Wait()
}

```

![Ausführungsergebnis des Bildbetrachters](/assets/images/go-tk-imageviewer/imageviewer.png)

In diesem Beispiel werden zur Vereinfachung der Implementierung alle Bild-Widgets beim Laden bereits im Voraus erstellt, und doppelte Dateien werden nicht überprüft.
Die oben genannten Probleme können verbessert werden, und der Abschnitt mit der auskommentierten DefaultTheme-Methode kann verwendet werden, um das Theme zu ändern.
Wir empfehlen Ihnen, zum Üben ein Programm zu erstellen, in dem diese Aspekte verbessert sind.

## Zusammenfassung

In diesem Beitrag haben wir untersucht, wie Aufrufe von Befehlen in der Go-Tcl/Tk-Bibliothek funktionieren, und einen Bildbetrachter mit Listbox erstellt.

1. Methode zum Aufruf von Befehlen der Tcl/Tk-Bibliothek
2. Verwendung der Listbox
3. Änderung der Eigenschaften des Listbox-Widgets
4. Erstellung eines Bildbetrachters

Versuchen Sie auf diese Weise auch, andere Bibliotheken zu modifizieren, und erstellen Sie mit den hinzugefügten Funktionen ein vollständiges Programm.