Let’s bring some variety to the system tray menu – create a WinUI-style popup!

Actually, this won’t be a real menu – just a window we’ll display as a menu replacement. This approach has one significant limitation: the “hidden icons” overflow menu will immediately close when you move the cursor away from the tray icon. I suspect this behavior is specifically tied to our menu simulation.

Interestingly, I’ve noticed the same behavior in several fairly popular applications. So for now, we can probably overlook this issue.

In this article, I won’t include much code – it’s all available on GitHub (yes, it’s just one big class). The solution code provides an approximate approach to the problem and is intended more for demonstration purposes than for actual use in production projects.

Here’s the window creation code with detailed explanations of how we make it resemble a native context menu:

// Create a new WinUI window that will act as our fake menu
window = new Window();

// Set the content to ItemsControl (lightweight container for menu items)
window.Content = new ItemsControl()
{
    IsTabStop = false,       // Disable keyboard tab navigation
    MinWidth = 125,          // Set minimum width for menu-like appearance
    Margin = new Thickness(4, 4, 4, 4) // Add padding around items
};

// Get native window handle for Win32 API calls
var hWnd = (HWND)WinRT.Interop.WindowNative.GetWindowHandle(window);

// Apply visual styling to make it look like a menu
UseRoundCorners(hWnd);       // Modern rounded corners (Win11 style)
SetTopMost(hWnd);            // Keep above other windows

// Configure window styles to behave like a popup menu
SetWindowStyle(hWnd, WindowStyle.PopupWindow);  // Borderless popup style
AddWindowStyleEx(hWnd, WindowStyleEx.Layered |  // For transparency effects
                      WindowStyleEx.TopMost |    // Stay on top
                      WindowStyleEx.AppWindow);  // Modern window behavior

// Apply acrylic blur effect (WinUI style background)
window.SystemBackdrop = new DesktopAcrylicBackdrop();

// Set up window event handlers
window.Activated += OnWindowActivated;      // Handle activation
window.AppWindow.Closing += OnWindowClosing; // Handle closing
window.AppWindow.IsShownInSwitchers = false; // Ensure hidden from switchers

// Populate with menu items
SetItems((window.Content as ItemsControl)!, menuItems);

// Apply correct theme (dark/light mode)
UpdateTheme(ShouldSystemUseDarkMode());

Notice the ShouldSystemUseDarkMode? This function returns the taskbar’s theme. In my opinion, anything related to the taskbar and Start Menu should use system settings rather than application-specific ones.

It’s also good to track theme changes. We handle this through the WindowHelper class by processing WM_WININICHANGE messages:

if (messageId == WM_WININICHANGE && Marshal.PtrToStringAuto(lParam) == "ImmersiveColorSet")
{
    UpdateTheme(ShouldSystemUseDarkMode());
}

By the way, this applies to the application icon as well. You can make it automatically adapt to dark/light system themes.

Show method displays the context menu in the system tray:

public void Show(int x, int y)
{
    // Get native window handle for Win32 API calls
    var hWnd = (HWND)WinRT.Interop.WindowNative.GetWindowHandle(window);

    // Get current monitor's work area (excluding taskbar)
    var workArea = GetPrimaryWorkArea();
    
    // Get DPI scaling factor (for HighDPI displays)
    var scale = PInvoke.GetDpiForWindow(hWnd) / 96f; // 96 = 100% scaling

    // Ensure proper layout measurement
    if (window.Content is FrameworkElement root)
    {
        // Force layout recalculation
        root.UpdateLayout();
        
        // Measure available space (constrains to work area)
        root.Measure(new Size(workArea.Width, workArea.Height));
    }
    else
    {
        return; // Safety check
    }

    // Resize window to match content dimensions with DPI scaling
    window.AppWindow?.Resize(new Windows.Graphics.SizeInt32(
        (int)(root.DesiredSize.Width * scale),  // Scaled width
        (int)(root.DesiredSize.Height * scale)  // Scaled height
    ));

    var size = window.AppWindow?.Size;
    
    // Smart positioning:
    // - Flips horizontally if near right edge
    // - Always opens above cursor (standard menu behavior)
    window.AppWindow?.Move(new Windows.Graphics.PointInt32
    {
        X = (int)((x + size?.Width < workArea.Width ? x : x - size?.Width) ?? x),
        Y = (int)((y - size?.Height) ?? y)  // Position above cursor
    });

    PInvoke.SetForegroundWindow(hWnd);  // Bring to front
    PInvoke.ShowWindow(hWnd, SHOW_WINDOW_CMD.SW_SHOW); // Make visible
}

The GetPrimaryWorkArea method returns the usable area of ​​the screen (excluding the taskbar), which helps determine whether the tray icon is visible (when its borders extend beyond the work area) or hidden in a drop-down menu (when it is within that work area).

Leveraging this knowledge, you can customize menu display behavior. For example, here’s how I implemented it in flowOSD to match system taskbar menu styling:

image

Happy coding!