Go 每日一库之 fyne

时间  2020-06-22
标签 每日 fyne 繁體版
原文   原文链接

简介

Go 语言生态中，GUI 一直是短板，更别说跨平台的 GUI 了。fyne向前迈了一大步。fyne 是 Go 语言编写的跨平台的 UI 库，它能够很方便地移植到手机设备上。fyne使用上很是简单，同时它还提供fyne命令打包静态资源和应用程序。咱们先简单介绍基本控件和布局，而后介绍如何发布一个fyne应用程序。html

快速使用

本文代码使用 Go Modules。git

先初始化：github

$ mkdir fyne && cd fyne
$ go mod init github.com/darjun/go-daily-lib/fyne
复制代码

因为fyne包含一些 C/C++ 的代码，因此须要gcc编译工具。在 Linux/Mac OSX 上，gcc基本是标配，在 windows 上咱们有 3 种方式安装gcc工具链：golang

本文选择TDM-GCC的方式安装。到jmeubank.github.io/tdm-gcc/dow…下载安装程序并安装。正常状况下安装程序会自动设置PATH路径。打开命令行，键入gcc -v。若是正常输出版本信息，说明安装成功且环境变量设置正确。canvas

安装fyne：windows

$ go get -u fyne.io/fyne
复制代码

到此准备工做已经完成，咱们开始编码。按照惯例，先以Hello, World程序开始：微信

package main

import (
  "fyne.io/fyne"
  "fyne.io/fyne/app"
  "fyne.io/fyne/widget"
)

func main() {
  myApp := app.New()

  myWin := myApp.NewWindow("Hello")
  myWin.SetContent(widget.NewLabel("Hello Fyne!"))
  myWin.Resize(fyne.NewSize(200, 200))
  myWin.ShowAndRun()
}
复制代码

运行结果以下：app

fyne的使用很简单。每一个fyne程序都包括两个部分，一个是应用程序对象myApp，经过app.New()建立。另外一个是窗口对象，经过应用程序对象myApp来建立myApp.NewWindow("Hello")。myApp.NewWindow()方法中传入的字符串就是窗口标题。框架

fyne提供了不少经常使用的组件，经过widget.NewXXX()建立（XXX为组件名）。上面示例中，咱们建立了一个Label控件，而后设置到窗口中。最后，调用myWin.ShowAndRun()开始运行程序。实际上myWin.ShowAndRun()等价于ide

myWin.Show()
myApp.Run()
复制代码

myWin.Show()显示窗口，myApp.Run()开启事件循环。

注意一点，fyne默认窗口大小是根据内容的宽高来设置的。上面咱们调用myWin.Resize()手动设置了大小。不然窗口只能放下字符串Hello Fyne!。

fyne包结构划分

fyne将功能划分到多个子包中：

  • fyne.io/fyne：提供全部fyne应用程序代码共用的基础定义，包括数据类型和接口；
  • fyne.io/fyne/app：提供建立应用程序的 API；
  • fyne.io/fyne/canvas：提供Fyne使用的绘制 API；
  • fyne.io/fyne/dialog：提供对话框组件；
  • fyne.io/fyne/layout：提供多种界面布局；
  • fyne.io/fyne/widget：提供多种组件，fyne全部的窗体控件和交互元素都在这个子包中。

Canvas

在fyne应用程序中，全部显示元素都是绘制在画布（Canvas）上的。这些元素都是画布对象（CanvasObject）。调用Canvas.SetContent()方法可设置画布内容。Canvas通常和布局（Layout）容器（Container）一块儿使用。canvas子包中提供了一些基础的画布对象：

package main

import (
  "image/color"
  "math/rand"

  "fyne.io/fyne"
  "fyne.io/fyne/app"
  "fyne.io/fyne/canvas"
  "fyne.io/fyne/layout"
  "fyne.io/fyne/theme"
)

func main() {
  a := app.New()
  w := a.NewWindow("Canvas")

  rect := canvas.NewRectangle(color.White)

  text := canvas.NewText("Hello Text", color.White)
  text.Alignment = fyne.TextAlignTrailing
  text.TextStyle = fyne.TextStyle{Italic: true}

  line := canvas.NewLine(color.White)
  line.StrokeWidth = 5

  circle := canvas.NewCircle(color.White)
  circle.StrokeColor = color.Gray{0x99}
  circle.StrokeWidth = 5

  image := canvas.NewImageFromResource(theme.FyneLogo())
  image.FillMode = canvas.ImageFillOriginal

  raster := canvas.NewRasterWithPixels(
    func(_, _, w, h int) color.Color {
      return color.RGBA{uint8(rand.Intn(255)),
        uint8(rand.Intn(255)),
        uint8(rand.Intn(255)), 0xff}
    },
  )

  gradient := canvas.NewHorizontalGradient(color.White, color.Transparent)

  container := fyne.NewContainerWithLayout(
    layout.NewGridWrapLayout(fyne.NewSize(150, 150)),
    rect, text, line, circle, image, raster, gradient))
  w.SetContent(container)
  w.ShowAndRun()
}
复制代码

