[V2] SysTray

[alexec]

Is your feature request related to a problem? Please describe.

I'd like a systray in v2. v3 is alpha for 3(?) years now.
The https://github.com/getlantern/systray does not work because of objc linking conflict.
The APIs for systray are public.

Describe the solution you'd like

SysTray.

Describe alternatives you've considered

No response

Additional context

No response

[alexec]

// Package systray provides a macOS-specific system tray implementation.
package systray

type MenuItem struct {
	id         int
	title      string
	handler    func()
	ref        any
	subMenu    *Menu
	parentMenu *Menu
	isSubMenu  bool
}

type Menu struct {
	items []*MenuItem
	ref   any
}

var rootMenu *Menu

// Initialize initializes the systray
func Initialize() {
	rootMenu = &Menu{
		items: make([]*MenuItem, 0),
	}
	initialize()
}

func SetIcon(iconPath string)            { updateIcon(iconPath) }
func SetTooltip(tooltipText string)      { updateTooltip(tooltipText) }
func SetIconClickHandler(handler func()) { updateIconClickHandler(handler) }
func AddSeparator()                      { addSeparator() }

func AddMenuItem(title string, handler func()) *MenuItem {
	if rootMenu.items == nil {
		rootMenu.items = make([]*MenuItem, 0)
	}
	item := &MenuItem{
		id:         len(rootMenu.items),
		title:      title,
		handler:    handler,
		parentMenu: rootMenu,
	}
	rootMenu.items = append(rootMenu.items, item)
	addMenuItem(item)
	return item
}

// AddSubMenuItem creates a submenu for the given menu item
func (item *MenuItem) AddSubMenuItem(title string, handler func()) *MenuItem {
	if item.subMenu == nil {
		item.subMenu = &Menu{
			items: make([]*MenuItem, 0),
		}
		createSubMenu(item)
	}

	subItem := &MenuItem{
		id:         len(item.subMenu.items),
		title:      title,
		handler:    handler,
		parentMenu: item.subMenu,
		isSubMenu:  true,
	}
	item.subMenu.items = append(item.subMenu.items, subItem)
	addSubMenuItem(item, subItem)
	return subItem
}

// AddSeparator adds a separator to this menu item's submenu
func (item *MenuItem) AddSeparator() {
	if item.subMenu == nil {
		item.subMenu = &Menu{
			items: make([]*MenuItem, 0),
		}
		createSubMenu(item)
	}

	// Call the function to add a separator to this item's submenu
	addSubmenuSeparator(item)
}

func ClearMenuItems() {
	clearMenuItems()
	rootMenu.items = nil
}

//go:build darwin
// +build darwin

package systray

/*
#cgo CFLAGS: -x objective-c
#cgo LDFLAGS: -framework Cocoa
#include <stdlib.h>

// Function declarations for systray operations
void systray_init();
void systray_set_icon(const char* path);
void systray_set_tooltip(const char* tooltip);
int systray_add_menu_item(const char* title, const char* tooltip);
void systray_add_separator();
void systray_update_menu_item(int menuId, const char* title);
void systray_remove_menu_item(int menuId);
void systray_clear_menu_items();

// Function declarations for submenu support
void systray_create_submenu(int parentId);
int systray_add_submenu_item(int parentId, const char* title, const char* tooltip);
void systray_add_submenu_separator(int parentId);

// These functions are implemented in Go
extern void systray_ready();
extern void systray_menu_item_selected(int menu_id);
extern void systray_icon_clicked();
*/
import "C"
import (
	"runtime"
	"sync"
	"unsafe"
)

var (
	menuLock    sync.Mutex
	initialized bool
)

var (
	menuItemHandlers = make(map[int]func())
	iconClickHandler func()
	menuItemRefs     = make(map[int]*MenuItem)
)

// initialize initializes the systray and shows the icon in the status bar
func initialize() {
	menuLock.Lock()
	defer menuLock.Unlock()

	if !initialized {
		runtime.LockOSThread()
		defer runtime.UnlockOSThread()
		C.systray_init()
		initialized = true
	}
}

// updateIcon sets the systray icon
func updateIcon(iconPath string) {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	cPath := C.CString(iconPath)
	C.systray_set_icon(cPath)
	C.free(unsafe.Pointer(cPath))
}

// updateTooltip sets the systray tooltip (no-op now)
func updateTooltip(tooltipText string) {
	// Tooltip support removed
}

