Comment construire GTK dans Golang

Vue d'ensemble

À mesure que Golang devient de plus en plus populaire, de plus en plus de personnes essaient d'utiliser Golang pour créer des applications de bureau. Gtk est une boîte à outils populaire pour créer des interfaces graphiques multiplateformes. Cet article expliquera comment utiliser Golang et Gtk pour créer rapidement des applications GUI et démontrera l'utilisation de certains contrôles de base de Gtk.

Première étape : installer Gtk

La première tâche à accomplir est d'installer Gtk3, cela peut être fait de plusieurs manières, mais voici comment l'installer sur un système Ubuntu ou Debian :

 $ sudo apt-get update
 $ sudo apt-get install libgtk-3-dev

Deuxième étape : installer les packages associés

Afin d'utiliser Golang pour écrire des applications Gtk, vous devez installer les packages suivants :

 $ go get -u github.com/gotk3/gotk3/gtk
 $ go get -u github.com/gotk3/gotk3/glib
 $ go get -u github.com/gotk3/gotk3/cairo

Étape 3 : Créer la fonction principale

Ensuite, vous devez créer une fonction principale pour définir les fenêtres, les cadres, etc. qu'il faut créer. Voici un exemple de fonction Main simple :

 package main

 import (
  "github.com/gotk3/gotk3/gtk"
  "log"
 )

 func main() {
  // 初始化 Gtk
  gtk.Init(nil)

  // 创建新的窗口
  win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
  if err != nil {
    log.Fatal("无法创建窗口:", err)
  }

  // 设置窗口的标题
  win.SetTitle("我的第一个Golang Gtk应用程序")

  // 设置窗口的大小
  win.SetDefaultSize(800, 600)

  // 显示窗口
  win.Show()

  // 进入主循环
  gtk.Main()
 }

Dans cet exemple, la tâche la plus importante de la fonction Main est de créer une nouvelle fenêtre de niveau supérieur à l'aide de gtk.WindowNew. Cette fonction nécessite un paramètre gtk.WindowType pour spécifier le type de fenêtre. Dans ce cas, il suffit de spécifier gtk.WINDOW_TOPLEVEL comme paramètre, ce qui créera une simple fenêtre sans barre de menus ni barre d'outils.

Une fois la fenêtre créée, nous pouvons utiliser win.SetTitle et win.SetDefaultSize pour définir le titre et la taille de la fenêtre. Enfin, nous utilisons win.Show pour afficher la fenêtre à l'écran. Notez également que nous appelons la boucle gtk.Main() à la fin, qui maintiendra la fenêtre ouverte jusqu'à ce que l'utilisateur la ferme.

Étape 4 : Créer une boîte

Maintenant, nous avons créé une fenêtre simple, mais c'est une toile vierge. Nous devons ajouter quelques contrôles à la fenêtre pour mieux organiser la vue. Dans Gtk, cela peut être facilement fait en ajoutant le contrôle à la Box.

Gtk propose quatre types de boîtes différents : GtkBox, GtkHBox, GtkVBox et GtkFrame. GtkBox est une boîte de base qui peut être utilisée pour organiser les contrôles horizontalement ou verticalement. GtkHBox et GtkVBox servent uniquement à effectuer des dispositions horizontales et verticales courantes. GtkFrame est une boîte spéciale qui fournit des étiquettes et des ombres.

Voici un exemple d'ajout d'une GtkBox à une nouvelle fenêtre :

 func main() {
     gtk.Init(nil)
     win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
     if err != nil {
         log.Fatal("无法创建窗口:", err)
     }
     win.SetTitle("我的第一个Golang Gtk应用程序")
     win.SetDefaultSize(800, 600)

     // 创建容器
     box, err := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 4)
     if err != nil {
         log.Fatal("无法创建盒子", err)
     }

     // 向盒子添加一个标签
     label, err := gtk.LabelNew("Hello, Golang!")
     if err != nil {
         log.Fatal("无法创建标签", err)
     }
     box.PackStart(label, true, true, 0)

     // 显示窗口和盒子
     win.Add(box)
     box.ShowAll()
     win.Show()
     gtk.Main()
 }