程序运行结果以下：

canvas.Rectangle是最简单的画布对象了，经过canvas.NewRectangle()建立，传入填充颜色。

canvas.Text是显示文本的画布对象，经过canvas.NewText()建立，传入文本字符串和颜色。该对象可设置对齐方式和字体样式。对齐方式经过设置Text对象的Alignment字段值，取值有：

  • TextAlignLeading：左对齐；
  • TextAlignCenter：中间对齐；
  • TextAlignTrailing：右对齐。

字体样式经过设置Text对象的TextStyle字段值，TextStyle是一个结构体：

type TextStyle struct {
  Bold      bool
  Italic    bool
  Monospace bool
}
复制代码

对应字段设置为true将显示对应的样式：

  • Bold：粗体；
  • Italic：斜体；
  • Monospace：系统等宽字体。

咱们还能够经过设置环境变量FYNE_FONT为一个.ttf文件从而使用外部字体。

canvas.Line是线段，经过canvas.NewLine()建立，传入颜色。能够经过line.StrokeWidth设置线段宽度。默认状况下，线段是从父控件或画布的左上角到右下角的。可经过line.Move()和line.Resize()修改位置。

canvas.Circle是圆形，经过canvas.NewCircle()建立，传入颜色。另外经过StrokeColor和StrokeWidth设置圆形边框的颜色和宽度。

canvas.Image是图像，能够经过已加载的程序资源建立（canvas.NewImageFromResource()），传入资源对象。或经过文件路径建立（canvas.NewImageFromFile()），传入文件路径。或经过已构造的image.Image对象建立（canvas.NewImageFromImage()）。能够经过FillMode设置图像的填充模式：

  • ImageFillStretch：拉伸，填满空间；
  • ImageFillContain：保持宽高比；
  • ImageFillOriginal：保持原始大小，不缩放。

下面程序演示了这 3 种建立图像的方式：

package main

import (
  "image"
  "image/color"

  "fyne.io/fyne"
  "fyne.io/fyne/app"
  "fyne.io/fyne/canvas"
  "fyne.io/fyne/layout"
  "fyne.io/fyne/theme"
)

func main() {
  a := app.New()
  w := a.NewWindow("Hello")

  img1 := canvas.NewImageFromResource(theme.FyneLogo())
  img1.FillMode = canvas.ImageFillOriginal

  img2 := canvas.NewImageFromFile("./luffy.jpg")
  img2.FillMode = canvas.ImageFillOriginal

  image := image.NewAlpha(image.Rectangle{image.Point{0, 0}, image.Point{100, 100}})
  for i := 0; i < 100; i++ {
    for j := 0; j < 100; j++ {
      image.Set(i, j, color.Alpha{uint8(i % 256)})
    }
  }
  img3 := canvas.NewImageFromImage(image)
  img3.FillMode = canvas.ImageFillOriginal

  container := fyne.NewContainerWithLayout(
    layout.NewGridWrapLayout(fyne.NewSize(150, 150)),
    img1, img2, img3)
  w.SetContent(container)
  w.ShowAndRun()
}
复制代码

theme.FyneLogo()是 Fyne 图标资源，luffy.jpg是磁盘中的文件，最后建立一个image.Image，从中生成canvas.Image。

最后一种是梯度渐变效果，有两种类型canvas.LinearGradient（线性渐变）和canvas.RadialGradient（放射渐变），指从一种颜色渐变到另外一种颜色。线性渐变又分为两种水平线性渐变和垂直线性渐变，分别经过canvas.NewHorizontalGradient()和canvas.NewVerticalGradient()建立。放射渐变经过canvas.NewRadialGradient()建立。咱们在上面的示例中已经看到了水平线性渐变的效果，接下来一块儿看看放射渐变的效果：

func main() {
  a := app.New()
  w := a.NewWindow("Canvas")

  gradient := canvas.NewRadialGradient(color.White, color.Transparent)
  w.SetContent(gradient)
  w.Resize(fyne.NewSize(200, 200))
  w.ShowAndRun()
}
复制代码

运行效果以下：

放射效果就是从中心向周围渐变。

Widget

窗体控件是一个Fyne应用程序的主要组成部分。它们能适配当前的主题，而且处理与用户的交互。

Label

标签（Label）是最简单的一个控件了，用于显示字符串。它有点相似于canvas.Text，不一样之处在于Label能够处理简单的格式化，例如\n：

func main() {
  myApp := app.New()
  myWin := myApp.NewWindow("Label")

  l1 := widget.NewLabel("Name")
  l2 := widget.NewLabel("da\njun")

  container := fyne.NewContainerWithLayout(layout.NewVBoxLayout(), l1, l2)
  myWin.SetContent(container)
  myWin.Resize(fyne.NewSize(150, 150))
  myWin.ShowAndRun()
}
复制代码

第二个widget.Label中\n后面的内容会在下一行渲染：

Button

