windigo

Windigo provides full support for Component Object Model (COM) objects.

Lifetime Management: Because COM objects require manual reference counting, Windigo uses a win.OleReleaser object to manage their lifetimes. A win.OleReleaser acts like an arena allocator: you pass it to functions that produce COM objects, and calling releaser.Release() will call Release on all associated COM objects at once. This ensures proper cleanup and prevents memory leaks.

Initialization: Before using COM, you must initialize the COM library using win.CoInitializeEx (typically with co.COINIT_APARTMENTTHREADED) and ensure you call win.CoUninitialize when finished.

Example: Using a COM File Open Dialog:

package main

import (
	"github.com/rodrigocfd/windigo/co"
	"github.com/rodrigocfd/windigo/win"
)

func main() {
	runtime.LockOSThread()

	_, _ = win.CoInitializeEx(
		co.COINIT_APARTMENTTHREADED | co.COINIT_DISABLE_OLE1DDE)
	defer win.CoUninitialize()

	releaser := win.NewOleReleaser()
	defer releaser.Release()

	var fod *win.IFileOpenDialog
	_ = win.CoCreateInstance(
		releaser,
		&co.CLSID_FileOpenDialog,
		nil,
		co.CLSCTX_INPROC_SERVER,
		&fod,
	)

	defOpts, _ := fod.GetOptions()
	_ = fod.SetOptions(defOpts |
		co.FOS_FORCEFILESYSTEM |
		co.FOS_FILEMUSTEXIST,
	)

	_ = fod.SetFileTypes([]win.COMDLG_FILTERSPEC{
		{Name: "Text files", Spec: "*.txt"},
		{Name: "All files", Spec: "*.*"},
	})
	_ = fod.SetFileTypeIndex(1)

	if ok, _ := fod.Show(win.HWND(0)); ok {
		item, _ := fod.GetResult(releaser)
		fileName, _ := item.GetDisplayName(co.SIGDN_FILESYSPATH)
		println(fileName)
	}
}

Windigo supports COM Automation through bindings to the IDispatch interface and VARIANT parameters. This allows you to invoke methods on COM objects dynamically using InvokeMethod or InvokeGetAsIDispatch.

When using automation, you still use win.OleReleaser to manage the lifetime of the objects returned by these calls. This is useful for controlling external applications like Microsoft Excel.

package main

import (
	"github.com/rodrigocfd/windigo/co"
	"github.com/rodrigocfd/windigo/win"
)

func main() {
	_, _ = win.CoInitializeEx(
		co.COINIT_APARTMENTTHREADED | co.COINIT_DISABLE_OLE1DDE)
	defer win.CoUninitialize()

	rel := win.NewOleReleaser()
	defer rel.Release()

	clsId, _ := win.CLSIDFromProgID("Excel.Application")

	var excel *win.IDispatch
	_ = win.CoCreateInstance(
		rel,
		&clsId,
		nil,
		co.CLSCTX_LOCAL_SERVER,
		&excel,
	)

	books, _ := excel.InvokeGetAsIDispatch(rel, "Workbooks")
	file, _ := books.InvokeMethodAsIDispatch(rel, "Open", "C:\\Temp\\foo.xlsx")
	_, _ = file.InvokeMethod(rel, "SaveAs", "C:\\Temp\\foo copy.xlsx")
	_, _ = file.InvokeMethod(rel, "Close")
}

Windigo provides a high-level ui package for creating Windows GUI applications.

Important Requirements:

• You must call runtime.LockOSThread() at the start of your main function because the Windows GUI is single-threaded.
• To compile a final .exe without a console window appearing, use the following build command:

go build -trimpath -ldflags "-s -w -H=windowsgui"

Example of creating a main window with child controls (Static text, Edit field, and Button) and handling a button click event:

package main

import (
	"fmt"
	"runtime"

	"github.com/rodrigocfd/windigo/co"
	"github.com/rodrigocfd/windigo/ui"
)

func main() {
	runtime.LockOSThread() // important: Windows GUI is single-threaded

	ShowMainWindow()
}

type MyWindow struct {
	wnd     *ui.Main
	blName *ui.Static
	xtName *ui.Edit
	btnShow *ui.Button
}

func ShowMainWindow() int {
	wnd := ui.NewMain(
		ui.OptsMain().
			Title("Hello you").
			Center(true).
			Size(ui.Dpi(340, 80)).
			ClassIconId(101),
	)

	blName := ui.NewStatic(
		wnd,
		ui.OptsStatic().
			Text("Your name").
			Position(ui.Dpi(10, 22)),
	)
	xtName := ui.NewEdit(
		wnd,
		ui.OptsEdit().
			Position(ui.Dpi(80, 20)).
			Width(ui.DpiX(150)),
	)
	btnShow := ui.NewButton(
		wnd,
		ui.OptsButton().
			Text("&Show").
			Position(ui.Dpi(240, 19)),
	)

	me := &MyWindow{wnd, lblName, txtName, btnShow}
	me.events()
	return wnd.RunAsMain()
}

func (me *MyWindow) events() {
	me.btnShow.On().BnClicked(func() {
		msg := fmt.Sprintf("Hello, %s!", me.txtName.Text())
		me.wnd.Hwnd().MessageBox(msg, "Saying hello", co.MB_ICONINFORMATION)
	})
}

Use the win package to interact with the Windows Registry. You can open keys using RegOpenKeyEx, query values with RegQueryValueEx, and enumerate values with RegEnumValue.

When querying values, you can attempt to extract specific types using methods like .Sz() for strings or .Dword() for uint32 values.

package main

import (
	"github.com/rodrigocfd/windigo/co"
	"github.com/rodrigocfd/windigo/win"
)

func main() {
	hKey, _ := win.HKEY_CURRENT_USER.RegOpenKeyEx(
		"Control Panel\\Mouse",
		co.REG_OPTION_NONE,
		co.KEY_READ)
	defer hKey.RegCloseKey()

	regVal, _ := hKey.RegQueryValueEx("Beep")

	if strVal, ok := regVal.Sz(); ok {
		println("Beep is", strVal)
	}

	namesVals, _ := hKey.RegEnumValue()
	for _, nameVal := range namesVals {
		if str, ok := nameVal.Val.Sz(); ok {
			println("Value str", nameVal.Name, str)
		} else if num, ok := nameVal.Val.Dword(); ok {
			println("Value int", nameVal.Name, num)
		} else {
			println("Value other", nameVal.Name)
		}
	}
}