// updateIconClickHandler sets the handler for icon clicks
func updateIconClickHandler(handler func()) {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()
	iconClickHandler = handler
}

//export systray_ready
func systray_ready() {
	// This is called when the systray is ready
}

//export systray_menu_item_selected
func systray_menu_item_selected(menuID C.int) {
	menuItemHandlers[int(menuID)]()
}

// addMenuItem adds a menu item to the systray
func addMenuItem(item *MenuItem) {
	menuLock.Lock()
	defer menuLock.Unlock()

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	cTitle := C.CString(item.title)

	menuID := int(C.systray_add_menu_item(cTitle, nil))
	C.free(unsafe.Pointer(cTitle))

	item.id = menuID
	menuItemHandlers[menuID] = item.handler
	menuItemRefs[menuID] = item
}

func addSeparator() {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()
	C.systray_add_separator()
}

func removeMenuItem(item *MenuItem) {
	menuLock.Lock()
	defer menuLock.Unlock()

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	if item != nil && item.id >= 0 {
		// Remove from UI first
		C.systray_remove_menu_item(C.int(item.id))
		// Then remove handler
		delete(menuItemHandlers, item.id)
		delete(menuItemRefs, item.id)
		item.id = -1 // Mark as removed
	}
}

// createSubMenu creates a submenu for the given menu item
func createSubMenu(item *MenuItem) {
	menuLock.Lock()
	defer menuLock.Unlock()

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	if item != nil && item.id >= 0 {
		C.systray_create_submenu(C.int(item.id))

		if item.subMenu == nil {
			item.subMenu = &Menu{items: make([]*MenuItem, 0)}
		}
	}
}

// addSubMenuItem adds an item to a submenu
func addSubMenuItem(parent *MenuItem, item *MenuItem) {
	menuLock.Lock()
	defer menuLock.Unlock()

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	cTitle := C.CString(item.title)

	// Add to the parent's submenu using the Objective-C implementation
	menuID := int(C.systray_add_submenu_item(C.int(parent.id), cTitle, nil))
	C.free(unsafe.Pointer(cTitle))

	item.id = menuID
	menuItemHandlers[menuID] = item.handler
	menuItemRefs[menuID] = item

	if parent.subMenu != nil {
		parent.subMenu.items = append(parent.subMenu.items, item)
	}
}

// addSubmenuSeparator adds a separator to a submenu
func addSubmenuSeparator(parent *MenuItem) {
	menuLock.Lock()
	defer menuLock.Unlock()

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	if parent != nil && parent.id >= 0 {
		C.systray_add_submenu_separator(C.int(parent.id))
	}
}

func clearMenuItems() {
	menuLock.Lock()
	defer menuLock.Unlock()

	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	C.systray_clear_menu_items()
	menuItemHandlers = make(map[int]func())
	menuItemRefs = make(map[int]*MenuItem)
}

//export systray_icon_clicked
func systray_icon_clicked() {
	if iconClickHandler != nil {
		iconClickHandler()
	}
}

// This file is based on Wails 3 source code.
#import <Cocoa/Cocoa.h>
#include <stdlib.h>

// Function declarations
void initializeOnMainThread(void);
void systray_init(void);
void systray_set_icon(const char* path);
int systray_add_menu_item(const char* title, const char* unused);
void systray_add_separator(void);
void systray_add_submenu_separator(int parentId);
void systray_update_menu_item(int menuId, const char* title);
void systray_remove_menu_item(int menuId);
void systray_clear_menu_items(void);

// Forward declarations
extern void systray_menu_item_selected(int menu_id);
extern void systray_icon_clicked();

// Global variables
static NSStatusItem *statusItem;
static NSMenu *menu;
static NSMutableArray *menuItems;
static NSMutableDictionary *subMenus;
static BOOL initialized = NO;
static dispatch_semaphore_t menuSemaphore;

@interface SystrayDelegate : NSObject
- (void)menuItemClicked:(id)sender;
- (void)iconClicked:(id)sender;
@end

@implementation SystrayDelegate
- (void)menuItemClicked:(id)sender {
    NSMenuItem *menuItem = (NSMenuItem *)sender;
    int menuId = [menuItem tag];
    systray_menu_item_selected(menuId);
}

- (void)iconClicked:(id)sender {
    systray_icon_clicked();
}
@end

// Static instance of our delegate
static SystrayDelegate *delegate = nil;