按钮（Button）控件让用户点击，给用户反馈。Button能够包含文本，图标或二者皆有。调用widget.NewButton()建立一个默认的文本按钮，传入文本和一个无参的回调函数。带图标的按钮须要调用widget.NewButtonWithIcon()，传入文本和回调参数，还须要一个fyne.Resource类型的图标资源：

func main() {
  myApp := app.New()
  myWin := myApp.NewWindow("Button")

  btn1 := widget.NewButton("text button", func() {
    fmt.Println("text button clicked")
  })

  btn2 := widget.NewButtonWithIcon("icon", theme.HomeIcon(), func() {
    fmt.Println("icon button clicked")
  })

  container := fyne.NewContainerWithLayout(layout.NewVBoxLayout(), btn1, btn2)
  myWin.SetContent(container)
  myWin.Resize(fyne.NewSize(150, 50))
  myWin.ShowAndRun()
}
复制代码

上面建立了一个文本按钮和一个图标按钮，theme子包中包含一些默认的图标资源，也能够加载外部的图标。运行：

点击按钮，对应的回调就会被调用，试试看！

Box

盒子控件（Box）就是一个简单的水平或垂直的容器。在内部，Box对子控件采用盒状布局（Box Layout），详见后文布局。咱们能够经过传入控件对象给widget.NewHBox()或widget.NewVBox()建立盒子。或者调用已经建立好的widget.Box对象的Append()或Prepend()向盒子中添加控件。前者在尾部追加，后者在头部添加。

func main() {
  myApp := app.New()
  myWin := myApp.NewWindow("Box")

  content := widget.NewVBox(
    widget.NewLabel("The top row of VBox"),
    widget.NewHBox(
      widget.NewLabel("Label 1"),
      widget.NewLabel("Label 2"),
    ),
  )
  content.Append(widget.NewButton("Append", func() {
    content.Append(widget.NewLabel("Appended"))
  }))
  content.Append(widget.NewButton("Prepend", func() {
    content.Prepend(widget.NewLabel("Prepended"))
  }))

  myWin.SetContent(content)
  myWin.Resize(fyne.NewSize(150, 150))
  myWin.ShowAndRun()
}
复制代码

咱们甚至能够嵌套widget.Box控件，这样就能够实现比较灵活的布局。上面的代码中添加了两个按钮，点击时分别在尾部和头部添加一个Label：

Entry

输入框（Entry）控件用于给用户输入简单的文本内容。调用widget.NewEntry()便可建立一个输入框控件。咱们通常保存输入框控件的引用，以便访问其Text字段来获取内容。注册OnChanged回调函数。每当内容有修改时，OnChanged就会被调用。咱们能够调用SetReadOnly(true)设置输入框的只读属性。方法SetPlaceHolder()用来设置占位字符串，设置字段Multiline让输入框接受多行文本。另外，咱们可使用NewPasswordEntry()建立一个密码输入框，输入的文本不会以明文显示。

func main() {
  myApp := app.New()
  myWin := myApp.NewWindow("Entry")

  nameEntry := widget.NewEntry()
  nameEntry.SetPlaceHolder("input name")
  nameEntry.OnChanged = func(content string) {
    fmt.Println("name:", nameEntry.Text, "entered")
  }

  passEntry := widget.NewPasswordEntry()
  passEntry.SetPlaceHolder("input password")

  nameBox := widget.NewHBox(widget.NewLabel("Name"), layout.NewSpacer(), nameEntry)
  passwordBox := widget.NewHBox(widget.NewLabel("Password"), layout.NewSpacer(), passEntry)

  loginBtn := widget.NewButton("Login", func() {
    fmt.Println("name:", nameEntry.Text, "password:", passEntry.Text, "login in")
  })

  multiEntry := widget.NewEntry()
  multiEntry.SetPlaceHolder("please enter\nyour description")
  multiEntry.MultiLine = true

  content := widget.NewVBox(nameBox, passwordBox, loginBtn, multiEntry)
  myWin.SetContent(content)
  myWin.ShowAndRun()
}
复制代码

这里咱们实现了一个简单的登陆界面：

Checkbox/Radio/Select

CheckBox是简单的选择框，每一个选择是独立的，例如爱好能够是足球、篮球，也能够都是。建立方法widget.NewCheck()，传入选项字符串（足球，篮球）和回调函数。回调函数接受一个bool类型的参数，表示该选项是否选中。

Radio是单选框，每一个组内只能选择一个，例如性别，只能是男或女（？）。建立方法widget.NewRadio()，传入字符串切片和回调函数做为参数。回调函数接受一个字符串参数，表示选中的选项。也可使用Selected字段读取选中的选项。

Select是下拉选择框，点击时显示一个下拉菜单，点击选择。选项很是多的时候，比较适合用Select。建立方法widget.NewSelect()，参数与NewRadio()彻底相同。

