Repository: qtile/qtile

Issue:
Window is pushed of screen when a max_border_width is greater then 0 and maximized
<!--
Please do not ask general questions here! There are [community
contact](https://github.com/qtile/qtile#community) options for that.
-->

# Issue description
When a window is maximized (not full screen) and the floating layout has a max_border_width > 0 the window will stretch off screen. This is especially noticeable the more width you add. If you have a second monitor you will see the window being shifted onto the 2nd screen.

When maximizing a window max_border_width will be taken into account when the window size is calculated.

This may also be present for fullscreen and fullscreen_border_width as well. In which case the correct window size should also take into account fullscreen_border_width

---
## Replicate
Use the config provided (need to change filetype to .py) hit mod + f while having a window in focus. It will maximize that window with borders of 10
observe that the window has been offset by the border off the screen

<!--
A brief discussion of what failed and how it failed. A description of
what you tried is helpful, i.e. "When I use lazy.kill() on a window I get
the following stack trace" instead of "Closing windows doesn't work".
-->

# Qtile version
0.18.1.dev0+g8e7ecc0a.d20210719
<!--
Please include the exact commit hash of the version of Qtile that failed.
-->

# Stack traces

<!--
Please attach any stack traces found in:

* `~/.xsession-errors`
* `~/.local/share/qtile/qtile.log`
-->

# Configuration
```python
# Copyright (c) 2010 Aldo Cortesi
# Copyright (c) 2010, 2014 dequis
# Copyright (c) 2012 Randall Ma
# Copyright (c) 2012-2014 Tycho Andersen
# Copyright (c) 2012 Craig Barnes
# Copyright (c) 2013 horsik
# Copyright (c) 2013 Tao Sauvage
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

from typing import List  # noqa: F401

from libqtile import bar, layout, widget
from libqtile.config import Click, Drag, Group, Key, Match, Screen
from libqtile.lazy import lazy
from libqtile.utils import guess_terminal

mod = "mod4"
terminal = guess_terminal()

keys = [
    # Switch between windows
    Key([mod], "h", lazy.layout.left(), desc="Move focus to left"),
    Key([mod], "l", lazy.layout.right(), desc="Move focus to right"),
    Key([mod], "j", lazy.layout.down(), desc="Move focus down"),
    Key([mod], "k", lazy.layout.up(), desc="Move focus up"),
    Key([mod], "f", lazy.window.toggle_maximize()),
    Key([mod], "space", lazy.layout.next(),
        desc="Move window focus to other window"),

    # Move windows between left/right columns or move up/down in current stack.
    # Moving out of range in Columns layout will create new column.
    Key([mod, "shift"], "h", lazy.layout.shuffle_left(),
        desc="Move window to the left"),
    Key([mod, "shift"], "l", lazy.layout.shuffle_right(),
        desc="Move window to the right"),
    Key([mod, "shift"], "j", lazy.layout.shuffle_down(),
        desc="Move window down"),
    Key([mod, "shift"], "k", lazy.layout.shuffle_up(), desc="Move window up"),

    # Grow windows. If current window is on the edge of screen and direction
    # will be to screen edge - window would shrink.
    Key([mod, "control"], "h", lazy.layout.grow_left(),
        desc="Grow window to the left"),
    Key([mod, "control"], "l", lazy.layout.grow_right(),
        desc="Grow window to the right"),
    Key([mod, "control"], "j", lazy.layout.grow_down(),
        desc="Grow window down"),
    Key([mod, "control"], "k", lazy.layout.grow_up(), desc="Grow window up"),
    Key([mod], "n", lazy.layout.normalize(), desc="Reset all window sizes"),

    # Toggle between split and unsplit sides of stack.
    # Split = all windows displayed
    # Unsplit = 1 window displayed, like Max layout, but still with
    # multiple stack panes
    Key([mod, "shift"], "Return", lazy.layout.toggle_split(),
        desc="Toggle between split and unsplit sides of stack"),
    Key([mod], "Return", lazy.spawn(terminal), desc="Launch terminal"),

    # Toggle between different layouts as defined below
    Key([mod], "Tab", lazy.next_layout(), desc="Toggle between layouts"),
    Key([mod], "w", lazy.window.kill(), desc="Kill focused window"),

    Key([mod, "control"], "r", lazy.restart(), desc="Restart Qtile"),
    Key([mod, "control"], "q", lazy.shutdown(), desc="Shutdown Qtile"),
    Key([mod], "r", lazy.spawncmd(),
        desc="Spawn a command using a prompt widget"),
]

groups = [Group(i) for i in "123456789"]

for i in groups:
    keys.extend([
        # mod1 + letter of group = switch to group
        Key([mod], i.name, lazy.group[i.name].toscreen(),
            desc="Switch to group {}".format(i.name)),

        # mod1 + shift + letter of group = switch to & move focused window to group
        Key([mod, "shift"], i.name, lazy.window.togroup(i.name, switch_group=True),
            desc="Switch to & move focused window to group {}".format(i.name)),
        # Or, use below if you prefer not to switch to that group.
        # # mod1 + shift + letter of group = move focused window to group
        # Key([mod, "shift"], i.name, lazy.window.togroup(i.name),
        #     desc="move focused window to group {}".format(i.name)),
    ])

layouts = [
    layout.Columns(border_focus_stack=['#d75f5f', '#8f3d3d'], border_width=4),
    layout.Max(),
    # Try more layouts by unleashing below layouts.
    # layout.Stack(num_stacks=2),
    # layout.Bsp(),
    # layout.Matrix(),
    # layout.MonadTall(),
    # layout.MonadWide(),
    # layout.RatioTile(),
    # layout.Tile(),
    # layout.TreeTab(),
    # layout.VerticalTile(),
    # layout.Zoomy(),
]

widget_defaults = dict(
    font='sans',
    fontsize=12,
    padding=3,
)
extension_defaults = widget_defaults.copy()

screens = [
    Screen(
        bottom=bar.Bar(
            [
                widget.CurrentLayout(),
                widget.GroupBox(),
                widget.Prompt(),
                widget.WindowName(),
                widget.Chord(
                    chords_colors={
                        'launch': ("#ff0000", "#ffffff"),
                    },
                    name_transform=lambda name: name.upper(),
                ),
                widget.TextBox("default config", name="default"),
                widget.TextBox("Press &lt;M-r&gt; to spawn", foreground="#d75f5f"),
                widget.Systray(),
                widget.Clock(format='%Y-%m-%d %a %I:%M %p'),
                widget.QuickExit(),
            ],
            24,
        ),
    ),
]

# Drag floating layouts.
mouse = [
    Drag([mod], "Button1", lazy.window.set_position_floating(),
         start=lazy.window.get_position()),
    Drag([mod], "Button3", lazy.window.set_size_floating(),
         start=lazy.window.get_size()),
    Click([mod], "Button2", lazy.window.bring_to_front())
]

dgroups_key_binder = None
dgroups_app_rules = []  # type: List
follow_mouse_focus = True
bring_front_click = False
cursor_warp = False
floating_layout = layout.Floating(float_rules=[
    # Run the utility of `xprop` to see the wm class and name of an X client.
    *layout.Floating.default_float_rules,
    Match(wm_class='confirmreset'),  # gitk
    Match(wm_class='makebranch'),  # gitk
    Match(wm_class='maketag'),  # gitk
    Match(wm_class='ssh-askpass'),  # ssh-askpass
    Match(title='branchdialog'),  # gitk
    Match(title='pinentry'),  # GPG key password entry
], fullscreen_border_width = 10, max_border_width = 10, border_width = 10, border_focus = "#ffcc55", border_normal = "#000000")
auto_fullscreen = True
focus_on_window_activation = "smart"
reconfigure_screens = True

# If things like steam games want to auto-minimize themselves when losing
# focus, should we respect this or not?
auto_minimize = True

# XXX: Gasp! We're lying here. In fact, nobody really uses or cares about this
# string besides java UI toolkits; you can see several discussions on the
# mailing lists, GitHub issues, and other WM documentation that suggest setting
# this string if your java app doesn't work correctly. We may as well just lie
# and say that we're a working one by default.
#
# We choose LG3D to maximize irony: it is a 3D non-reparenting WM written in
# java that happens to be on java's whitelist.
wmname = "LG3D"

```
<!--
Please include a link or attach your configuration to the issue.
-->
[config.txt](https://github.com/qtile/qtile/files/7008036/config.txt)




Discussion:

Resolving patch:
diff --git a/libqtile/backend/wayland/window.py b/libqtile/backend/wayland/window.py
--- a/libqtile/backend/wayland/window.py
+++ b/libqtile/backend/wayland/window.py
@@ -348,11 +348,12 @@ def fullscreen(self, do_full):
         if do_full:
             screen = self.group.screen or \
                 self.qtile.find_closest_screen(self.x, self.y)
+            bw = self.group.floating_layout.fullscreen_border_width
             self._enablefloating(
                 screen.x,
                 screen.y,
-                screen.width,
-                screen.height,
+                screen.width - 2 * bw,
+                screen.height - 2 * bw,
                 new_float_state=FloatStates.FULLSCREEN
             )
             return
@@ -370,11 +371,12 @@ def maximized(self, do_maximize):
             screen = self.group.screen or \
                 self.qtile.find_closest_screen(self.x, self.y)
 
+            bw = self.group.floating_layout.max_border_width
             self._enablefloating(
                 screen.dx,
                 screen.dy,
-                screen.dwidth,
-                screen.dheight,
+                screen.dwidth - 2 * bw,
+                screen.dheight - 2 * bw,
                 new_float_state=FloatStates.MAXIMIZED
             )
         else:
diff --git a/libqtile/backend/x11/window.py b/libqtile/backend/x11/window.py
--- a/libqtile/backend/x11/window.py
+++ b/libqtile/backend/x11/window.py
@@ -1323,11 +1323,12 @@ def set_state(old_state, new_state):
             screen = self.group.screen or \
                 self.qtile.find_closest_screen(self.x, self.y)
 
+            bw = self.group.floating_layout.fullscreen_border_width
             self._enablefloating(
                 screen.x,
                 screen.y,
-                screen.width,
-                screen.height,
+                screen.width - 2 * bw,
+                screen.height - 2 * bw,
                 new_float_state=FloatStates.FULLSCREEN
             )
             set_state(prev_state, prev_state | atom)
@@ -1353,11 +1354,12 @@ def maximized(self, do_maximize):
             screen = self.group.screen or \
                 self.qtile.find_closest_screen(self.x, self.y)
 
+            bw = self.group.floating_layout.max_border_width
             self._enablefloating(
                 screen.dx,
                 screen.dy,
-                screen.dwidth,
-                screen.dheight,
+                screen.dwidth - 2 * bw,
+                screen.dheight - 2 * bw,
                 new_float_state=FloatStates.MAXIMIZED
             )
         else:


Test patch:
diff --git a/test/layouts/test_floating.py b/test/layouts/test_floating.py
--- a/test/layouts/test_floating.py
+++ b/test/layouts/test_floating.py
@@ -34,7 +34,10 @@ class FloatingConfig(Config):
     layouts = [
         layout.Floating()
     ]
-    floating_layout = libqtile.resources.default_config.floating_layout
+    floating_layout = layout.Floating(
+        fullscreen_border_width=15,
+        max_border_width=10,
+    )
     keys = []
     mouse = []
     screens = []
@@ -69,3 +72,32 @@ def test_float_next_prev_window(manager):
     assert_focused(manager, "two")
     manager.c.group.next_window()
     assert_focused(manager, "three")
+
+
+@floating_config
+def test_border_widths(manager):
+    manager.test_window("one")
+
+    # Default geometry
+    info = manager.c.window.info()
+    assert info["x"] == 350
+    assert info["y"] == 250
+    assert info["width"] == 100
+    assert info["height"] == 100
+
+    # Fullscreen
+    manager.c.window.enable_fullscreen()
+    info = manager.c.window.info()
+    assert info["x"] == 0
+    assert info["y"] == 0
+    assert info["width"] == 770
+    assert info["height"] == 570
+    manager.c.window.disable_fullscreen()
+
+    # Maximized
+    manager.c.window.toggle_maximize()
+    info = manager.c.window.info()
+    assert info["x"] == 0
+    assert info["y"] == 0
+    assert info["width"] == 780
+    assert info["height"] == 580