Multiple monitor support

[somethingweird287]

So, I use 2 monitors. When I installed the config, I could only see bar in 1 monitor. So I tweaked few things to get bar on both monitors.

Ax-Shell/main.py

from hyprpy import Hyprland


# ..... (previous code)

if __name__ == "__main__":
    setproctitle.setproctitle(APP_NAME)

    if not os.path.isfile(CONFIG_FILE):
        exec_shell_command_async(f"python {get_relative_path('../config/config.py')}")

    current_wallpaper = os.path.expanduser("~/.current.wall")
    if not os.path.exists(current_wallpaper):
        example_wallpaper = os.path.expanduser(
            f"~/.config/{APP_NAME_CAP}/assets/wallpapers_example/example-1.jpg"
        )
        os.symlink(example_wallpaper, current_wallpaper)

    # Load configuration
    from config.data import load_config
    config = load_config()
    corners = Corners()
    dock = Dock()

    notch = None

    bars = []
    monitors = get_all_monitors()

    for i, monitor in enumerate(monitors):
        bar = Bar(monitor_id=monitor.id)
        if i == 0:
            notch = Notch()
            bar.notch = notch
            notch.bar = bar
        bars.append(bar)

    # Set corners visibility based on config
    corners_visible = config.get("corners_visible", True)
    corners.set_visible(corners_visible)

    app_components = [dock, corners]
    for bar in bars:
        app_components.append(bar)

    # Add the notch only once and only if it was created
    if notch:
        app_components.append(notch)

    app = Application(
        f"{APP_NAME}", *app_components
    )
# ....... (rest of the code is same)

Ax-Shell/modules/bar.py

class Bar(Window):
    def __init__(self, monitor_id=None, **kwargs):
        super().__init__(
            name="bar",
            layer="top",
            monitor=monitor_id,
            anchor="left top right" if not data.VERTICAL else "top left bottom",
            margin="-4px -4px -8px -4px"
            if not data.VERTICAL
            else "-4px -8px -4px -4px",
            exclusivity="auto",
            visible=True,
            all_visible=True,
        )
# .........(rest of the code)

I am not good at programming, this is my first time doing these things, so maybe I could have done this better.

[ozgilik]

🚨 Missing get_all_monitors() Function

Hi, first of all, thank you for your great work on this project! 🙌

While reviewing the example code below:

monitors = get_all_monitors()

for i, monitor in enumerate(monitors):
    bar = Bar(monitor_id=monitor.id)
    if i == 0:
        notch = Notch()
        bar.notch = notch
        notch.bar = bar
    bars.append(bar)

I noticed that the function get_all_monitors() is being used but not defined anywhere in the repository.

To avoid confusion and make the example work out of the box, it might be a good idea to include a basic definition of this function. Since you're already using hyprpy, something like the following could work well:

from hyprpy import Hyprland

def get_all_monitors():
    hypr = Hyprland()
    return hypr.get_monitors()

Also, in order to use the hyprpy module, the python-hyprpy package must be installed. On Arch-based systems, it can be installed from the AUR using:

yay -S python-hyprpy

Including this helper function and installation note would greatly improve the developer experience for anyone trying to follow the examples.

Thanks again for the awesome project! 🚀

[somethingweird287]

Yeah I forgot about the function. As I said this is my first time doing these collaborative things. So apologies. And your get_all_monitors() function matches mine! And should I edit it and fix it?

[ozgilik]

🚨 Bug Report: Tools (Power vs. etc.) Windows Open on Incorrect Monitor and Are Unclickable

Hi there,

I encountered a bug where the tools windows (such as Power vs. etc.) open on the wrong monitor when clicked. These windows do not appear on the monitor where the click occurred, instead, they open on a different monitor.

Additionally, the opened windows are not clickable, making them unusable, and this significantly impacts the user experience.

This issue seems to be related to the window management or monitor handling, possibly due to incorrect focus behavior or window placement.

It would be great to see this issue addressed, as it currently prevents smooth usage of the tools.

I will take a look at it if I get a chance to work on it.

Thank you for your work on this project!

[ozgilik]

✅ Fix for Notch Display and Clickability on Multi-Monitor Setups

Hello! I have encountered an issue where clicking the power or tools or dashboard etc. buttons on monitors other than the primary monitor causes the corresponding notch window to:

• Open on the wrong monitor (usually the primary monitor).
• Become unclickable and unusable.

After reviewing the code, I realized that this is because only one instance of Notch is created and shared across all bars/monitors.

🔧 Solution

To fix this, I created a separate Notch instance for each monitor, like this:

notches = []

for i, monitor in enumerate(monitors):
    bar = Bar(monitor_id=monitor.id)
    notch = Notch(monitor_id=monitor.id) # Create a separate Notch for each monitor
    bar.notch = notch
    notch.bar = bar
    bars.append(bar)
    notches.append(notch)