func main() {
  myApp := app.New()
  myWin := myApp.NewWindow("Choices")

  nameEntry := widget.NewEntry()
  nameEntry.SetPlaceHolder("input name")

  passEntry := widget.NewPasswordEntry()
  passEntry.SetPlaceHolder("input password")

  repeatPassEntry := widget.NewPasswordEntry()
  repeatPassEntry.SetPlaceHolder("repeat password")

  nameBox := widget.NewHBox(widget.NewLabel("Name"), layout.NewSpacer(), nameEntry)
  passwordBox := widget.NewHBox(widget.NewLabel("Password"), layout.NewSpacer(), passEntry)
  repeatPasswordBox := widget.NewHBox(widget.NewLabel("Repeat Password"), layout.NewSpacer(), repeatPassEntry)

  sexRadio := widget.NewRadio([]string{"male", "female", "unknown"}, func(value string) {
    fmt.Println("sex:", value)
  })
  sexBox := widget.NewHBox(widget.NewLabel("Sex"), sexRadio)

  football := widget.NewCheck("football", func(value bool) {
    fmt.Println("football:", value)
  })
  basketball := widget.NewCheck("basketball", func(value bool) {
    fmt.Println("basketball:", value)
  })
  pingpong := widget.NewCheck("pingpong", func(value bool) {
    fmt.Println("pingpong:", value)
  })
  hobbyBox := widget.NewHBox(widget.NewLabel("Hobby"), football, basketball, pingpong)

  provinceSelect := widget.NewSelect([]string{"anhui", "zhejiang", "shanghai"}, func(value string) {
    fmt.Println("province:", value)
  })
  provinceBox := widget.NewHBox(widget.NewLabel("Province"), layout.NewSpacer(), provinceSelect)

  registerBtn := widget.NewButton("Register", func() {
    fmt.Println("name:", nameEntry.Text, "password:", passEntry.Text, "register")
  })

  content := widget.NewVBox(nameBox, passwordBox, repeatPasswordBox,
    sexBox, hobbyBox, provinceBox, registerBtn)
  myWin.SetContent(content)
  myWin.ShowAndRun()
}
复制代码

这里咱们实现了一个简单的注册界面：

Form

表单控件（Form）用于对不少Label和输入控件进行布局。若是指定了OnSubmit或OnCancel函数，表单控件会自动添加对应的Button按钮。咱们调用widget.NewForm()传入一个widget.FormItem切片建立Form控件。每一项中一个字符串做为Label的文本，一个控件对象。建立好Form对象以后还能调用其Append(label, widget)方法添加控件。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Form")

  nameEntry := widget.NewEntry()
  passEntry := widget.NewPasswordEntry()

  form := widget.NewForm(
    &widget.FormItem{"Name", nameEntry},
    &widget.FormItem{"Pass", passEntry},
  )
  form.OnSubmit = func() {
    fmt.Println("name:", nameEntry.Text, "pass:", passEntry.Text, "login in")
  }
  form.OnCancel = func() {
    fmt.Println("login canceled")
  }

  myWindow.SetContent(form)
  myWindow.Resize(fyne.NewSize(150, 150))
  myWindow.ShowAndRun()
}
复制代码

使用Form能大大简化表单的构建，咱们使用Form从新编写了上面的登陆界面：

注意Submit和Cancel按钮是自动生成的！

ProgressBar

进度条控件（ProgressBar）用来表示任务的进度，例如文件下载的进度。建立方法widget.NewProgressBar()，默认最小值为0.0，最大值为1.1，可经过Min/Max字段设置。调用SetValue()方法来控制进度。还有一种进度条是循环动画，它表示有任务在进行中，并不能表示具体的完成状况。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("ProgressBar")

  bar1 := widget.NewProgressBar()
  bar1.Min = 0
  bar1.Max = 100
  bar2 := widget.NewProgressBarInfinite()

  go func() {
    for i := 0; i <= 100; i ++ {
      time.Sleep(time.Millisecond * 500)
      bar1.SetValue(float64(i))
    }
  }()

  content := widget.NewVBox(bar1, bar2)
  myWindow.SetContent(content)
  myWindow.Resize(fyne.NewSize(150, 150))
  myWindow.ShowAndRun()
}
复制代码

在另外一个 goroutine 中更新进度。效果以下：

TabContainer

标签容器（TabContainer）容许用户在不一样的内容面板之间切换。标签能够是文本或图标。建立方法widget.NewTabContainer()，传入widget.TabItem做为参数。widget.TabItem可经过widget.NewTabItem(label, widget)建立。标签还能够设置位置：

  • TabLocationBottom：显示在底部；
  • TabLocationLeading：显示在顶部左边；
  • TabLocationTrailing：显示在顶部右边。

