# Puregotk

> **_NOTE:_**  This library is currently expiremental and needs thorough testing. Some APIs might be incorrectly exposed

Autogenerated GTK4+Adwaita bindings for Go leveraging [purego](https://github.com/ebitengine/purego)

# Motivation
I created this library because I found that alternative libraries using Cgo had much too slow compilation speed. For my laptop around 15 minutes to build a simple example (*without build cache*) for [gotk3](https://github.com/gotk3/gotk3) and also [gotk4](https://github.com/diamondburned/gotk4). Whilst this is maybe not a big problem for development, I found it annoying for CI and package building where you would not want to rely on a cache. Additionally, having [Cgo](https://pkg.go.dev/cmd/cgo) involved means harder cross compilation.

This is not a fault for these libraries as CGo compilation is just inherently slow in Go. In this project I want to test a new approach by levering purego which allows you to load libraries using dlopen without needing cgo.

Compilation speed currently is around 40 seconds for me on basic examples.

## Advantages

No Cgo needed, thus:
* Easy cross compilation
* No C toolchain needed
* Much faster compile times than alternatives like [gotk3](https://github.com/gotk3/gotk3) & [gotk4](https://github.com/diamondburned/gotk4)
  
## Disadvantages

Limitations of this library as compared to the alternatives using cgo:
* Some APIs are not possible due to purego not currently supporting struct arguments (that are not pointers)

# Planned features
In order of priority:
* General code cleanup
* Support for OS other than Linux (I only test on Linux currently)
* GTK 3 support
* Architectures other than AMD64/ARM64

# Basic example

```go
package main

import (
	"os"

	"github.com/jwijenbergh/puregotk/v4/gio"
	"github.com/jwijenbergh/puregotk/v4/gtk"
)

func main() {
	app := gtk.NewApplication("com.github.jwijenbergh.puregotk.gtk4.hello", gio.GApplicationFlagsNoneValue)
	// cleanup, no finalizers are used in this library
	defer app.Unref()
	// functions with callback arguments take function pointers
	// this is for internal re-use of callbacks
	actcb := func(_ gio.Application) {
		activate(app)
	}
	app.ConnectActivate(&actcb)

	if code := app.Run(len(os.Args), os.Args); code > 0 {
		os.Exit(code)
	}
}

func activate(app *gtk.Application) {
	window := gtk.NewApplicationWindow(app)
	window.SetTitle("purego")
	label := gtk.NewLabel("Hello, World!")
	window.SetChild(&label.Widget)
	// cleanup, no finalizers are used in this library
	label.Unref()
	window.SetDefaultSize(500, 500)
	window.Present()
}
```

Save this to a main.go and then build & run with

```bash
go run main.go
```

> **_NOTE:_**  You can also use `CGO_ENABLED=0` to build without cgo!

# Library loading
Because the GTK libs are loading at runtime (in `init`), we have to know where your libs are located.
The default configuration is a "just works" configuration, we hardcode some paths that are common. 

However, for systems such as NixOS or distros that use other paths the following environment variables might help:

- `PUREGOTK_LIB_FOLDER`, set this to the root folder where all libs are stored e.g. `/some/path/`
- `PUREGOTK_LIBNAME_PATH` where `LIBNAME` is the name of the library, e.g. `PUREGOTK_GTK_PATH` for the file path to GTK e.g. `/some/path/libgtk-4.so`. You have to do this for all deps, e.g. cairo, pango, etc

See https://github.com/jwijenbergh/puregotk/blob/main/internal/core/core.go for exact implementation details.

Additionally we also have a fallback to `pkg-config`, but I would say only rely on this as a last effort due to the increased startup time.
When packaging code, always make sure that correct paths are used by e.g. using the aforementioned environment variables.

# Generating the library
This library is automatically generated by reading GIR files.

To generate the library, run:

```bash
./gen.sh
```

In the root of the project. This needs:

- Go >= 1.20
- [goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports)

# License

[MIT](./LICENSE)

# Acknowledgements
* [Purego](https://github.com/ebitengine/purego) and the ebitengine team for their great work
* [gotk4](https://github.com/diamondburned/gotk4) for some GIR type definitions
* [gtk](https://gitlab.gnome.org/gnome/gtk) of course