With this change:

✅ Clicking on tools or power now or dashboard etc. will open the notch window on the correct monitor
✅ The window that opens will remain clickable and interactive
✅ Multi-monitor setups behave consistently and correctly

It seems to work for me. Please try it yourself.

Just wanted to share this in case anyone else encounters the same issue or the maintainer considers updating the default behavior. 🙌

[ozgilik]

Fix: Notch Windows Opening on Wrong Monitor with Keyboard Shortcuts ⌨️🖥️

---

Problem

When using keyboard shortcuts (SUPER+D, SUPER+B, etc.), Notch windows (Dashboard, Bluetooth, etc.) always opened on the primary monitor, even if:

• The cursor was on a secondary monitor 🖱️
• Active windows were on another monitor

Example:

1. Move cursor to Monitor 2
2. Press SUPER+D
3. Dashboard opens on Monitor 1 ❌

---

Solution

Modified notch.py to:

1. Track Notch instances per monitor 🗂️
2. Detect cursor position on shortcut press 🎯
3. Open windows on the monitor where the cursor resides ✅

Full Modified Code

modules/notch.py:

# ... other imports ...
import json
import subprocess

class Notch(Window):
    _instances = {}  # {monitor_id: Notch}

    def __init__(self, monitor_id=None, **kwargs):
        super().__init__(
            name=f"notch-{monitor_id}",
            layer="top",
            anchor="top",
            margin="-40px 0px 0px 0px" if not data.VERTICAL else "0px 0px 0px 0px",
            monitor=monitor_id,
            keyboard_mode="none",
            exclusivity="none",
            visible=True,
            all_visible=True,
        )
        self.monitor_id = str(monitor_id)
        Notch._instances[self.monitor_id] = self  # ✨ Track instance

        # ... rest of original __init__ code ...

    # NEW METHOD
    def open_notch(self, widget):
        try:
            # Get cursor position from Hyprland socket
            cursor_result = subprocess.run(
                ['hyprctl', 'cursorpos', '-j'], 
                capture_output=True, 
                text=True
            )
            cursor_data = json.loads(cursor_result.stdout)
            cursor_x, cursor_y = cursor_data["x"], cursor_data["y"]

            # Get all monitor information
            monitors_result = subprocess.run(
                ['hyprctl', 'monitors', '-j'], 
                capture_output=True, 
                text=True
            )
            monitors = json.loads(monitors_result.stdout)

            # Find the monitor with the cursor
            active_monitor = None
            for monitor in monitors:
                m_x = monitor["x"]
                m_y = monitor["y"]
                m_width = monitor["width"]
                m_height = monitor["height"]
                
                if (m_x <= cursor_x < m_x + m_width and 
                    m_y <= cursor_y < m_y + m_height):
                    active_monitor = monitor
                    break

            if not active_monitor:  # Fallback
                active_monitor = monitors[0]

            # Call the corresponding Notch instance
            active_id = str(active_monitor["id"])
            if self.monitor_id != active_id:
                active_notch = Notch._instances.get(active_id)
                if active_notch:
                    active_notch._real_open_notch(widget)
                    return
                    
            self._real_open_notch(widget)

        except Exception as e:
            print(f"Error: {e}")
            if Notch._instances:
                next(iter(Notch._instances.values()))._real_open_notch(widget)

    # RENAMED ORIGINAL METHOD
    def _real_open_notch(self, widget):
        # ORIGINAL CODE OF open_notch GOES HERE
        # ... full original implementation ...

Key Changes 🔄

Before	After
❌ Shortcuts ignored cursor position	✅ Shortcuts respect cursor position
❌ Single Notch instance for all monitors	✅ Dedicated Notch instance per monitor
❌ Hardcoded primary monitor logic	✅ Dynamic monitor detection using cursor position

---

How to Test 🧪

1. Basic Test

• Steps:
  1. Move cursor to secondary monitor
  2. Press SUPER+D
• Expected Result:
  ✅ Dashboard opens on the secondary monitor

2. Multi-Monitor Stress Test

• Steps:
  1. Rapidly move cursor between monitors
  2. Repeatedly press SUPER+D in different monitor zones
• Expected Result:
  🚀 Dashboard always follows cursor position

Maybe better solutions can be found. I shared it to help friends who are dealing with more than one monitor. I am sure @Axenide will do better and share the update with us.

[Axenide]

Woah guys, you've been busy, huh? I'll review these soon. Thank you for everything. :)

[UniOnTheMap]

Did you get time to review it? Any multi-monitor support would be better than nothing imo

[Axenide]

i forgor 💀

But after the next merge I'll work on it, I promise!