看示例：

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("TabContainer")

  nameLabel := widget.NewLabel("Name: dajun")
  sexLabel := widget.NewLabel("Sex: male")
  ageLabel := widget.NewLabel("Age: 18")
  addressLabel := widget.NewLabel("Province: shanghai")
  addressLabel.Hide()
  profile := widget.NewVBox(nameLabel, sexLabel, ageLabel, addressLabel)

  musicRadio := widget.NewRadio([]string{"on", "off"}, func(string) {})
  showAddressCheck := widget.NewCheck("show address?", func(value bool) {
    if !value {
      addressLabel.Hide()
    } else {
      addressLabel.Show()
    }
  })
  memberTypeSelect := widget.NewSelect([]string{"junior", "senior", "admin"}, func(string) {})

  setting := widget.NewForm(
    &widget.FormItem{"music", musicRadio},
    &widget.FormItem{"check", showAddressCheck},
    &widget.FormItem{"member type", memberTypeSelect},
  )

  tabs := widget.NewTabContainer(
    widget.NewTabItem("Profile", profile),
    widget.NewTabItem("Setting", setting),
  )

  myWindow.SetContent(tabs)
  myWindow.Resize(fyne.NewSize(200, 200))
  myWindow.ShowAndRun()
}
复制代码

上面代码编写了一个简单的我的信息面板和设置面板，点击show address？可切换地址信息是否显示：

Toolbar

工具栏（Toolbar）是不少 GUI 应用程序必备的部分。工具栏将经常使用命令用图标的方式很形象地展现出来，方便使用。建立方法widget.NewToolbar()，传入多个widget.ToolbarItem做为参数。最常使用的ToolbarItem有命令（Action）、分隔符（Separator）和空白（Spacer），分别经过widget.NewToolbarItemAction(resource, callback)/widget.NewToolbarSeparator()/widget.NewToolbarSpacer()建立。命令须要指定回调，点击时触发。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Toolbar")

  toolbar := widget.NewToolbar(
    widget.NewToolbarAction(theme.DocumentCreateIcon(), func() {
      fmt.Println("New document")
    }),
    widget.NewToolbarSeparator(),
    widget.NewToolbarAction(theme.ContentCutIcon(), func() {
      fmt.Println("Cut")
    }),
    widget.NewToolbarAction(theme.ContentCopyIcon(), func() {
      fmt.Println("Copy")
    }),
    widget.NewToolbarAction(theme.ContentPasteIcon(), func() {
      fmt.Println("Paste")
    }),
    widget.NewToolbarSpacer(),
    widget.NewToolbarAction(theme.HelpIcon(), func() {
      log.Println("Display help")
    }),
  )

  content := fyne.NewContainerWithLayout(
    layout.NewBorderLayout(toolbar, nil, nil, nil),
    toolbar, widget.NewLabel(`Lorem ipsum dolor, sit amet consectetur adipisicing elit. Quidem consectetur ipsam nesciunt, quasi sint expedita minus aut, porro iusto magnam ducimus voluptates cum vitae. Vero adipisci earum iure consequatur quidem.`),
  )
  myWindow.SetContent(content)
  myWindow.ShowAndRun()
}
复制代码

工具栏通常使用BorderLayout，将工具栏放在其余任何控件上面，布局后文会详述。运行：

扩展控件

标准的 Fyne 控件提供了最小的功能集和定制化以适应大部分的应用场景。有些时候，咱们须要更高级的功能。除了本身编写控件外，咱们还能够扩展示有的控件。例如，咱们但愿图标控件widget.Icon能响应鼠标左键、右键和双击。首先编写一个构造函数，调用ExtendBaseWidget()方法得到基础的控件功能：

type tappableIcon struct {
  widget.Icon
}

func newTappableIcon(res fyne.Resource) *tappableIcon {
  icon := &tappableIcon{}
  icon.ExtendBaseWidget(icon)
  icon.SetResource(res)

  return icon
}
复制代码

而后实现相关的接口：

// src/fyne.io/fyne/canvasobject.go
// 鼠标左键
type Tappable interface {
  Tapped(*PointEvent)
}

// 鼠标右键或长按
type SecondaryTappable interface {
  TappedSecondary(*PointEvent)
}

// 双击
type DoubleTappable interface {
  DoubleTapped(*PointEvent)
}
复制代码

接口实现：

func (t *tappableIcon) Tapped(e *fyne.PointEvent) {
  log.Println("I have been left tapped at", e)
}

func (t *tappableIcon) TappedSecondary(e *fyne.PointEvent) {
  log.Println("I have been right tapped at", e)
}

func (t *tappableIcon) DoubleTapped(e *fyne.PointEvent) {
  log.Println("I have been double tapped at", e)
}
复制代码

最后使用：

func main() {
  a := app.New()
  w := a.NewWindow("Tappable")
  w.SetContent(newTappableIcon(theme.FyneLogo()))
  w.Resize(fyne.NewSize(200, 200))
  w.ShowAndRun()
}
复制代码

运行，点击图标控制台有相应输出：

2020/06/18 06:44:02 I have been left tapped at &{{110 97} {106 93}}
2020/06/18 06:44:03 I have been left tapped at &{{110 97} {106 93}}
2020/06/18 06:44:05 I have been right tapped at &{{88 102} {84 98}}
2020/06/18 06:44:06 I have been right tapped at &{{88 102} {84 98}}
2020/06/18 06:44:06 I have been left tapped at &{{88 101} {84 97}}
2020/06/18 06:44:07 I have been double tapped at &{{88 101} {84 97}}
复制代码

