Simplify border drawing code

kitty/borders.py

@@ -69,6 +69,7 @@ class Borders:
         self.os_window_id = os_window_id
         self.tab_id = tab_id
         self.draw_active_borders = opts.active_border_color is not None
+        self.draw_minimal_borders = opts.draw_minimal_borders
 
     def __call__(
         self,
@@ -88,29 +89,24 @@ class Borders:
         if groups:
             bw = groups[0].effective_border()
         draw_borders = bw > 0 and draw_window_borders
-        if draw_borders:
-            border_data = current_layout.resolve_borders(all_windows)
         active_group = all_windows.active_group
 
         for i, wg in enumerate(groups):
             window_bg = wg.default_bg
             window_bg = (window_bg << 8) | BorderColor.window_bg
-            if draw_borders:
+            if draw_borders and not self.draw_minimal_borders:
                 # Draw the border rectangles
                 if wg is active_group and self.draw_active_borders:
                     color = BorderColor.active
                 else:
                     color = BorderColor.bell if wg.needs_attention else BorderColor.inactive
-                try:
+                draw_edges(self.os_window_id, self.tab_id, (color, color, color, color), wg, borders=True)
-                    colors = tuple(color if needed else window_bg for needed in next(border_data))
-                    draw_edges(self.os_window_id, self.tab_id, colors, wg, borders=True)
-                except StopIteration:
-                    pass
             if not has_background_image:
                 # Draw the background rectangles over the padding region
                 colors = window_bg, window_bg, window_bg, window_bg
                 draw_edges(self.os_window_id, self.tab_id, colors, wg)
 
-        for border_line in current_layout.window_independent_borders(all_windows):
+        if self.draw_minimal_borders:
-            left, top, right, bottom = border_line.edges
+            for border_line in current_layout.minimal_borders(all_windows):
-            add_borders_rect(self.os_window_id, self.tab_id, left, top, right, bottom, border_line.color)
+                left, top, right, bottom = border_line.edges
+                add_borders_rect(self.os_window_id, self.tab_id, left, top, right, bottom, border_line.color)

kitty/layout/base.py

@@ -19,13 +19,6 @@ from kitty.window_list import WindowGroup, WindowList
 from kitty.borders import BorderColor
 
 
-class Borders(NamedTuple):
-    left: bool
-    top: bool
-    right: bool
-    bottom: bool
-
-
 class BorderLine(NamedTuple):
     edges: Edges = Edges()
     color: BorderColor = BorderColor.inactive
@@ -45,8 +38,6 @@ class LayoutData(NamedTuple):
     content_size: int = 0
 
 
-all_borders = Borders(True, True, True, True)
-no_borders = Borders(False, False, False, False)
 DecorationPairs = Sequence[Tuple[int, int]]
 LayoutDimension = Generator[LayoutData, None, None]
 ListOfWindows = List[WindowType]
@@ -211,7 +202,6 @@ class Layout:
     name: Optional[str] = None
     needs_window_borders = True
     must_draw_borders = False  # can be overridden to customize behavior from kittens
-    no_minimal_window_borders = False  # if True means minimal borders are drawn in window_independent_borders
     layout_opts = LayoutOpts({})
     only_active_window_visible = False
 
@@ -384,22 +374,9 @@ class Layout:
     def compute_needs_borders_map(self, all_windows: WindowList) -> Dict[int, bool]:
         return all_windows.compute_needs_borders_map(lgd.draw_active_borders)
 
-    def resolve_borders(self, all_windows: WindowList) -> Generator[Borders, None, None]:
+    def minimal_borders(self, windows: WindowList) -> Generator[BorderLine, None, None]:
-        if lgd.draw_minimal_borders:
-            needs_borders_map = self.compute_needs_borders_map(all_windows)
-            yield from self.minimal_borders(all_windows, needs_borders_map)
-        else:
-            for i in range(all_windows.num_groups):
-                yield all_borders
-
-    def window_independent_borders(self, windows: WindowList) -> Generator[BorderLine, None, None]:
         return
         yield BorderLine()  # type: ignore
 
-    def minimal_borders(self, windows: WindowList, needs_borders_map: Dict[int, bool]) -> Generator[Borders, None, None]:
-        if not self.no_minimal_window_borders:
-            for needs_border in needs_borders_map.values():
-                yield all_borders if needs_border else no_borders
-
     def layout_action(self, action_name: str, args: Sequence[str], all_windows: WindowList) -> Optional[bool]:
         pass

kitty/layout/grid.py

@@ -178,7 +178,7 @@ class Grid(Layout):
                 n, nrows, ncols, special_rows, special_col, on_col_done):
             position_window_in_grid_cell(window_idx, xl, yl)
 
-    def window_independent_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
+    def minimal_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
         n = all_windows.num_groups
         if not lgd.draw_minimal_borders or n < 2:
             return

kitty/layout/splits.py

@@ -487,7 +487,7 @@ class Splits(Layout):
             pair.bias = 0.5
         return True
 
-    def window_independent_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
+    def minimal_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
         groups = tuple(all_windows.iter_all_layoutable_groups())
         window_count = len(groups)
         if not lgd.draw_minimal_borders or window_count < 2:

kitty/layout/tall.py

@@ -202,7 +202,7 @@ class Tall(Layout):
                 self.layout_opts.full_size -= 1
                 return True
 
-    def window_independent_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
+    def minimal_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
         num = all_windows.num_groups
         if num == 1 or not lgd.draw_minimal_borders:
             return

kitty/layout/vertical.py

@@ -10,7 +10,7 @@ from kitty.typing import WindowType
 from kitty.window_list import WindowGroup, WindowList
 
 from .base import (
-    BorderLine, Borders, Layout, LayoutData, LayoutDimension, NeighborsMap,
+    BorderLine, Layout, LayoutData, LayoutDimension, NeighborsMap,
     lgd, variable_bias
 )
 
@@ -63,7 +63,6 @@ class Vertical(Layout):
 
     name = 'vertical'
     main_is_horizontal = False
-    only_between_border = Borders(False, False, False, True)
     no_minimal_window_borders = True
     main_axis_layout = Layout.ylayout
     perp_axis_layout = Layout.xlayout
@@ -111,7 +110,7 @@ class Vertical(Layout):
         for wg, xl, yl in self.generate_layout_data(all_windows):
             self.set_window_group_geometry(wg, xl, yl)
 
-    def window_independent_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
+    def minimal_borders(self, all_windows: WindowList) -> Generator[BorderLine, None, None]:
         window_count = all_windows.num_groups
         if window_count == 1 or not lgd.draw_minimal_borders:
             return
@@ -133,6 +132,5 @@ class Horizontal(Vertical):
 
     name = 'horizontal'
     main_is_horizontal = True
-    only_between_border = Borders(False, False, True, False)
     main_axis_layout = Layout.xlayout
     perp_axis_layout = Layout.ylayout