Dans cet exemple, nous créons d'abord une boîte verticale. En utilisant gtk.BoxNew, nous spécifions gtk.ORIENTATION_VERTICAL et définissons le deuxième paramètre sur 4 pour spécifier l'espacement entre les éléments de la boîte. Ensuite, nous créons une nouvelle étiquette, l'ajoutons à la boîte et définissons enfin le texte de l'étiquette.

La dernière étape consiste à montrer la fenêtre et la boîte. Nous ajoutons la boîte à la fenêtre à l'aide de la méthode win.Add et affichons tous les éléments de la boîte à l'aide de la méthode box.ShowAll().

Étape 5 : Ajouter des boutons

En plus des étiquettes, Gtk prend également en charge divers contrôles, tels que des boutons, des zones de texte et des listes déroulantes. Ajoutons un bouton à notre fenêtre. Voici un exemple d'ajout d'un bouton à une fenêtre :

 func main() {
     gtk.Init(nil)
     win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
     if err != nil {
         log.Fatal("无法创建窗口:", err)
     }
     win.SetTitle("我的第一个Golang Gtk应用程序")
     win.SetDefaultSize(800, 600)

     box, err := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 4)
     if err != nil {
         log.Fatal("无法创建盒子", err)
     }

     button, err := gtk.ButtonNewWithLabel("点击我！")
     if err != nil {
         log.Fatal("无法创建按钮", err)
     }

     button.Connect("clicked", func() {
         log.Println("按钮被点击了！")
     })

     box.PackStart(button, false, false, 0)

     win.Add(box)
     box.ShowAll()
     win.Show()
     gtk.Main()
 }

Dans cet exemple, nous créons d'abord un nouveau bouton, en utilisant gtk.ButtonNewWithLabel, et définissons le texte du bouton sur "Cliquez sur moi !". Nous connectons ensuite le gestionnaire d'événements et le bouton affichera un message sur la console chaque fois que l'utilisateur clique sur le bouton.

Enfin, nous ajoutons le bouton à la fenêtre, définissons le deuxième paramètre sur false pour indiquer de ne pas étirer le contrôle et utilisons la méthode box.PackStart pour ajouter un écart de valeur "pixel".

Étape six : Ajouter une image

Enfin, nous ajouterons une image à notre fenêtre, cela peut être facilement fait en utilisant GtkImage. Voici un exemple d'ajout d'une image à une fenêtre :

 func main() {
     gtk.Init(nil)
     win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
     if err != nil {
         log.Fatal("无法创建窗口:", err)
     }
     win.SetTitle("我的第一个Golang Gtk应用程序")
     win.SetDefaultSize(800, 600)

     box, err := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 4)
     if err != nil {
         log.Fatal("无法创建盒子", err)
     }

     button, err := gtk.ButtonNewWithLabel("点击我！")
     if err != nil {
         log.Fatal("无法创建按钮", err)
     }

     button.Connect("clicked", func() {
         log.Println("按钮被点击了！")
     })

     box.PackStart(button, false, false, 0)

     // 加载图像文件
     img, err := gtk.ImageNewFromFile("test.png")
     if err != nil {
        log.Fatal("无法加载图像", err)
     }

     box.PackStart(img, false, false, 0)

     win.Add(box)
     box.ShowAll()
     win.Show()
     gtk.Main()
 }

Dans cet exemple, nous créons d'abord un bouton et l'ajoutons à la boîte. Ensuite, nous chargeons le fichier test.png situé sur le système de fichiers local et créons une nouvelle instance de GtkImage en utilisant gtk.ImageNewFromFile. Enfin, nous ajoutons l'image à notre boîte en utilisant la méthode box.PackStart.

Conclusion

Gtk est une boîte à outils GUI populaire qui peut être utilisée pour créer des applications GUI multiplateformes. Il est très pratique d'écrire des applications Gtk à l'aide de Golang car Golang fournit de nombreux packages tiers pour prendre en charge l'utilisation de Gtk. Dans cet article, nous avons expliqué comment utiliser Golang et Gtk pour créer des fenêtres et ajouter des contrôles courants tels que des boîtes, des boutons et des images. J'espère que grâce à cet article, vous pourrez facilement commencer à écrire des applications GUI à l'aide de Golang et Gtk.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!