输出的fyne.PointEvent中有绝对位置（对于窗口左上角）和相对位置（对于容器左上角）。

Layout

布局（Layout）就是控件如何在界面上显示，如何排列的。要想界面好看，布局是必需要掌握的。几乎全部的 GUI 框架都提供了布局或相似的接口。实际上，在前面的示例中咱们已经在fyne.NewContainerWithLayout()函数中使用了布局。

BoxLayout

盒状布局（BoxLayout）是最常使用的一个布局。它将控件都排在一行或一列。在fyne中，咱们能够经过layout.NewHBoxLayout()建立一个水平盒装布局，经过layout.NewVBoxLayout()建立一个垂直盒装布局。水平布局中的控件都排列在一行中，每一个控件的宽度等于其内容的最小宽度（MinSize().Width），它们都拥有相同的高度，即全部控件的最大高度（MinSize().Height）。

垂直布局中的控件都排列在一列中，每一个控件的高度等于其内容的最小高度，它们都拥有相同的宽度，即全部控件的最大宽度。

通常地，在BoxLayout中使用layout.NewSpacer()辅助布局，它会占满剩余的空间。对于水平盒状布局来讲，第一个控件前添加一个layout.NewSpacer()，全部控件右对齐。最后一个控件后添加一个layout.NewSpacer()，全部控件左对齐。先后都有，那么控件中间对齐。若是在中间有添加一个layout.NewSpacer()，那么其它控件两边对齐。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Box Layout")

  hcontainer1 := fyne.NewContainerWithLayout(layout.NewHBoxLayout(),
    canvas.NewText("left", color.White),
    canvas.NewText("right", color.White))

  // 左对齐
  hcontainer2 := fyne.NewContainerWithLayout(layout.NewHBoxLayout(),
    layout.NewSpacer(),
    canvas.NewText("left", color.White),
    canvas.NewText("right", color.White))

  // 右对齐
  hcontainer3 := fyne.NewContainerWithLayout(layout.NewHBoxLayout(),
    canvas.NewText("left", color.White),
    canvas.NewText("right", color.White),
    layout.NewSpacer())

  // 中间对齐
  hcontainer4 := fyne.NewContainerWithLayout(layout.NewHBoxLayout(),
    layout.NewSpacer(),
    canvas.NewText("left", color.White),
    canvas.NewText("right", color.White),
    layout.NewSpacer())

  // 两边对齐
  hcontainer5 := fyne.NewContainerWithLayout(layout.NewHBoxLayout(),
    canvas.NewText("left", color.White),
    layout.NewSpacer(),
    canvas.NewText("right", color.White))

  myWindow.SetContent(fyne.NewContainerWithLayout(layout.NewVBoxLayout(),
    hcontainer1, hcontainer2, hcontainer3, hcontainer4, hcontainer5))
  myWindow.Resize(fyne.NewSize(200, 200))
  myWindow.ShowAndRun()
}
复制代码

运行效果：

GridLayout

格子布局（GridLayout）每一行有固定的列，添加的控件数量超过这个值时，后面的控件将会在新的行显示。建立方法layout.NewGridLayout(cols)，传入每行的列数。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Grid Layout")

  img1 := canvas.NewImageFromResource(theme.FyneLogo())
  img2 := canvas.NewImageFromResource(theme.FyneLogo())
  img3 := canvas.NewImageFromResource(theme.FyneLogo())
  myWindow.SetContent(fyne.NewContainerWithLayout(layout.NewGridLayout(2),
    img1, img2, img3))
  myWindow.Resize(fyne.NewSize(300, 300))
  myWindow.ShowAndRun()
}
复制代码

运行效果：

该布局有个优点，咱们缩放界面时，控件会自动调整大小。试试看~

GridWrapLayout

GridWrapLayout是GridLayout的扩展。GridWrapLayout建立时会指定一个初始size，这个size会应用到全部的子控件上，每一个子控件都保持这个size。初始，每行一个控件。若是界面大小变化了，这些子控件会从新排列。例如宽度翻倍了，那么一行就能够排两个控件了。有点像流动布局：

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Grid Wrap Layout")

  img1 := canvas.NewImageFromResource(theme.FyneLogo())
  img2 := canvas.NewImageFromResource(theme.FyneLogo())
  img3 := canvas.NewImageFromResource(theme.FyneLogo())
  myWindow.SetContent(
    fyne.NewContainerWithLayout(
      layout.NewGridWrapLayout(fyne.NewSize(150, 150)),
      img1, img2, img3))
  myWindow.ShowAndRun()
}
复制代码

初始：

加大宽度：

再加大宽度：

BorderLayout

