def _render_surface(self, surface: Surface, sx: int, sy: int,
rdata: Tuple) -> None:
texture = surface.get_texture()
if texture is None:
return
now, window, wx, wy, opacity, scale = rdata
x = (wx + sx) * scale
y = (wy + sy) * scale
width = surface.current.width * scale
height = surface.current.height * scale
transform_matrix = self.transform_matrix
if window.borderwidth:
bw = int(window.borderwidth * scale)
if surface == window.surface.surface:
outer_w = width + bw * 2
outer_h = height + bw * 2
num = len(window.bordercolor)
bws = [bw // num] * num
for i in range(bw % num):
bws[i] += 1
coord = 0
for i, bc in enumerate(window.bordercolor):
border = Box(
int(x + coord),
int(y + coord),
int(outer_w - coord * 2),
int(bws[i]),
)
self.renderer.render_rect(border, bc,
transform_matrix) # Top border
border.y = int(y + outer_h - bws[i] - coord)
self.renderer.render_rect(
border, bc, transform_matrix) # Bottom border
border.y = int(y + coord)
border.width = int(bws[i])
border.height = int(outer_h - coord * 2)
self.renderer.render_rect(border, bc,
transform_matrix) # Left border
border.x = int(x + outer_w - bws[i] - coord)
self.renderer.render_rect(border, bc,
transform_matrix) # Right border
coord += bws[i]
x += bw
y += bw
box = Box(
int(x),
int(y),
int(width),
int(height),
)
inverse = wlrOutput.transform_invert(surface.current.transform)
matrix = Matrix.project_box(box, inverse, 0, transform_matrix)
self.renderer.render_texture_with_matrix(texture, matrix, opacity)
surface.send_frame_done(now)
def _render_surface(
self, surface: Surface, sx: int, sy: int, data: Tuple[Output, View, Timespec]
) -> None:
output, view, now = data
texture = surface.get_texture()
if texture is None:
return
ox, oy = self._output_layout.output_coords(output)
ox += view.x + sx
oy += view.y + sy
box = Box(
int(ox * output.scale),
int(oy * output.scale),
int(surface.current.width * output.scale),
int(surface.current.height * output.scale),
)
transform = surface.current.transform
inverse = Output.transform_invert(transform)
matrix = Matrix.project_box(box, inverse, 0, output.transform_matrix)
self._renderer.render_texture_with_matrix(texture, matrix, 1)
surface.send_frame_done(now)
def __init__(self, core: Core, wlr_output: wlrOutput):
self.core = core
self.renderer = core.renderer
self.wlr_output = wlr_output
wlr_output.data = self
self.output_layout = self.core.output_layout
self._damage: OutputDamage = OutputDamage(wlr_output)
self.wallpaper = None
self.transform_matrix = wlr_output.transform_matrix
self.x, self.y = self.output_layout.output_coords(wlr_output)
self.add_listener(wlr_output.destroy_event, self._on_destroy)
self.add_listener(self._damage.frame_event, self._on_frame)
# The layers enum indexes into this list to get a list of surfaces
self.layers: List[List[Static]] = [
[] for _ in range(len(LayerShellV1Layer))
]
# This is run during tests, when we want to fix the output's geometry
if wlr_output.is_headless and "PYTEST_CURRENT_TEST" in os.environ:
assert len(core.outputs) < 2, "This should not be reached"
if not core.outputs:
# First test output
wlr_output.set_custom_mode(800, 600, 0)
else:
# Secound test output
wlr_output.set_custom_mode(640, 480, 0)
wlr_output.commit()
def server_new_output(self, listener, output: Output) -> None:
output.init_render(self._allocator, self._renderer)
if output.modes != []:
mode = output.preferred_mode()
if mode is None:
logger.error("Got no output mode")
return
output.set_mode(mode)
output.enable()
output.commit()
self.outputs.append(output)
self._output_layout.add_auto(output)
output.frame_event.add(Listener(self.output_frame))
def _render_surface(self, surface: Surface, sx: int, sy: int,
rdata: Tuple) -> None:
texture = surface.get_texture()
if texture is None:
return
now, window, wx, wy, opacity, scale = rdata
x = (wx + sx) * scale
y = (wy + sy) * scale
width = surface.current.width * scale
height = surface.current.height * scale
transform_matrix = self.transform_matrix
if window.borderwidth:
bw = window.borderwidth * scale
if surface == window.surface.surface:
bc = window.bordercolor
border = Box(
int(x),
int(y),
int(width + bw * 2),
int(bw),
)
x += bw
y += bw
self.renderer.render_rect(border, bc,
transform_matrix) # Top border
border.y = int(y + height)
self.renderer.render_rect(border, bc,
transform_matrix) # Bottom border
border.y = int(y - bw)
border.width = int(bw)
border.height = int(height + bw * 2)
self.renderer.render_rect(border, bc,
transform_matrix) # Left border
border.x = int(x + width)
self.renderer.render_rect(border, bc,
transform_matrix) # Right border
else:
x += bw
y += bw
box = Box(
int(x),
int(y),
int(width),
int(height),
)
inverse = wlrOutput.transform_invert(surface.current.transform)
matrix = Matrix.project_box(box, inverse, 0, transform_matrix)
self.renderer.render_texture_with_matrix(texture, matrix, opacity)
surface.send_frame_done(now)
def _on_new_output(self, _listener, wlr_output: wlrOutput):
logger.debug("Signal: backend new_output_event")
if wlr_output.modes != []:
mode = wlr_output.preferred_mode()
if mode is None:
logger.error("New output has no output mode")
return
wlr_output.set_mode(mode)
wlr_output.enable()
wlr_output.commit()
self.outputs.append(output.Output(self, wlr_output))
self.output_layout.add_auto(wlr_output)
def _on_new_output(self, _listener, wlr_output: wlrOutput):
logger.debug("Signal: backend new_output_event")
wlr_output.init_render(self._allocator, self.renderer)
if wlr_output.modes != []:
mode = wlr_output.preferred_mode()
if mode is None:
logger.error("New output has no output mode")
return
wlr_output.set_mode(mode)
wlr_output.enable()
wlr_output.commit()
self.outputs.append(Output(self, wlr_output))
# Put new output at far right
layout_geo = self.output_layout.get_box()
self.output_layout.add(wlr_output, layout_geo.width, 0)
if not self._current_output:
self._current_output = self.outputs[0]
def __init__(self, core: Core, wlr_output: wlrOutput):
self.core = core
self.renderer = core.renderer
self.wlr_output = wlr_output
wlr_output.data = self
self.output_layout = self.core.output_layout
self.damage: OutputDamage = OutputDamage(wlr_output)
self.wallpaper = None
self.transform_matrix = wlr_output.transform_matrix
self.x, self.y = self.output_layout.output_coords(wlr_output)
self.add_listener(wlr_output.destroy_event, self._on_destroy)
self.add_listener(self.damage.frame_event, self._on_frame)
# The layers enum indexes into this list to get a list of surfaces
self.layers: List[List[Static]] = [[]] * len(LayerShellV1Layer)
def _render_dnd_icon(
self, dnd: Dnd, now: Timespec, scale: float, transform_matrix: Matrix
) -> None:
"""Render the drag-n-drop icon if there is one."""
icon = dnd.wlr_drag.icon
if icon.mapped:
texture = icon.surface.get_texture()
if texture:
box = Box(
int((dnd.x - self.x) * scale),
int((dnd.y - self.y) * scale),
int(icon.surface.current.width * scale),
int(icon.surface.current.height * scale),
)
inverse = wlrOutput.transform_invert(icon.surface.current.transform)
matrix = Matrix.project_box(box, inverse, 0, transform_matrix)
self.renderer.render_texture_with_matrix(texture, matrix, 1)
icon.surface.send_frame_done(now)
def server_new_output(self, listener, output: Output) -> None:
if output.modes != []:
mode = output.preferred_mode()
if mode is None:
logger.error("Got no output mode")
return
output.set_mode(mode)
output.enable()
if not output.commit():
logger.error("Unable to commit output")
return
self.outputs.append(output)
self._output_layout.add_auto(output)
output.frame_event.add(Listener(self.output_frame))
