main.go

// ToggleTheme is a Windows system tray application that allows users to toggle between
// light and dark themes. It monitors the Windows registry for theme changes and updates
// the system tray menu accordingly. The application provides a simple interface for
// switching themes and includes an "About" dialog with information about the application.
//
// If you update winres/winres.json run: go-winres make
//
// build with: go build -ldflags "-s -w -H=windowsgui" -trimpath -o toggletheme.exe
//

package main

import (
	_ "embed"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"
	"unsafe"

	"fyne.io/systray"
	"golang.org/x/sys/windows"
	"golang.org/x/sys/windows/registry"
)

//go:embed dark-theme.ico
var iconData []byte

var mToggleTheme *systray.MenuItem
var user32 = syscall.NewLazyDLL("user32.dll")
var procMessageBoxW = user32.NewProc("MessageBoxW")

var temp = os.TempDir()
var logFile = temp + "\\toggletheme.log"

const personalizePath = `Software\Microsoft\Windows\CurrentVersion\Themes\Personalize`
const newline = "\r\n"

const appName = "ToggleTheme"

func MessageBox(title, text string, style uint) int {
	titlePtr, _ := syscall.UTF16PtrFromString(title)
	textPtr, _ := syscall.UTF16PtrFromString(text)
	ret, _, _ := procMessageBoxW.Call(
		0,
		uintptr(unsafe.Pointer(textPtr)),
		uintptr(unsafe.Pointer(titlePtr)),
		uintptr(style),
	)
	return int(ret)
}

func onReady() {
	systray.SetIcon(iconData)
	updateTooltip()
	systray.SetOnTapped(handleToggleAction)

	// Menu items
	mToggleTheme = systray.AddMenuItem(getToggleLabel(), "Switch between light and dark mode")
	systray.AddSeparator()
	mAbout := systray.AddMenuItem("About", "About ToggleTheme")
	mQuit := systray.AddMenuItem("Quit", "Exit the application")

	// Start registry watcher in background
	go watchThemeChanges()

	// Handle menu clicks
	go func() {
		for {
			select {
			case <-mToggleTheme.ClickedCh:
				handleToggleAction()
			case <-mAbout.ClickedCh:
				var msg = fmt.Sprintf("Toggles Windows theme between light and dark mode%s%s"+
					"Left-click the tray icon to toggle the theme.%s"+
					"Right-click the tray icon to access the menu.%s%s"+
					"https://github.com/Timthreetwelve/toggletheme",
					newline, newline, newline, newline, newline)
				MessageBox("About ToggleTheme", msg, 0)
			case <-mQuit.ClickedCh:
				systray.Quit()
				return
			}
		}
	}()
}

func handleToggleAction() {
	if err := toggleTheme(); err != nil {
		message := fmt.Sprintf("Failed to toggle theme: %v", err)
		writeLog(logFile, message)
		return
	}

	mToggleTheme.SetTitle(getToggleLabel())
	updateTooltip()
	curMode, _ := getCurrentTheme()
	if curMode {
		message := "Switched to light mode."
		writeLog(logFile, message)
		fmt.Println(message)
	} else {
		message := "Switched to dark mode."
		writeLog(logFile, message)
		fmt.Println(message)
	}
}

func onExit() {
	fmt.Println("Done.")
	message := "ToggleTheme is shutting down."
	writeLog(logFile, message)
	writeLog(logFile, "")
}

func getCurrentTheme() (bool, error) {
	k, err := registry.OpenKey(registry.CURRENT_USER, personalizePath, registry.QUERY_VALUE)
	if err != nil {
		return false, err
	}
	defer k.Close()

	val, _, err := k.GetIntegerValue("AppsUseLightTheme")
	if err != nil {
		return false, err
	}
	return val == 1, nil
}

func getToggleLabel() string {
	isLight, err := getCurrentTheme()
	if err != nil {
		return "Toggle Light/Dark Mode"
	}
	if isLight {
		return "Switch to Dark Mode"
	}
	return "Switch to Light Mode"
}

func getCurrentThemeLabel() string {
	isLight, err := getCurrentTheme()
	if err != nil {
		return "Current theme: Unknown"
	}
	if isLight {
		return "Current theme: Light"
	}
	return "Current theme: Dark"
}

func updateTooltip() {
	systray.SetTooltip(appName + newline + getCurrentThemeLabel())
}

func toggleTheme() error {
	k, err := registry.OpenKey(registry.CURRENT_USER, personalizePath, registry.QUERY_VALUE|registry.SET_VALUE)
	if err != nil {
		return err
	}
	defer k.Close()

	current, _, err := k.GetIntegerValue("AppsUseLightTheme")
	if err != nil {
		return err
	}

	var newVal uint64
	if current == 1 {
		newVal = 0 // Dark mode
	} else {
		newVal = 1 // Light mode
	}

	if err := k.SetDWordValue("AppsUseLightTheme", uint32(newVal)); err != nil {
		return err
	}
	if err := k.SetDWordValue("SystemUsesLightTheme", uint32(newVal)); err != nil {
		return err
	}

	return nil
}

// watchThemeChanges listens for registry changes and updates the menu label
func watchThemeChanges() {
	k, err := registry.OpenKey(registry.CURRENT_USER, personalizePath, registry.NOTIFY)
	if err != nil {
		message := fmt.Sprintf("Failed to open registry key for watching: %v", err)
		writeLog(logFile, message)
		return
	}
	defer k.Close()

	h := windows.Handle(k)
	for {
		// Wait for registry change notification
		err := windows.RegNotifyChangeKeyValue(
			h,
			false,
			windows.REG_NOTIFY_CHANGE_LAST_SET,
			0,
			false,
		)
		if err != nil {
			message := fmt.Sprintf("Registry watch error: %v", err)
			writeLog(logFile, message)
			return
		}

		// Update menu label after change
		mToggleTheme.SetTitle(getToggleLabel())
		updateTooltip()
	}
}

func writeLog(filename, message string) error {
	// Open file in append mode, create if not exists
	f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return fmt.Errorf("failed to open log file: %w", err)
	}
	defer func() {
		if cerr := f.Close(); cerr != nil {
			log.Printf("failed to close log file: %v", cerr)
		}
	}()

	// Create a logger that writes to the file
	logger := log.New(f, "", log.LstdFlags)
	logger.Println(message)
	return nil
}

func main() {

	execPath, err := os.Executable()
	if err != nil {
		fmt.Println("Error getting executable path:", err)
		return
	}
	message := fmt.Sprintf("ToggleTheme is starting up from %s.", execPath)
	writeLog(logFile, message)

	message = fmt.Sprintf("%s", getCurrentThemeLabel())
	writeLog(logFile, message)

	// Handle Ctrl+C / SIGTERM gracefully
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
	go func() {
		<-sigChan
		systray.Quit()
	}()

	// Run systray
	fmt.Println("ToggleTheme is running in the system tray. ")
	systray.Run(onReady, onExit)
}