Building cross-platform GUI applications with Fyne : create beautiful, platform-agnostic graphical applications using Fyne and the Go programming language / Andrew Williams.

Format:

Book

Author/Creator:

Williams, Andrew, author.

Language:

English

Subjects (All):

Graphical user interfaces (Computer systems).

Physical Description:

1 online resource (318 pages)

Edition:

1st ed.

Place of Publication:

Birmingham, England ; Mumbai : Packt, [2021]

Summary:

The Fyne GUI toolkit solves many of the challenges relating to traditional technologies and older programming languages. This book introduces the key APIs and techniques behind Fyne applications that make them easy to build. From the basics through to building five completed applications, you'll get up to speed with every stage of app development.

Contents:

Cover

Title Page

Copyright and Credits

Dedication

Contributors

Table of Contents

Preface

Section 1: Why Fyne? The Reason for Being and a Vision of the Future

Chapter 1: A Brief History of GUI Toolkits and Cross-Platform Development

Understanding the history of the graphical user interface

Popularity of the desktop computer

Moving to the web

Smartphones and mobile apps

Exploring the evolution of GUI toolkits

Platform-specific toolkits

Cross-platform toolkits

Hybrid apps

Comparing native graphical apps to web UIs

Development speed versus delivery

Visual style

Technical constraints

Options for cross-platform native toolkits

Compiled versus interpreted

Interpreted options

Compiled options (C-based)

Compiled options (other languages)

Summary

Chapter 2: The Future According to Fyne

Technical requirements

Starting with a clean slate

Designing for modern devices

Parallelism and web services

Building for any device

Best practices have moved on

How Go is a great fit for this challenge

Simple cross-platform code

Standard library

Concurrency

Web services

High level with system access

Looking good with Material Design

Color palette

Standard icons

Designing APIs for simplicity and maintainability

Semantic API

Modular

Testable

Extensible

A vision of the future

Beautiful apps

Simple to learn

Platform-agnostic

Distribution to all platforms

Further reading

Section 2: Components of a Fyne App

Chapter 3: Window, Canvas, and Drawing

Anatomy of a Fyne application

Application

Window

Canvas

Container

Understanding CanvasObject and the canvas package

Canvas demo

Adding objects to our window

Combining elements.

Scalable drawing primitives

Coordinate system

Pixel output - rendering images

Images

Raster

Gradient

Animating a transition

Looping animations

Implementing a simple game

Adding a timer to move the snake

Using keys to control direction

Animating the movement

Chapter 4: Layout and File Handling

Laying out containers

Manual layout

Using a layout manager

Hidden objects

Standard layouts

MaxLayout

CenterLayout

PaddedLayout

BoxLayout

FormLayout

GridLayout

GridWrapLayout

BorderLayout

Combining layouts

Using the container package

Cross-platform file handling

URI

Reading and writing

User file selection

ListableURI

Implementing an image browser application

Creating the layout

Listing a directory

Loading the images

Loading the app faster

Creating a custom layout for the image elements

Changing a directory

Chapter 5: Widget Library and Themes

Exploring the design of the Widget API

Focus on behavior

Rendering a widget

Card

Check

Entry

FileIcon

Form

Hyperlink

Icon

Label

Pop-up menu

ProgressBar

RadioGroup

Select

SelectEntry

Slider

TextGrid

Toolbar

Grouping with the collection widgets

List

Table

Tree

Adding structure with container widgets

AppTabs

Scroll

Split

Using common dialogs

ColorPicker

Confirmation

File selection

Information

Custom dialogs

Understanding themes

Built-in themes

User settings

Included icons

Application override

Implementing a task list application

Designing the GUI

Defining the data

Selecting tasks

Filling in the details

Chapter 6: Data Binding and Storage

Binding data to widgets.

Understanding data binding

Supported data types

Creating, reading, and writing bound data

Listening for changes

Using data with standard widgets

Adapting data types for display

Formatting types into strings

Parsing values from the string type

Propagating changes through conversions

Binding complex data types

Using lists of data

Using data maps

Mapping structs to a data binding

Storing data using the Preferences API

Get and set values

Supported types

Fallback values

Removing old data

Binding to preferences

Implementing a water consumption tracker

Constructing the user interface

Binding data to the UI

Storing with preferences

Chapter 7: Building Custom Widgets and Themes

Extending existing widgets

Overriding widget functions

Adding new behavior

Creating a component from scratch

Implementing the theme interface

Providing customizations to the standard theme

Implementing a chat app user interface

Creating a message widget

Section 3: Packaging and Distribution

Chapter 8: Project Structure and Best Practices

Organizing your project

Starting simple

Adding new types

Splitting code into packages

Test driving your development

Designed to be tested

Testing our GUI logic

Verifying that the output is being rendered

Continuous integration for GUIs

Managing platform-specific code

Chapter 9: Bundling Resources and Preparing for Release

Bundling assets

Including multiple assets

Automating bundle commands

Checking for UI hints

Choosing metadata, icons, and app IDs

Application icons

Describing your app

Application identifier (appID)

Packaging applications (desktop and mobile).

Packaging for your current computer

Packaging for a mobile device

Installing your application

Installing on your current computer

Installing on a mobile device

Cross-compiling with ease

Using installed toolchains

Using the fyne-cross tool

Chapter 10: Distribution - App Stores and Beyond

Building your application for release

Running the release command

Sharing your app on the web

Distributing apps to desktop app stores

Mac App Store

Microsoft Store

Linux and BSD distributions

Uploading apps to Google Play and the iOS App Store

iOS App Store

Google Play Store

Appendix A: Developer Tool Installation

Installing on Apple macOS

Installing on Microsoft Windows

Appendix B: Installing Mobile Build Tools

Preparing for Android

Preparing for iOS and iPadOS

Appendix C: Cross-Compiling

Manually installing compilers

Cross compiling for macOS

Cross compiling for Windows

Cross compiling for Linux

Using fyne-cross

Installing fyne-cross

About PACKT

Other Books You May Enjoy

Index.

Notes:

Description based on print version record.

Description based on publisher supplied metadata and other sources.

ISBN:

9781800566880

1800566883

OCLC:

1235970737