leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

shell: Fix missing titlebars

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-03-07 22:20:44 +01:00
parent 659933b039
commit 5d173a46a6
11 changed files with 208 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

29
src/backend/kms/mod.rs
View file

@ -1,7 +1,9 @@
// SPDX-License-Identifier: GPL-3.0-only
#[cfg(feature = "debug")]
use crate::backend::render::element::AsGlowRenderer;
use crate::{
backend::render::{element::CosmicElement, workspace_elements, CLEAR_COLOR},
backend::render::{workspace_elements, CLEAR_COLOR},
config::OutputConfig,
shell::Shell,
state::{BackendData, ClientState, Common, Data, Fps},
@ -944,15 +946,6 @@ impl Surface {
return Ok(());
}
self.fps.start();
#[cfg(feature = "debug")]
if let Some(rd) = self.fps.rd.as_mut() {
rd.start_frame_capture(
renderer.glow_renderer().egl_context().get_context_handle(),
std::ptr::null(),
);
}
let compositor = self.surface.as_mut().unwrap();
let (render_node, mut renderer) = match render_node {
Some((render_node, allocator)) => (
@ -963,8 +956,17 @@ impl Surface {
None => (target_node, api.single_renderer(&target_node).unwrap()),
};
self.fps.start();
#[cfg(feature = "debug")]
if let Some(rd) = self.fps.rd.as_mut() {
rd.start_frame_capture(
renderer.glow_renderer().egl_context().get_context_handle(),
std::ptr::null(),
);
}
let handle = state.shell.workspaces.active(&self.output).handle;
let elements: Vec<CosmicElement<GlMultiRenderer<'_, '_>>> = workspace_elements(
let elements = workspace_elements(
Some(&render_node),
&mut renderer,
state,
@ -973,7 +975,10 @@ impl Surface {
CursorMode::All,
&mut Some(&mut self.fps),
false,
)?;
)
.map_err(|err| {
anyhow::format_err!("Failed to accumulate elements for rendering: {:?}", err)
})?;
self.fps.elements();
let res = compositor.render_frame::<_, _, Gles2Renderbuffer>(

17
src/backend/render/mod.rs
View file

@ -12,7 +12,8 @@ use crate::{
};
use crate::{
shell::{
layout::floating::SeatMoveGrabState, CosmicMappedRenderElement, WorkspaceRenderElement,
element::window::CosmicWindowRenderElement, layout::floating::SeatMoveGrabState,
CosmicMappedRenderElement,
},
state::{Common, Fps},
utils::prelude::SeatExt,
@ -169,6 +170,7 @@ where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
E: From<CursorRenderElement<R>> + From<CosmicMappedRenderElement<R>>,
{
#[cfg(feature = "debug")]
@ -222,7 +224,7 @@ where
elements
}
pub fn workspace_elements<R, E>(
pub fn workspace_elements<R>(
_gpu: Option<&DrmNode>,
renderer: &mut R,
state: &mut Common,
@ -231,19 +233,18 @@ pub fn workspace_elements<R, E>(
cursor_mode: CursorMode,
_fps: &mut Option<&mut Fps>,
exclude_workspace_overview: bool,
) -> Result<Vec<E>, OutputNoMode>
) -> Result<Vec<CosmicElement<R>>, RenderError<R>>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
CosmicMappedRenderElement<R>: RenderElement<R>,
E: From<CursorRenderElement<R>>
+ From<CosmicMappedRenderElement<R>>
+ From<WorkspaceRenderElement<R>>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
#[cfg(feature = "debug")]
puffin::profile_function!();
let mut elements: Vec<E> = cursor_elements(renderer, state, output, cursor_mode);
let mut elements = cursor_elements(renderer, state, output, cursor_mode);
#[cfg(feature = "debug")]
{
@ -336,6 +337,7 @@ where
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
Source: Clone,
{
let handle = state.shell.workspaces.active(output).handle;
@ -385,6 +387,7 @@ where
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
Source: Clone,
{
#[cfg(feature = "debug")]

2
src/shell/element/mod.rs
View file

@ -50,6 +50,7 @@ pub mod stack;
pub use self::stack::CosmicStack;
pub mod window;
pub use self::window::CosmicWindow;
use self::window::CosmicWindowRenderElement;
#[cfg(feature = "debug")]
use egui::plot::{Corner, Legend, Plot, PlotPoints, Polygon};
@ -886,6 +887,7 @@ where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
type RenderElement = CosmicMappedRenderElement<R>;
fn render_elements<C: From<Self::RenderElement>>(

178
src/shell/element/window.rs
View file

@ -1,4 +1,8 @@
use crate::{
backend::render::{
element::{AsGlowFrame, AsGlowRenderer},
GlMultiFrame, GlMultiRenderer,
},
shell::Shell,
state::State,
utils::{
@ -8,7 +12,7 @@ use crate::{
wayland::handlers::screencopy::ScreencopySessions,
};
use calloop::LoopHandle;
use cosmic::{iced_native::Command, Element};
use cosmic::iced_native::Command;
use cosmic_protocols::screencopy::v1::server::zcosmic_screencopy_session_v1::InputType;
use iced_softbuffer::native::raqote::{DrawOptions, DrawTarget, PathBuilder, SolidSource, Source};
use smithay::{
@ -17,8 +21,11 @@ use smithay::{
renderer::{
element::{
memory::MemoryRenderBufferRenderElement, surface::WaylandSurfaceRenderElement,
AsRenderElements,
AsRenderElements, Element, Id, RenderElement,
},
glow::GlowRenderer,
multigpu::Error as MultiError,
utils::CommitCounter,
ImportAll, ImportMem, Renderer,
},
},
@ -29,8 +36,7 @@ use smithay::{
Seat,
},
output::Output,
render_elements,
utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size},
utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size, Transform},
wayland::seat::WaylandFocus,
};
use std::{
@ -240,7 +246,7 @@ impl Program for CosmicWindowInternal {
target.pop_clip();
}
fn view(&self) -> Element<'_, Self::Message> {
fn view(&self) -> cosmic::Element<'_, Self::Message> {
cosmic::widget::header_bar()
.title(self.last_title.lock().unwrap().clone())
.on_drag(Message::DragStart)
@ -536,16 +542,162 @@ impl PointerTarget<State> for CosmicWindow {
}
}
render_elements! {
pub CosmicWindowRenderElement<R> where R: ImportAll + ImportMem;
Header=MemoryRenderBufferRenderElement<R>,
Window=WaylandSurfaceRenderElement<R>,
pub enum CosmicWindowRenderElement<R>
where
R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
<R as Renderer>::TextureId: 'static,
{
Header(MemoryRenderBufferRenderElement<GlowRenderer>),
Window(WaylandSurfaceRenderElement<R>),
}
impl<R> From<WaylandSurfaceRenderElement<R>> for CosmicWindowRenderElement<R>
where
R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
<R as Renderer>::TextureId: 'static,
{
fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
CosmicWindowRenderElement::Window(elem)
}
}
impl<R> From<MemoryRenderBufferRenderElement<GlowRenderer>> for CosmicWindowRenderElement<R>
where
R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
<R as Renderer>::TextureId: 'static,
{
fn from(elem: MemoryRenderBufferRenderElement<GlowRenderer>) -> Self {
CosmicWindowRenderElement::Header(elem)
}
}
impl<R> Element for CosmicWindowRenderElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: 'static,
{
fn id(&self) -> &Id {
match self {
CosmicWindowRenderElement::Header(h) => h.id(),
CosmicWindowRenderElement::Window(w) => w.id(),
}
}
fn current_commit(&self) -> CommitCounter {
match self {
CosmicWindowRenderElement::Header(h) => h.current_commit(),
CosmicWindowRenderElement::Window(w) => w.current_commit(),
}
}
fn src(&self) -> Rectangle<f64, smithay::utils::Buffer> {
match self {
CosmicWindowRenderElement::Header(h) => h.src(),
CosmicWindowRenderElement::Window(w) => w.src(),
}
}
fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
match self {
CosmicWindowRenderElement::Header(h) => h.geometry(scale),
CosmicWindowRenderElement::Window(w) => w.geometry(scale),
}
}
fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
match self {
CosmicWindowRenderElement::Header(h) => h.location(scale),
CosmicWindowRenderElement::Window(w) => w.location(scale),
}
}
fn transform(&self) -> Transform {
match self {
CosmicWindowRenderElement::Header(h) => h.transform(),
CosmicWindowRenderElement::Window(w) => w.transform(),
}
}
fn damage_since(
&self,
scale: Scale<f64>,
commit: Option<CommitCounter>,
) -> Vec<Rectangle<i32, Physical>> {
match self {
CosmicWindowRenderElement::Header(h) => h.damage_since(scale, commit),
CosmicWindowRenderElement::Window(w) => w.damage_since(scale, commit),
}
}
fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
match self {
CosmicWindowRenderElement::Header(h) => h.opaque_regions(scale),
CosmicWindowRenderElement::Window(w) => w.opaque_regions(scale),
}
}
}
impl RenderElement<GlowRenderer> for CosmicWindowRenderElement<GlowRenderer> {
fn draw<'a>(
&self,
frame: &mut <GlowRenderer as Renderer>::Frame<'a>,
src: Rectangle<f64, smithay::utils::Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicWindowRenderElement::Header(h) => h.draw(frame, src, dst, damage),
CosmicWindowRenderElement::Window(w) => w.draw(frame, src, dst, damage),
}
}
fn underlying_storage(
&self,
renderer: &mut GlowRenderer,
) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
match self {
CosmicWindowRenderElement::Header(h) => h.underlying_storage(renderer),
CosmicWindowRenderElement::Window(w) => w.underlying_storage(renderer),
}
}
}
impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
for CosmicWindowRenderElement<GlMultiRenderer<'a, 'b>>
{
fn draw<'c>(
&self,
frame: &mut GlMultiFrame<'a, 'b, 'c>,
src: Rectangle<f64, smithay::utils::Buffer>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
) -> Result<(), <GlMultiRenderer<'a, 'b> as Renderer>::Error> {
match self {
CosmicWindowRenderElement::Header(h) => h
.draw(frame.glow_frame_mut(), src, dst, damage)
.map_err(|err| MultiError::Render(err)),
CosmicWindowRenderElement::Window(w) => w.draw(frame, src, dst, damage),
}
}
fn underlying_storage(
&self,
renderer: &mut GlMultiRenderer<'a, 'b>,
) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
match self {
CosmicWindowRenderElement::Header(h) => {
h.underlying_storage(renderer.glow_renderer_mut())
}
CosmicWindowRenderElement::Window(w) => w.underlying_storage(renderer),
}
}
}
impl<R> AsRenderElements<R> for CosmicWindow
where
R: Renderer + ImportAll + ImportMem,
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
type RenderElement = CosmicWindowRenderElement<R>;
fn render_elements<C: From<Self::RenderElement>>(
@ -568,9 +720,11 @@ where
)
});
if has_ssd {
elements.extend(AsRenderElements::<R>::render_elements::<
elements.extend(AsRenderElements::<GlowRenderer>::render_elements::<
CosmicWindowRenderElement<R>,
>(&self.0, renderer, location, scale))
>(
&self.0, renderer.glow_renderer_mut(), location, scale
))
}
elements.into_iter().map(C::from).collect()

3
src/shell/layout/floating/grabs/moving.rs
View file

@ -3,7 +3,7 @@
use crate::{
backend::render::{element::AsGlowRenderer, IndicatorShader},
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
element::{window::CosmicWindowRenderElement, CosmicMapped, CosmicMappedRenderElement},
focus::target::{KeyboardFocusTarget, PointerFocusTarget},
},
utils::prelude::*,
@ -42,6 +42,7 @@ impl MoveGrabState {
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
I: From<CosmicMappedRenderElement<R>>,
{
#[cfg(feature = "debug")]

3
src/shell/layout/floating/mod.rs
View file

@ -15,7 +15,7 @@ use std::collections::HashMap;
use crate::{
backend::render::{element::AsGlowRenderer, IndicatorShader},
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
element::{window::CosmicWindowRenderElement, CosmicMapped, CosmicMappedRenderElement},
grabs::ResizeEdge,
CosmicSurface,
},
@ -354,6 +354,7 @@ impl FloatingLayout {
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
#[cfg(feature = "debug")]
puffin::profile_function!();

3
src/shell/layout/tiling/mod.rs
View file

@ -3,7 +3,7 @@
use crate::{
backend::render::{element::AsGlowRenderer, IndicatorShader},
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
element::{window::CosmicWindowRenderElement, CosmicMapped, CosmicMappedRenderElement},
focus::{
target::{KeyboardFocusTarget, WindowGroup},
FocusDirection,
@ -1311,6 +1311,7 @@ impl TilingLayout {
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
#[cfg(feature = "debug")]
puffin::profile_function!();

2
src/shell/mod.rs
View file

@ -40,7 +40,7 @@ use crate::{
},
};
mod element;
pub mod element;
pub mod focus;
pub mod grabs;
pub mod layout;

3
src/shell/workspace.rs
View file

@ -35,7 +35,7 @@ use std::collections::HashMap;
use tracing::warn;
use super::{
element::CosmicMapped,
element::{window::CosmicWindowRenderElement, CosmicMapped},
focus::{FocusStack, FocusStackMut},
grabs::{ResizeEdge, ResizeGrab},
CosmicMappedRenderElement, CosmicSurface,
@ -445,6 +445,7 @@ impl Workspace {
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
#[cfg(feature = "debug")]
puffin::profile_function!();

2
src/utils/iced.rs
View file

@ -230,10 +230,10 @@ impl<P: Program + Send + 'static> IcedElement<P> {
pub fn force_update(&self) {
let mut internal = self.0.lock().unwrap();
internal.update(true);
for (_buffer, ref mut needs_redraw) in internal.buffers.values_mut() {
*needs_redraw = true;
}
internal.update(true);
}
}

4
src/wayland/handlers/screencopy.rs
View file

@ -47,7 +47,7 @@ use crate::{
element::{AsGlowRenderer, CosmicElement},
render_output, render_workspace, CursorMode, CLEAR_COLOR,
},
shell::{CosmicMappedRenderElement, CosmicSurface},
shell::{element::window::CosmicWindowRenderElement, CosmicMappedRenderElement, CosmicSurface},
state::{BackendData, ClientState, Common, Data, State},
utils::prelude::OutputExt,
wayland::protocols::{
@ -627,6 +627,7 @@ pub fn render_output_to_buffer(
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
let cursor_mode = match session.cursor_mode() {
ScreencopyCursorMode::Embedded => CursorMode::All,
@ -756,6 +757,7 @@ pub fn render_workspace_to_buffer(
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
let cursor_mode = match session.cursor_mode() {
ScreencopyCursorMode::Embedded => CursorMode::All,