边框布局（BorderLayout）比较经常使用于构建用户界面，上面例子中的Toolbar通常都和BorderLayout搭配使用。建立方法layout.NewBorderLayout(top, bottom, left, right)，分别传入顶部、底部、左侧、右侧的控件对象。添加到容器中的控件若是是这些边界对象，则显示在对应位置，其余都显示在中心：

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Border Layout")

  left := canvas.NewText("left", color.White)
  right := canvas.NewText("right", color.White)
  top := canvas.NewText("top", color.White)
  bottom := canvas.NewText("bottom", color.White)
  content := widget.NewLabel(`Lorem ipsum dolor, sit amet consectetur adipisicing elit. Quidem consectetur ipsam nesciunt, quasi sint expedita minus aut, porro iusto magnam ducimus voluptates cum vitae. Vero adipisci earum iure consequatur quidem.`)

  container := fyne.NewContainerWithLayout(
    layout.NewBorderLayout(top, bottom, left, right),
    top, bottom, left, right, content,
  )
  myWindow.SetContent(container)
  myWindow.ShowAndRun()
}
复制代码

效果：

FormLayout

表单布局（FormLayout）其实就是一个 2 列的GridLayout，可是针对表单作了一些微调。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Border Layout")

  nameLabel := canvas.NewText("Name", color.Black)
  nameValue := canvas.NewText("dajun", color.White)
  ageLabel := canvas.NewText("Age", color.Black)
  ageValue := canvas.NewText("18", color.White)

  container := fyne.NewContainerWithLayout(
    layout.NewFormLayout(),
    nameLabel, nameValue, ageLabel, ageValue,
  )
  myWindow.SetContent(container)
  myWindow.Resize(fyne.NewSize(150, 150))
  myWindow.ShowAndRun()
}
复制代码

运行效果：

CenterLayout

CenterLayout将容器内的全部控件显示在中心位置，按传入的顺序显示。最后传入的控件显示最上层。CenterLayout中全部控件将保持它们的最小尺寸（大小能容纳其内容）。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Center Layout")

  image := canvas.NewImageFromResource(theme.FyneLogo())
  image.FillMode = canvas.ImageFillOriginal
  text := canvas.NewText("Fyne Logo", color.Black)

  container := fyne.NewContainerWithLayout(
    layout.NewCenterLayout(),
    image, text,
  )
  myWindow.SetContent(container)
  myWindow.ShowAndRun()
}
复制代码

运行结果：

字符串Fyne Logo显示在图片上层。若是咱们把text和image顺序对调，字符串将会被图片挡住，没法看到。动手试一下~

MaxLayout

MaxLayout与CenterLayout相似，不一样之处在于MaxLayout会让容器内的元素都显示为最大尺寸（等于容器的大小）。细心的朋友可能发现了，在CenterLayout的示例中。咱们设置了图片的填充模式为ImageFillOriginal。若是不设置填充模式，图片的默认MinSize为(1, 1)。能够fmt.Println(image.MinSize())验证一下。这样图片就不会显示在界面中。

在MaxLayout的容器中，咱们不须要这样处理：

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Max Layout")

  image := canvas.NewImageFromResource(theme.FyneLogo())
  text := canvas.NewText("Fyne Logo", color.Black)

  container := fyne.NewContainerWithLayout(
    layout.NewMaxLayout(),
    image, text,
  )
  myWindow.SetContent(container)
  myWindow.Resize(fyne.Size(200, 200))
  myWindow.ShowAndRun()
}
复制代码

运行结果：

注意，canvas.Text显示为左对齐了。若是要居中对齐，设置其Alignment属性为fyne.TextAlignCenter。

自定义 Layout

内置布局在子包layout中。它们都实现了fyne.Layout接口：

// src/fyne.io/fyne/layout.go
type Layout interface {
  Layout([]CanvasObject, Size)
  MinSize(objects []CanvasObject) Size
}
复制代码

要实现自定义的布局，只须要实现这个接口。下面咱们实现一个台阶（对角）的布局，好似一个矩阵的对角线，从左上到右下。首先定义一个新的类型。而后实现接口fyne.Layout的两个方法：

type diagonal struct {
}

func (d *diagonal) MinSize(objects []fyne.CanvasObject) fyne.Size {
  w, h := 0, 0
  for _, o := range objects {
    childSize := o.MinSize()

    w += childSize.Width
    h += childSize.Height
  }

  return fyne.NewSize(w, h)
}

func (d *diagonal) Layout(objects []fyne.CanvasObject, containerSize fyne.Size) {
  pos := fyne.NewPos(0, 0)
  for _, o := range objects {
    size := o.MinSize()
    o.Resize(size)
    o.Move(pos)

    pos = pos.Add(fyne.NewPos(size.Width, size.Height))
  }
}
复制代码

