From f801c47d1e041b45fbaf019c13b8d4e0362dd6bb Mon Sep 17 00:00:00 2001 From: Kovid Goyal Date: Thu, 7 May 2020 11:41:35 +0530 Subject: [PATCH] Port vertical/horz layouts to new groups API --- kitty/layout/vertical.py | 56 +++++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 26 deletions(-) diff --git a/kitty/layout/vertical.py b/kitty/layout/vertical.py index a4d6d3cba..1c24f2d67 100644 --- a/kitty/layout/vertical.py +++ b/kitty/layout/vertical.py @@ -2,14 +2,14 @@ # vim:fileencoding=utf-8 # License: GPLv3 Copyright: 2020, Kovid Goyal -from typing import Dict, Generator, Optional +from typing import Dict, Generator from kitty.typing import WindowType from kitty.window_list import WindowList from .base import ( - Borders, NeighborsMap, Layout, LayoutDimension, ListOfWindows, - all_borders, no_borders, variable_bias + Borders, Layout, LayoutDimension, NeighborsMap, all_borders, no_borders, + variable_bias ) @@ -21,61 +21,65 @@ class Vertical(Layout): main_axis_layout = Layout.ylayout perp_axis_layout = Layout.xlayout - def variable_layout(self, windows: ListOfWindows, biased_map: Dict[int, float]) -> LayoutDimension: - num_windows = len(windows) + def variable_layout(self, all_windows: WindowList, biased_map: Dict[int, float]) -> LayoutDimension: + num_windows = all_windows.num_groups bias = variable_bias(num_windows, biased_map) if num_windows else None - return self.main_axis_layout(windows, bias=bias) + return self.main_axis_layout(all_windows.iter_all_layoutable_groups(), bias=bias) def remove_all_biases(self) -> bool: self.biased_map: Dict[int, float] = {} return True - def apply_bias(self, idx: int, increment: float, top_level_windows: ListOfWindows, is_horizontal: bool = True) -> bool: + def apply_bias(self, idx: int, increment: float, all_windows: WindowList, is_horizontal: bool = True) -> bool: if self.main_is_horizontal != is_horizontal: return False - num_windows = len(top_level_windows) + num_windows = all_windows.num_groups if num_windows < 2: return False - before_layout = list(self.variable_layout(top_level_windows, self.biased_map)) + before_layout = list(self.variable_layout(all_windows, self.biased_map)) candidate = self.biased_map.copy() before = candidate.get(idx, 0) candidate[idx] = before + increment - if before_layout == list(self.variable_layout(top_level_windows, candidate)): + if before_layout == list(self.variable_layout(all_windows, candidate)): return False self.biased_map = candidate return True - def do_layout(self, windows: WindowList, active_window_idx: int) -> None: - window_count = len(windows) + def do_layout(self, all_windows: WindowList) -> None: + window_count = all_windows.num_groups if window_count == 1: - self.layout_single_window(windows[0]) + self.layout_single_window_group(next(all_windows.iter_all_layoutable_groups())) return - ylayout = self.variable_layout(windows, self.biased_map) - for i, (w, yl) in enumerate(zip(windows, ylayout)): - xl = next(self.perp_axis_layout([w])) + ylayout = self.variable_layout(all_windows, self.biased_map) + for i, (wg, yl) in enumerate(zip(all_windows.iter_all_layoutable_groups(), ylayout)): + xl = next(self.perp_axis_layout(iter((wg,)))) if self.main_is_horizontal: xl, yl = yl, xl - self.set_window_geometry(w, i, xl, yl) + self.set_window_group_geometry(wg, xl, yl) - def minimal_borders(self, windows: WindowList, active_window: Optional[WindowType], needs_borders_map: Dict[int, bool]) -> Generator[Borders, None, None]: - last_i = len(windows) - 1 - for i, w in enumerate(windows): - if needs_borders_map[w.id]: + def minimal_borders(self, all_windows: WindowList, needs_borders_map: Dict[int, bool]) -> Generator[Borders, None, None]: + last_i = all_windows.num_groups - 1 + groups = tuple(all_windows.iter_all_layoutable_groups()) + for i, wg in enumerate(groups): + if needs_borders_map[wg.id]: yield all_borders continue if i == last_i: yield no_borders break - if needs_borders_map[windows[i+1].id]: + if needs_borders_map[groups[i+1].id]: yield no_borders else: yield self.only_between_border - def neighbors_for_window(self, window: WindowType, windows: WindowList) -> NeighborsMap: - idx = windows.index(window) - before = [] if window is windows[0] else [windows[idx-1].id] - after = [] if window is windows[-1] else [windows[idx+1].id] + def neighbors_for_window(self, window: WindowType, all_windows: WindowList) -> NeighborsMap: + wg = all_windows.group_for_window(window) + assert wg is not None + groups = tuple(all_windows.iter_all_layoutable_groups()) + idx = groups.index(wg) + before = [] if wg is groups[0] else [groups[idx-1].id] + after = [] if wg is groups[-1] else [groups[idx+1].id] if self.main_is_horizontal: return {'left': before, 'right': after, 'top': [], 'bottom': []} return {'top': before, 'bottom': after, 'left': [], 'right': []}