blob: 044751bf86b8dde5ca6e3bab0aee16da6529df77 [file] [log] [blame]
# Copyright 2021 The Pigweed Authors
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.
"""WindowManager"""
import collections
import copy
import functools
from itertools import chain
import logging
import operator
from typing import Any, Dict, Iterable, List, Optional
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.layout import (
Dimension,
HSplit,
VSplit,
FormattedTextControl,
Window,
WindowAlign,
)
from prompt_toolkit.mouse_events import MouseEvent, MouseEventType, MouseButton
from prompt_toolkit.widgets import MenuItem
from pw_console.console_prefs import ConsolePrefs, error_unknown_window
from pw_console.log_pane import LogPane
import pw_console.widgets.checkbox
from pw_console.widgets import WindowPaneToolbar
import pw_console.widgets.mouse_handlers
from pw_console.window_list import WindowList, DisplayMode
_LOG = logging.getLogger(__package__)
# Amount for adjusting window dimensions when enlarging and shrinking.
_WINDOW_SPLIT_ADJUST = 1
class WindowListResizeHandle(FormattedTextControl):
"""Button to initiate window list resize drag events."""
def __init__(self, window_manager, window_list: Any, *args,
**kwargs) -> None:
self.window_manager = window_manager
self.window_list = window_list
super().__init__(*args, **kwargs)
def mouse_handler(self, mouse_event: MouseEvent):
"""Mouse handler for this control."""
# Start resize mouse drag event
if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
self.window_manager.start_resize(self.window_list)
# Mouse event handled, return None.
return None
# Mouse event not handled, return NotImplemented.
return NotImplemented
class WindowManagerVSplit(VSplit):
"""PromptToolkit VSplit class with some additions for size and mouse resize.
This VSplit has a write_to_screen function that saves the width and height
of the container for the current render pass. It also handles overriding
mouse handlers for triggering window resize adjustments.
"""
def __init__(self, parent_window_manager, *args, **kwargs):
# Save a reference to the parent window pane.
self.parent_window_manager = parent_window_manager
super().__init__(*args, **kwargs)
def write_to_screen(
self,
screen,
mouse_handlers,
write_position,
parent_style: str,
erase_bg: bool,
z_index: Optional[int],
) -> None:
new_mouse_handlers = mouse_handlers
# Is resize mode active?
if self.parent_window_manager.resize_mode:
# Ignore future mouse_handler updates.
new_mouse_handlers = (
pw_console.widgets.mouse_handlers.EmptyMouseHandler())
# Set existing mouse_handlers to the parent_window_managers's
# mouse_handler. This will handle triggering resize events.
mouse_handlers.set_mouse_handler_for_range(
write_position.xpos,
write_position.xpos + write_position.width,
write_position.ypos,
write_position.ypos + write_position.height,
self.parent_window_manager.mouse_handler)
# Save the width and height for the current render pass.
self.parent_window_manager.update_window_manager_size(
write_position.width, write_position.height)
# Continue writing content to the screen.
super().write_to_screen(screen, new_mouse_handlers, write_position,
parent_style, erase_bg, z_index)
class WindowManagerHSplit(HSplit):
"""PromptToolkit HSplit class with some additions for size and mouse resize.
This HSplit has a write_to_screen function that saves the width and height
of the container for the current render pass. It also handles overriding
mouse handlers for triggering window resize adjustments.
"""
def __init__(self, parent_window_manager, *args, **kwargs):
# Save a reference to the parent window pane.
self.parent_window_manager = parent_window_manager
super().__init__(*args, **kwargs)
def write_to_screen(
self,
screen,
mouse_handlers,
write_position,
parent_style: str,
erase_bg: bool,
z_index: Optional[int],
) -> None:
new_mouse_handlers = mouse_handlers
# Is resize mode active?
if self.parent_window_manager.resize_mode:
# Ignore future mouse_handler updates.
new_mouse_handlers = (
pw_console.widgets.mouse_handlers.EmptyMouseHandler())
# Set existing mouse_handlers to the parent_window_managers's
# mouse_handler. This will handle triggering resize events.
mouse_handlers.set_mouse_handler_for_range(
write_position.xpos,
write_position.xpos + write_position.width,
write_position.ypos,
write_position.ypos + write_position.height,
self.parent_window_manager.mouse_handler)
# Save the width and height for the current render pass.
self.parent_window_manager.update_window_manager_size(
write_position.width, write_position.height)
# Continue writing content to the screen.
super().write_to_screen(screen, new_mouse_handlers, write_position,
parent_style, erase_bg, z_index)
class WindowManager:
"""WindowManager class
This class handles adding/removing/resizing windows and rendering the
prompt_toolkit split layout."""
# pylint: disable=too-many-public-methods,too-many-instance-attributes
def __init__(
self,
application: Any,
):
self.application = application
self.window_lists: collections.deque = collections.deque()
self.window_lists.append(WindowList(self))
self.key_bindings = self._create_key_bindings()
self.top_toolbars: List[WindowPaneToolbar] = []
self.bottom_toolbars: List[WindowPaneToolbar] = []
self.resize_mode: bool = False
self.resize_target_window_list_index: Optional[int] = None
self.resize_target_window_list: Optional[int] = None
self.resize_current_row: int = 0
self.resize_current_column: int = 0
self.current_window_manager_width: int = 0
self.current_window_manager_height: int = 0
self.last_window_manager_width: int = 0
self.last_window_manager_height: int = 0
def update_window_manager_size(self, width, height):
"""Save width and height for the current UI render pass."""
if width:
self.last_window_manager_width = self.current_window_manager_width
self.current_window_manager_width = width
if height:
self.last_window_manager_height = self.current_window_manager_height
self.current_window_manager_height = height
if (self.current_window_manager_width != self.last_window_manager_width
or self.current_window_manager_height !=
self.last_window_manager_height):
self.rebalance_window_list_sizes()
def _set_window_list_sizes(self, new_heights: List[int],
new_widths: List[int]) -> None:
for window_list in self.window_lists:
window_list.height = Dimension(preferred=new_heights[0])
new_heights = new_heights[1:]
window_list.width = Dimension(preferred=new_widths[0])
new_widths = new_widths[1:]
def vertical_window_list_spliting(self) -> bool:
return self.application.prefs.window_column_split_method == 'vertical'
def rebalance_window_list_sizes(self) -> None:
"""Adjust relative split sizes to fill available space."""
available_height = self.current_window_manager_height
available_width = self.current_window_manager_width
old_heights = [w.height.preferred for w in self.window_lists]
old_widths = [w.width.preferred for w in self.window_lists]
# Make sure the old totals are not zero.
old_height_total = max(sum(old_heights), 1)
old_width_total = max(sum(old_widths), 1)
height_percentages = [
value / old_height_total for value in old_heights
]
width_percentages = [value / old_width_total for value in old_widths]
new_heights = [
int(available_height * percentage)
for percentage in height_percentages
]
new_widths = [
int(available_width * percentage)
for percentage in width_percentages
]
if self.vertical_window_list_spliting():
new_heights = [
self.current_window_manager_height for h in new_heights
]
else:
new_widths = [
self.current_window_manager_width for h in new_widths
]
self._set_window_list_sizes(new_heights, new_widths)
def _create_key_bindings(self) -> KeyBindings:
key_bindings = KeyBindings()
register = self.application.prefs.register_keybinding
@register('window-manager.move-pane-left', key_bindings)
def move_pane_left(_event):
"""Move window pane left."""
self.move_pane_left()
@register('window-manager.move-pane-right', key_bindings)
def move_pane_right(_event):
"""Move window pane right."""
self.move_pane_right()
@register('window-manager.move-pane-down', key_bindings)
def move_pane_down(_event):
"""Move window pane down."""
self.move_pane_down()
@register('window-manager.move-pane-up', key_bindings)
def move_pane_up(_event):
"""Move window pane up."""
self.move_pane_up()
@register('window-manager.enlarge-pane', key_bindings)
def enlarge_pane(_event):
"""Enlarge the active window pane."""
self.enlarge_pane()
@register('window-manager.shrink-pane', key_bindings)
def shrink_pane(_event):
"""Shrink the active window pane."""
self.shrink_pane()
@register('window-manager.shrink-split', key_bindings)
def shrink_split(_event):
"""Shrink the current window split."""
self.shrink_split()
@register('window-manager.enlarge-split', key_bindings)
def enlarge_split(_event):
"""Enlarge the current window split."""
self.enlarge_split()
@register('window-manager.focus-prev-pane', key_bindings)
def focus_prev_pane(_event):
"""Switch focus to the previous window pane or tab."""
self.focus_previous_pane()
@register('window-manager.focus-next-pane', key_bindings)
def focus_next_pane(_event):
"""Switch focus to the next window pane or tab."""
self.focus_next_pane()
@register('window-manager.balance-window-panes', key_bindings)
def balance_window_panes(_event):
"""Balance all window sizes."""
self.balance_window_sizes()
return key_bindings
def delete_empty_window_lists(self):
empty_lists = [
window_list for window_list in self.window_lists
if window_list.empty()
]
for empty_list in empty_lists:
self.window_lists.remove(empty_list)
def add_top_toolbar(self, toolbar: WindowPaneToolbar) -> None:
self.top_toolbars.append(toolbar)
def add_bottom_toolbar(self, toolbar: WindowPaneToolbar) -> None:
self.bottom_toolbars.append(toolbar)
def create_root_container(self):
"""Create vertical or horizontal splits for all active panes."""
self.delete_empty_window_lists()
for window_list in self.window_lists:
window_list.update_container()
vertical_split = self.vertical_window_list_spliting()
window_containers = []
for i, window_list in enumerate(self.window_lists):
window_containers.append(window_list.container)
if (i + 1) >= len(self.window_lists):
continue
if vertical_split:
separator_padding = Window(
content=WindowListResizeHandle(self, window_list, "│"),
char='│',
width=1,
dont_extend_height=False,
)
resize_separator = HSplit(
[
separator_padding,
Window(
content=WindowListResizeHandle(
self, window_list, "║\n║\n║"),
char='│',
width=1,
dont_extend_height=True,
),
separator_padding,
],
style='class:pane_separator',
)
else:
resize_separator = Window(
content=WindowListResizeHandle(self, window_list, "════"),
char='─',
height=1,
align=WindowAlign.CENTER,
dont_extend_width=False,
style='class:pane_separator',
)
window_containers.append(resize_separator)
if vertical_split:
split = WindowManagerVSplit(self, window_containers)
else:
split = WindowManagerHSplit(self, window_containers)
split_items = []
split_items.extend(self.top_toolbars)
split_items.append(split)
split_items.extend(self.bottom_toolbars)
return HSplit(split_items)
def update_root_container_body(self):
# Replace the root MenuContainer body with the new split.
self.application.root_container.container.content.children[
1] = self.create_root_container()
def _get_active_window_list_and_pane(self):
active_pane = None
active_window_list = None
for window_list in self.window_lists:
active_pane = window_list.get_current_active_pane()
if active_pane:
active_window_list = window_list
break
return active_window_list, active_pane
def window_list_index(self, window_list: WindowList) -> Optional[int]:
index = None
try:
index = self.window_lists.index(window_list)
except ValueError:
# Ignore ValueError which can be raised by the self.window_lists
# deque if the window_list can't be found.
pass
return index
def run_action_on_active_pane(self, function_name):
_active_window_list, active_pane = (
self._get_active_window_list_and_pane())
if not hasattr(active_pane, function_name):
return
method_to_call = getattr(active_pane, function_name)
method_to_call()
return
def focus_previous_pane(self) -> None:
"""Focus on the previous visible window pane or tab."""
self.focus_next_pane(reverse_order=True)
def focus_next_pane(self, reverse_order=False) -> None:
"""Focus on the next visible window pane or tab."""
active_window_list, active_pane = (
self._get_active_window_list_and_pane())
if active_window_list is None:
return
# Total count of window lists and panes
window_list_count = len(self.window_lists)
pane_count = len(active_window_list.active_panes)
# Get currently focused indices
active_window_list_index = self.window_list_index(active_window_list)
if active_window_list_index is None:
return
active_pane_index = active_window_list.pane_index(active_pane)
increment = -1 if reverse_order else 1
# Assume we can switch to the next pane in the current window_list
next_pane_index = active_pane_index + increment
# Case 1: next_pane_index does not exist in this window list.
# Action: Switch to the first pane of the next window list.
if next_pane_index >= pane_count or next_pane_index < 0:
# Get the next window_list
next_window_list_index = ((active_window_list_index + increment) %
window_list_count)
next_window_list = self.window_lists[next_window_list_index]
# If tabbed window mode is enabled, switch to the first tab.
if next_window_list.display_mode == DisplayMode.TABBED:
if reverse_order:
next_window_list.switch_to_tab(
len(next_window_list.active_panes) - 1)
else:
next_window_list.switch_to_tab(0)
return
# Otherwise switch to the first visible window pane.
pane_list = next_window_list.active_panes
if reverse_order:
pane_list = reversed(pane_list)
for pane in pane_list:
if pane.show_pane:
self.application.focus_on_container(pane)
return
# Case 2: next_pane_index does exist and display mode is tabs.
# Action: Switch to the next tab of the current window list.
if active_window_list.display_mode == DisplayMode.TABBED:
active_window_list.switch_to_tab(next_pane_index)
return
# Case 3: next_pane_index does exist and display mode is stacked.
# Action: Switch to the next visible window pane.
index_range = range(1, pane_count)
if reverse_order:
index_range = range(pane_count - 1, 0, -1)
for i in index_range:
next_pane_index = (active_pane_index + i) % pane_count
next_pane = active_window_list.active_panes[next_pane_index]
if next_pane.show_pane:
self.application.focus_on_container(next_pane)
return
return
def move_pane_left(self):
active_window_list, active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
window_list_index = self.window_list_index(active_window_list)
# Move left should pick the previous window_list
target_window_list_index = window_list_index - 1
# Check if a new WindowList should be created on the left
if target_window_list_index == -1:
# Add the new WindowList
target_window_list = WindowList(self)
self.window_lists.appendleft(target_window_list)
self.reset_split_sizes()
# New index is 0
target_window_list_index = 0
# Get the destination window_list
target_window_list = self.window_lists[target_window_list_index]
# Move the pane
active_window_list.remove_pane_no_checks(active_pane)
target_window_list.add_pane(active_pane, add_at_beginning=True)
target_window_list.reset_pane_sizes()
self.delete_empty_window_lists()
def move_pane_right(self):
active_window_list, active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
window_list_index = self.window_list_index(active_window_list)
# Move right should pick the next window_list
target_window_list_index = window_list_index + 1
# Check if a new WindowList should be created
if target_window_list_index == len(self.window_lists):
# Add a new WindowList
target_window_list = WindowList(self)
self.window_lists.append(target_window_list)
self.reset_split_sizes()
# Get the destination window_list
target_window_list = self.window_lists[target_window_list_index]
# Move the pane
active_window_list.remove_pane_no_checks(active_pane)
target_window_list.add_pane(active_pane, add_at_beginning=True)
target_window_list.reset_pane_sizes()
self.delete_empty_window_lists()
def move_pane_up(self):
active_window_list, _active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
active_window_list.move_pane_up()
def move_pane_down(self):
active_window_list, _active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
active_window_list.move_pane_down()
def shrink_pane(self):
active_window_list, _active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
active_window_list.shrink_pane()
def enlarge_pane(self):
active_window_list, _active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
active_window_list.enlarge_pane()
def shrink_split(self):
if len(self.window_lists) < 2:
return
active_window_list, _active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
self.adjust_split_size(active_window_list, -_WINDOW_SPLIT_ADJUST)
def enlarge_split(self):
active_window_list, _active_pane = (
self._get_active_window_list_and_pane())
if not active_window_list:
return
self.adjust_split_size(active_window_list, _WINDOW_SPLIT_ADJUST)
def balance_window_sizes(self):
"""Reset all splits and pane sizes."""
self.reset_pane_sizes()
self.reset_split_sizes()
def reset_split_sizes(self):
"""Reset all active pane width and height to defaults"""
available_height = self.current_window_manager_height
available_width = self.current_window_manager_width
old_heights = [w.height.preferred for w in self.window_lists]
old_widths = [w.width.preferred for w in self.window_lists]
new_heights = [int(available_height / len(old_heights))
] * len(old_heights)
new_widths = [int(available_width / len(old_widths))] * len(old_widths)
self._set_window_list_sizes(new_heights, new_widths)
def _get_next_window_list_for_resizing(
self, window_list: WindowList) -> Optional[WindowList]:
window_list_index = self.window_list_index(window_list)
if window_list_index is None:
return None
next_window_list_index = ((window_list_index + 1) %
len(self.window_lists))
# Use the previous window if we are on the last split
if window_list_index == len(self.window_lists) - 1:
next_window_list_index = window_list_index - 1
next_window_list = self.window_lists[next_window_list_index]
return next_window_list
def adjust_split_size(self,
window_list: WindowList,
diff: int = _WINDOW_SPLIT_ADJUST) -> None:
"""Increase or decrease a given window_list's vertical split width."""
# No need to resize if only one split.
if len(self.window_lists) < 2:
return
# Get the next split to subtract from.
next_window_list = self._get_next_window_list_for_resizing(window_list)
if not next_window_list:
return
if self.vertical_window_list_spliting():
# Get current width
old_value = window_list.width.preferred
next_old_value = next_window_list.width.preferred # type: ignore
else:
# Get current height
old_value = window_list.height.preferred
next_old_value = next_window_list.height.preferred # type: ignore
# Add to the current split
new_value = old_value + diff
if new_value <= 0:
new_value = old_value
# Subtract from the next split
next_new_value = next_old_value - diff
if next_new_value <= 0:
next_new_value = next_old_value
# If new height is too small or no change, make no adjustments.
if new_value < 3 or next_new_value < 3 or old_value == new_value:
return
if self.vertical_window_list_spliting():
# Set new width
window_list.width.preferred = new_value
next_window_list.width.preferred = next_new_value # type: ignore
else:
# Set new height
window_list.height.preferred = new_value
next_window_list.height.preferred = next_new_value # type: ignore
window_list.rebalance_window_heights()
next_window_list.rebalance_window_heights()
def toggle_pane(self, pane):
"""Toggle a pane on or off."""
window_list, _pane_index = (
self._find_window_list_and_pane_index(pane))
# Don't hide the window if tabbed mode is enabled. Switching to a
# separate tab is preffered.
if window_list.display_mode == DisplayMode.TABBED:
return
pane.show_pane = not pane.show_pane
self.update_root_container_body()
self.application.update_menu_items()
# Set focus to the top level menu. This has the effect of keeping the
# menu open if it's already open.
self.application.focus_main_menu()
def focus_first_visible_pane(self):
"""Focus on the first visible container."""
for pane in self.active_panes():
if pane.show_pane:
self.application.application.layout.focus(pane)
break
def check_for_all_hidden_panes_and_unhide(self) -> None:
"""Scan for window_lists containing only hidden panes."""
for window_list in self.window_lists:
all_hidden = all(not pane.show_pane
for pane in window_list.active_panes)
if all_hidden:
# Unhide the first pane
self.toggle_pane(window_list.active_panes[0])
def add_pane_no_checks(self, pane: Any):
self.window_lists[0].add_pane_no_checks(pane)
def add_pane(self, pane: Any):
self.window_lists[0].add_pane(pane, add_at_beginning=True)
def first_window_list(self):
return self.window_lists[0]
def active_panes(self):
"""Return all active panes from all window lists."""
return chain.from_iterable(
map(operator.attrgetter('active_panes'), self.window_lists))
def start_resize_pane(self, pane):
window_list, pane_index = self._find_window_list_and_pane_index(pane)
window_list.start_resize(pane, pane_index)
def mouse_resize(self, xpos, ypos):
if self.resize_target_window_list_index is None:
return
target_window_list = self.window_lists[
self.resize_target_window_list_index]
diff = ypos - self.resize_current_row
if self.vertical_window_list_spliting():
diff = xpos - self.resize_current_column
if diff == 0:
return
self.adjust_split_size(target_window_list, diff)
self._resize_update_current_row_column()
self.application.redraw_ui()
def mouse_handler(self, mouse_event: MouseEvent):
"""MouseHandler used when resize_mode == True."""
mouse_position = mouse_event.position
if (mouse_event.event_type == MouseEventType.MOUSE_MOVE
and mouse_event.button == MouseButton.LEFT):
self.mouse_resize(mouse_position.x, mouse_position.y)
elif mouse_event.event_type == MouseEventType.MOUSE_UP:
self.stop_resize()
# Mouse event handled, return None.
return None
else:
self.stop_resize()
# Mouse event not handled, return NotImplemented.
return NotImplemented
def _calculate_actual_widths(self) -> List[int]:
widths = [w.width.preferred for w in self.window_lists]
available_width = self.current_window_manager_width
# Subtract 1 for each separator
available_width -= len(self.window_lists) - 1
remaining_rows = available_width - sum(widths)
window_list_index = 0
# Distribute remaining unaccounted columns to each window in turn.
while remaining_rows > 0:
widths[window_list_index] += 1
remaining_rows -= 1
window_list_index = (window_list_index + 1) % len(widths)
return widths
def _calculate_actual_heights(self) -> List[int]:
heights = [w.height.preferred for w in self.window_lists]
available_height = self.current_window_manager_height
# Subtract 1 for each vertical separator
available_height -= len(self.window_lists) - 1
remaining_rows = available_height - sum(heights)
window_list_index = 0
# Distribute remaining unaccounted columns to each window in turn.
while remaining_rows > 0:
heights[window_list_index] += 1
remaining_rows -= 1
window_list_index = (window_list_index + 1) % len(heights)
return heights
def _resize_update_current_row_column(self) -> None:
if self.resize_target_window_list_index is None:
return
widths = self._calculate_actual_widths()
heights = self._calculate_actual_heights()
start_column = 0
start_row = 0
# Find the starting column
for i in range(self.resize_target_window_list_index + 1):
# If we are past the target window_list, exit the loop.
if i > self.resize_target_window_list_index:
break
start_column += widths[i]
start_row += heights[i]
if i < self.resize_target_window_list_index - 1:
start_column += 1
start_row += 1
self.resize_current_column = start_column
self.resize_current_row = start_row
def start_resize(self, window_list):
# Check the target window_list isn't the last one.
if window_list == self.window_lists[-1]:
return
list_index = self.window_list_index(window_list)
if list_index is None:
return
self.resize_mode = True
self.resize_target_window_list = window_list
self.resize_target_window_list_index = list_index
self._resize_update_current_row_column()
def stop_resize(self):
self.resize_mode = False
self.resize_target_window_list = None
self.resize_target_window_list_index = None
self.resize_current_row = 0
self.resize_current_column = 0
def _find_window_list_and_pane_index(self, pane: Any):
pane_index = None
parent_window_list = None
for window_list in self.window_lists:
pane_index = window_list.pane_index(pane)
if pane_index is not None:
parent_window_list = window_list
break
return parent_window_list, pane_index
def remove_pane(self, existing_pane: Any):
window_list, _pane_index = (
self._find_window_list_and_pane_index(existing_pane))
if window_list:
window_list.remove_pane(existing_pane)
# Reset focus if this list is empty
if len(window_list.active_panes) == 0:
self.application.focus_main_menu()
def reset_pane_sizes(self):
for window_list in self.window_lists:
window_list.reset_pane_sizes()
def _remove_panes_from_layout(
self, pane_titles: Iterable[str]) -> Dict[str, Any]:
# Gather pane objects and remove them from the window layout.
collected_panes = {}
for window_list in self.window_lists:
# Make a copy of active_panes to prevent mutating the while
# iterating.
for pane in copy.copy(window_list.active_panes):
if pane.pane_title() in pane_titles:
collected_panes[pane.pane_title()] = (
window_list.remove_pane_no_checks(pane))
return collected_panes
def _set_pane_options(self, pane, options: dict) -> None: # pylint: disable=no-self-use
if options.get('hidden', False):
# Hide this pane
pane.show_pane = False
if options.get('height', False):
# Apply new height
new_height = options['height']
assert isinstance(new_height, int)
pane.height.preferred = new_height
def _set_window_list_display_modes(self, prefs: ConsolePrefs) -> None:
# Set column display modes
for column_index, column_type in enumerate(prefs.window_column_modes):
mode = DisplayMode.STACK
if 'tabbed' in column_type:
mode = DisplayMode.TABBED
self.window_lists[column_index].set_display_mode(mode)
def _create_new_log_pane_with_loggers(self, window_title, window_options,
existing_pane_titles) -> LogPane:
if 'loggers' not in window_options:
error_unknown_window(window_title, existing_pane_titles)
new_pane = LogPane(application=self.application,
pane_title=window_title)
# Add logger handlers
for logger_name, logger_options in window_options.get('loggers',
{}).items():
log_level_name = logger_options.get('level', None)
new_pane.add_log_handler(logger_name, level_name=log_level_name)
return new_pane
# TODO(tonymd): Split this large function up.
def apply_config(self, prefs: ConsolePrefs) -> None:
"""Apply window configuration from loaded ConsolePrefs."""
if not prefs.windows:
return
unique_titles = prefs.unique_window_titles
collected_panes = self._remove_panes_from_layout(unique_titles)
existing_pane_titles = [
p.pane_title() for p in collected_panes.values()
if isinstance(p, LogPane)
]
# Keep track of original non-duplicated pane titles
already_added_panes = []
for column_index, column in enumerate(prefs.windows.items()): # pylint: disable=too-many-nested-blocks
_column_type, windows = column
# Add a new window_list if needed
if column_index >= len(self.window_lists):
self.window_lists.append(WindowList(self))
# Set column display mode to stacked by default.
self.window_lists[column_index].display_mode = DisplayMode.STACK
# Add windows to the this column (window_list)
for window_title, window_dict in windows.items():
window_options = window_dict if window_dict else {}
new_pane = None
desired_window_title = window_title
# Check for duplicate_of: Title value
window_title = window_options.get('duplicate_of', window_title)
# Check if this pane is brand new, ready to be added, or should
# be duplicated.
if (window_title not in already_added_panes
and window_title not in collected_panes):
# New pane entirely
new_pane = self._create_new_log_pane_with_loggers(
window_title, window_options, existing_pane_titles)
elif window_title not in already_added_panes:
# First time adding this pane
already_added_panes.append(window_title)
new_pane = collected_panes[window_title]
elif window_title in collected_panes:
# Pane added once, duplicate it
new_pane = collected_panes[window_title].create_duplicate()
# Rename this duplicate pane
assert isinstance(new_pane, LogPane)
new_pane.set_pane_title(desired_window_title)
if new_pane:
# Set window size and visibility
self._set_pane_options(new_pane, window_options)
# Add the new pane
self.window_lists[column_index].add_pane_no_checks(
new_pane)
# Apply log filters
if isinstance(new_pane, LogPane):
new_pane.apply_filters_from_config(window_options)
# Update column display modes.
self._set_window_list_display_modes(prefs)
# Check for columns where all panes are hidden and unhide at least one.
self.check_for_all_hidden_panes_and_unhide()
# Update prompt_toolkit containers.
self.update_root_container_body()
self.application.update_menu_items()
# Focus on the first visible pane.
self.focus_first_visible_pane()
def create_window_menu(self):
"""Build the [Window] menu for the current set of window lists."""
root_menu_items = []
for window_list_index, window_list in enumerate(self.window_lists):
menu_items = []
menu_items.append(
MenuItem(
'Column {index} View Modes'.format(
index=window_list_index + 1),
children=[
MenuItem(
'{check} {display_mode} Windows'.format(
display_mode=display_mode.value,
check=pw_console.widgets.checkbox.
to_checkbox_text(
window_list.display_mode == display_mode,
end='',
)),
handler=functools.partial(
window_list.set_display_mode, display_mode),
) for display_mode in DisplayMode
],
))
menu_items.extend(
MenuItem(
'{index}: {title}'.format(
index=pane_index + 1,
title=pane.menu_title(),
),
children=[
MenuItem(
'{check} Show/Hide Window'.format(
check=pw_console.widgets.checkbox.
to_checkbox_text(pane.show_pane, end='')),
handler=functools.partial(self.toggle_pane, pane),
),
] + [
MenuItem(text,
handler=functools.partial(
self.application.run_pane_menu_option,
handler))
for text, handler in pane.get_all_menu_options()
],
) for pane_index, pane in enumerate(window_list.active_panes))
if window_list_index + 1 < len(self.window_lists):
menu_items.append(MenuItem('-'))
root_menu_items.extend(menu_items)
menu = MenuItem(
'[Windows]',
children=root_menu_items,
)
return [menu]