---
id: e55cbf5b5116abf3a5fc62c1af99e19b
author: Yunjin Lee
title: Implementace prohlížeče obrázků založeného na seznamovém poli pro více souborů v Go a Tcl/Tk 9.0
description: Implementujeme GUI prohlížeč obrázků s využitím modernc.org/tk9.0 tím, že přidáme vazby příkazů Tcl listbox a handlery virtuálních událostí, které umožňují otevírání více obrazových souborů, přepínání výběru a mazání položek seznamu.
language: cs
date: 2024-11-19T11:51:05.279238471Z
path: /blog/posts/creating-a-image-viewer-with-tk-in-go-z279238471Z
category: gui
---

Minulý příspěvek stručně představil knihovnu CGo-Free Tcl/Tk.
Tentokrát na předchozí příklad navážeme a vytvoříme prohlížeč obrázků.

## Plán prohlížeče obrázků

1. Dřívější zobrazovač obrázků neměl funkci odstranění obrázků, takže se s rostoucím počtem načtených obrázků
   velikost okna stávala nedostatečnou.
   Pojďme odstranit nepoužívané štítky.
2. Pokud chceme obrázky v zobrazovači uvádět jako seznam, vytvořme seznam.
3. Je vhodné načítat více obrázků najednou.
4. Implementujme také odebrání obrázků, které nechceme zobrazit, ze seznamu.
5. Vytvořme funkci, která umožní vybrat a zobrazit konkrétní obrázek z více obrázků.

## Upravená knihovna Tcl/Tk 9.0

Stávající knihovna má nedostatečnou implementaci Listboxu, a proto je obtížné zobrazit seznam obrázků.
Stáhněme si upravenou knihovnu.
Pokud nemáte nainstalované Git CLI, můžete knihovnu stáhnout také jako tarball nebo zip soubor.

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

Nejprve se podívejme na některé z přidaných funkcí.

Než se podíváme na nové funkce, zjistěme strukturu stávajících funkcí na příkladu funkce Destroy v souboru tk.go na řádku 1017.

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

Tato funkce je implementována tak, že předává akci funkci evalErr ve formě Tcl skriptu.
To znamená, že pro implementaci požadované funkce stačí předat příkaz ve formátu odpovídajícího Tcl skriptu.

Jako příklad implementujme metodu pro přidání položky do listboxu.
Nejprve si v oficiální příručce prohlédněme příkaz insert, který lze u listboxu použít.

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

Z popisu příkazu insert na stránce dokumentace vyplývá, že insert vkládá seznam položek na zadaný index.
Pro jeho implementaci tedy můžeme napsat kód:

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

Nyní, když známe přibližný princip implementace, popíšeme další funkce pro Listbox.

### Seznam: vkládání a mazání

```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()
}

```

Ve výše uvedeném programu AddItem vkládá položky oddělené mezerou postupně od indexu 0.
Položky item1 až item3 tak získají indexy 0, 1 a 2.
Jak mazání položek funguje, si ověříme spuštěním příkladu.

### Seznam: získání vybraných položek

Nyní získáme položky vybrané v Listboxu a zkontrolujeme je.

```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()
}
```

Metoda Selected vrací indexy všech položek vybraných v aktuálním Listboxu.
Metoda GetOne vrací hodnotu položky odpovídající danému indexu.
Výsledek je vidět ve výstupu konzole.
Pro úplnost, podobná metoda Get přijímá počáteční a koncový index a vrací hodnoty všech položek v daném rozsahu.

Dále změníme barvy listboxu.

Nejprve se podívejme na následující příklad.

```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()
}
```

![색상 적용 결과](/assets/images/go-tk-imageviewer/listbox_color.png)

Jak je vidět z kódu, výška se zvětšila.
Barvy se rovněž správně uplatnily.
Protože jsme nastavili volbu barvy pouze pro konkrétní položku, změnila se barva pouze u prvního řádku.

Metoda Relief umožňuje změnit styl okraje widgetu na jednu z možností: flat, groove, raise, ridge, solid nebo sunken.
Rozdíl není příliš velký.

## Příklad prohlížeče obrázků

Nyní vytvoříme prohlížeč obrázků s použitím widgetů, které jsme se naučili.
Příkladový program vypadá takto:

```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()
}

```

![이미지 뷰어 실행 결과](/assets/images/go-tk-imageviewer/imageviewer.png)

V tomto příkladu jsou kvůli jednoduchosti implementace všechny widgety obrázků vytvořeny předem při jejich načítání
a duplicitní soubory se nekontrolují.
Výše zmíněné nedostatky lze vylepšit
a také lze pomocí metody DefaultTheme, která je v komentáři, změnit téma.
Doporučujeme si procvičit tvorbu vylepšeného programu s těmito úpravami.

## Shrnutí

V tomto článku jsme si ukázali, jak funguje volání příkazů v knihovně Tcl/Tk pro jazyk Go,
a vytvořili jsme prohlížeč obrázků s přidaným seznamem (Listbox).

1. Způsob volání příkazů knihovny Tcl/Tk
2. Použití Listboxu
3. Změna vlastností widgetu Listbox
4. Tvorba prohlížeče obrázků

Doporučujeme stejným způsobem zkusit upravit i jiné knihovny a dokončit program s přidanými funkcemi.