void systray_init() {
    if (initialized) {
        return;
    }

    menuSemaphore = dispatch_semaphore_create(1);

    if ([NSThread isMainThread]) {
        initializeOnMainThread();
    } else {
        dispatch_sync(dispatch_get_main_queue(), ^{
            initializeOnMainThread();
        });
    }
}

void initializeOnMainThread() {
    menuItems = [[NSMutableArray alloc] init];
    subMenus = [[NSMutableDictionary alloc] init];

    statusItem = [[NSStatusBar systemStatusBar] statusItemWithLength:NSVariableStatusItemLength];
    [statusItem retain];
    [statusItem setVisible:YES];

    if ([statusItem respondsToSelector:@selector(button)]) {
        statusItem.button.imagePosition = NSImageLeft;
        statusItem.button.imageScaling = NSImageScaleProportionallyDown;

        NSImage *blankImage = [[NSImage alloc] initWithSize:NSMakeSize(22, 22)];
        statusItem.button.image = blankImage;
        [blankImage release];
    }

    menu = [[NSMenu alloc] init];
    [menu setAutoenablesItems:NO];
    [statusItem setMenu:menu];

    delegate = [[SystrayDelegate alloc] init];
    [delegate retain];

    if ([statusItem respondsToSelector:@selector(button)]) {
        statusItem.button.target = delegate;
        statusItem.button.action = @selector(iconClicked:);
    }

    initialized = YES;
}

void systray_set_icon(const char *path) {
    if (statusItem == nil || path == NULL) return;

    NSString *iconPath = [NSString stringWithUTF8String:path];
    if (iconPath == nil) return;

    dispatch_async(dispatch_get_main_queue(), ^{
        NSImage *icon = [[NSImage alloc] initWithContentsOfFile:iconPath];
        if (icon != nil) {
            CGFloat height = [[NSStatusBar systemStatusBar] thickness];
            [icon setSize:NSMakeSize(height, height)];
            [icon setTemplate:NO];

            if ([statusItem respondsToSelector:@selector(button)]) {
                statusItem.button.image = icon;
                statusItem.button.imagePosition = NSImageLeft;
                [statusItem setVisible:YES];
                statusItem.button.imageScaling = NSImageScaleProportionallyDown;
            } else {
                statusItem.button.image = icon;
            }
        }
        [icon release];
    });
}

void systray_set_tooltip(const char *tooltip) {
    // Tooltip functionality removed
    return;
}

int systray_add_menu_item(const char *title, const char *unused) {
    if (menu == nil) return -1;

    const char *safeTitle = title ? title : " ";
    __block int menuId = -1;

    dispatch_sync(dispatch_get_main_queue(), ^{
        NSString *titleStr = [NSString stringWithUTF8String:safeTitle];
        if (titleStr == nil) titleStr = @" ";

        NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle:titleStr
                                                        action:@selector(menuItemClicked:)
                                                 keyEquivalent:@""];
        [menuItem setTarget:delegate];

        menuId = [menuItems count];
        [menuItem setTag:menuId];

        [menu addItem:menuItem];
        [menuItems addObject:menuItem];
        [menuItem release];
    });

    return menuId;
}

void systray_add_separator() {
    if (menu == nil) return;

    dispatch_sync(dispatch_get_main_queue(), ^{
        [menu addItem:[NSMenuItem separatorItem]];
    });
}

void systray_add_submenu_separator(int parentId) {
    if (menu == nil) return;

    dispatch_sync(dispatch_get_main_queue(), ^{
        dispatch_semaphore_wait(menuSemaphore, DISPATCH_TIME_FOREVER);

        NSMenu *parentMenu = [subMenus objectForKey:[NSNumber numberWithInt:parentId]];
        if (parentMenu != nil) {
            [parentMenu addItem:[NSMenuItem separatorItem]];
        }

        dispatch_semaphore_signal(menuSemaphore);
    });
}

void systray_clear_menu_items() {
    if (menu == nil) return;

    dispatch_sync(dispatch_get_main_queue(), ^{
        dispatch_semaphore_wait(menuSemaphore, DISPATCH_TIME_FOREVER);
        [menu removeAllItems];
        [menuItems removeAllObjects];
        [subMenus removeAllObjects];
        dispatch_semaphore_signal(menuSemaphore);
    });
}