MinSize()返回全部子控件的MinSize之和。Layout()从左上到右下排列控件。而后是使用：

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Diagonal Layout")

  img1 := canvas.NewImageFromResource(theme.FyneLogo())
  img1.FillMode = canvas.ImageFillOriginal
  img2 := canvas.NewImageFromResource(theme.FyneLogo())
  img2.FillMode = canvas.ImageFillOriginal
  img3 := canvas.NewImageFromResource(theme.FyneLogo())
  img3.FillMode = canvas.ImageFillOriginal

  container := fyne.NewContainerWithLayout(
    &diagonal{},
    img1, img2, img3,
  )
  myWindow.SetContent(container)
  myWindow.ShowAndRun()
}
复制代码

运行结果：

fyne demo

fyne提供了一个 Demo，演示了大部分控件和布局的使用。可以使用下面命令安装，执行：

$ go get fyne.io/fyne/cmd/fyne_demo
$ fyne_demo
复制代码

效果图：

fyne命令

fyne库为了方便开发者提供了fyne命令。fyne能够用来将静态资源打包进可执行程序，还能将整个应用程序打包成可发布的形式。fyne命令经过下面命令安装：

$ go get fyne.io/fyne/cmd/fyne
复制代码

安装完成以后fyne就在$GOPATH/bin目录中，将$GOPATH/bin添加到系统$PATH中就能够直接运行fyne命令了。

静态资源

其实在前面的示例中咱们已经屡次使用了fyne内置的静态资源，使用最多的要属fyne.FyneLogo()了。下面咱们有两个图片image1.png/image2.jpg。咱们使用fyne bundle命令将这两个图片打包进代码：

$ fyne bundle image1.png >> bundled.go
$ fyne bundle -append image2.jpg >> bundled.go
复制代码

第二个命令指定-append选项表示添加到现有文件中，生成的文件以下：

// bundled.go
package main

import "fyne.io/fyne"

var resourceImage1Png = &fyne.StaticResource{
  StaticName: "image1.png",
  StaticContent: []byte{...}}

var resourceImage2Jpg = &fyne.StaticResource{
  StaticName: "image2.jpg",
  StaticContent: []byte{...}}
复制代码

实际上就是将图片内容存入一个字节切片中，咱们在代码中就能够调用canvas.NewImageFromResource()，传入resourceImage1Png或resourceImage2Jpg来建立canvas.Image对象了。

func main() {
  myApp := app.New()
  myWindow := myApp.NewWindow("Bundle Resource")

  img1 := canvas.NewImageFromResource(resourceImage1Png)
  img1.FillMode = canvas.ImageFillOriginal
  img2 := canvas.NewImageFromResource(resourceImage2Jpg)
  img2.FillMode = canvas.ImageFillOriginal
  img3 := canvas.NewImageFromResource(theme.FyneLogo())
  img3.FillMode = canvas.ImageFillOriginal

  container := fyne.NewContainerWithLayout(
    layout.NewGridLayout(1),
    img1, img2, img3,
  )
  myWindow.SetContent(container)
  myWindow.ShowAndRun()
}
复制代码

运行结果：

注意，因为如今是两个文件，不能使用go run main.go，应该用go run .。

theme.FyneLogo()其实是也是提早打包进代码的，代码文件是bundled-icons.go：

// src/fyne.io/fyne/theme/icons.go
func FyneLogo() fyne.Resource {
  return fynelogo
}

// src/fyne.io/fyne/theme/bundled-icons.go
var fynelogo = &fyne.StaticResource{
  StaticName: "fyne.png",
  StaticContent: []byte{}}
复制代码

发布应用程序

发布图像应用程序到多个操做系统是很是复杂的任务。图形界面应用程序一般有图标和一些元数据。fyne命令提供了将应用程序发布到多个平台的支持。使用fyne package命令将建立一个可在其它计算机上安装/运行的应用程序。在 Windows 上，fyne package会建立一个.exe文件。在 macOS 上，会建立一个.app文件。在 Linux 上，会生成一个.tar.xz文件，可手动安装。

咱们将上面的应用程序打包成一个exe文件：

$ fyne package -os windows -icon icon.jpg
复制代码

上面命令会在同目录下生成两个文件bundle.exe和fyne.syso，将这两个文件拷贝到任何目录或其余 Windows 计算机均可以经过直接双击bundle.exe运行了。没有其余的依赖。

fyne还支持交叉编译，能在 windows 上编译 mac 的应用程序，不过须要安装额外的工具，感兴趣可自行探索。

总结

fyne提供了丰富的组件和功能，咱们介绍的只是很基础的一部分，还有剪切板、快捷键、滚动条、菜单等等等等内容。fyne命令实现打包静态资源和应用程序，很是方便。fyne还有其余高级功能留待你们探索、挖掘~

你们若是发现好玩、好用的 Go 语言库，欢迎到 Go 每日一库 GitHub 上提交 issue😄

参考

  1. fyne GitHub：github.com/fyne-io/fyn…
  2. fyne 官网：fyne.io/
  3. fyne 官方入门教程：developer.fyne.io/tour/introd…
  4. Go 每日一库 GitHub：github.com/darjun/go-d…

我

个人博客：darjun.github.io

欢迎关注个人微信公众号【GoUpUp】，共同窗习，一块儿进步~

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程