void systray_remove_menu_item(int menuId) {
    if (menu == nil) return;

    dispatch_sync(dispatch_get_main_queue(), ^{
        dispatch_semaphore_wait(menuSemaphore, DISPATCH_TIME_FOREVER);

        for (NSMenuItem *menuItem in [menu itemArray]) {
            if ([menuItem tag] == menuId) {
                [menu removeItem:menuItem];
                break;
            }
        }

        for (NSMenuItem *item in [menuItems copy]) {
            if ([item tag] == menuId) {
                [menuItems removeObject:item];
                break;
            }
        }

        // Remove any submenu associated with this item
        [subMenus removeObjectForKey:[NSNumber numberWithInt:menuId]];

        dispatch_semaphore_signal(menuSemaphore);
    });
}

void systray_create_submenu(int parentId) {
    if (menu == nil) return;

    dispatch_sync(dispatch_get_main_queue(), ^{
        dispatch_semaphore_wait(menuSemaphore, DISPATCH_TIME_FOREVER);

        NSMenuItem *parentItem = nil;
        for (NSMenuItem *item in menuItems) {
            if ([item tag] == parentId) {
                parentItem = item;
                break;
            }
        }

        if (parentItem != nil) {
            // Create submenu
            NSMenu *subMenu = [[NSMenu alloc] init];
            [subMenu setAutoenablesItems:NO];
            [parentItem setSubmenu:subMenu];

            // Store reference to submenu
            [subMenus setObject:subMenu forKey:[NSNumber numberWithInt:parentId]];
        }

        dispatch_semaphore_signal(menuSemaphore);
    });
}

int systray_add_submenu_item(int parentId, const char *title, const char *unused) {
    if (menu == nil) return -1;

    const char *safeTitle = title ? title : " ";
    __block int menuId = -1;

    dispatch_sync(dispatch_get_main_queue(), ^{
        dispatch_semaphore_wait(menuSemaphore, DISPATCH_TIME_FOREVER);

        NSMenu *parentMenu = [subMenus objectForKey:[NSNumber numberWithInt:parentId]];
        if (parentMenu == nil) {
            // Create a submenu if it doesn't exist
            for (NSMenuItem *item in menuItems) {
                if ([item tag] == parentId) {
                    NSMenu *newSubMenu = [[NSMenu alloc] init];
                    [newSubMenu setAutoenablesItems:NO];
                    [item setSubmenu:newSubMenu];
                    [subMenus setObject:newSubMenu forKey:[NSNumber numberWithInt:parentId]];
                    parentMenu = newSubMenu;
                    break;
                }
            }

            if (parentMenu == nil) {
                dispatch_semaphore_signal(menuSemaphore);
                return;
            }
        }

        NSString *titleStr = [NSString stringWithUTF8String:safeTitle];
        if (titleStr == nil) titleStr = @" ";

        NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle:titleStr
                                                      action:@selector(menuItemClicked:)
                                               keyEquivalent:@""];
        [menuItem setTarget:delegate];

        menuId = [menuItems count];
        [menuItem setTag:menuId];

        [parentMenu addItem:menuItem];
        [menuItems addObject:menuItem];

        dispatch_semaphore_signal(menuSemaphore);
    });

    return menuId;
}

[dmytro-vovk]

@alexec the code you posted works but partially. It shows the tray icon (Initialize() and SetIcon() work) but that's it, calling SetIconClickHandler() has no effect.

[alexec]

You can't call SetIconClickHandler if you add any menus. This is a Darwin limitation.

[dmytro-vovk]

Trying to get it working:

systray.Initialize()
systray.SetIcon("./build/appicon.png")
systray.SetIconClickHandler(func() {
	log.Println("Tray icon clicked")
})

This shows the icon, but log message is not there when I click it.

@alexec does it work for you? Could you please share a working code example? 🙏

[leaanthony]

Systray will not be supported in v2.

[alexec]

You can have sys-tray using the code above. That is what I'm doing.

[leaanthony]

I'm not saying you couldn't get it working if you tried hard enough but we aren't supporting it in v2 😄 It's super hard managing both versions right now 😅 Thanks for adding the example though. We can point people to this thread if they're keen 🙏

[leaanthony]

Not sure if this will work but @dosu - remember this thread for people wanting to use systray on mac for v2.

[dosubot[bot]]

Answer saved at https://app.dosu.dev/documents/9175ed26-4ba6-4de3-9ef0-cfe3ab6f2ff2

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}