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

chore: theme-v2 libcosmic update

Browse source
This commit is contained in:
Victoria Brekenfeld 2026-04-17 11:48:11 +02:00 • committed by Victoria Brekenfeld
parent 667414bd92
commit 55d57ddba2
19 changed files with 609 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -726,7 +726,7 @@ where
return Ok(Vec::new());
}
let theme = shell_ref.theme().clone();
let blur_strength = 9; // TODO
let blur_strength = (theme.cosmic().frosted as u8 + 1) as usize;
let scale = output.current_scale().fractional_scale();
// we don't want to hold a shell lock across `cursor_elements`,
// that is prone to deadlock with the main-thread on some grabs.

124
src/backend/render/wayland/blur_effect.rs
View file

@ -117,21 +117,22 @@ impl BlurShaders {
type BlurTexture = Mutex<Option<GlesTexture>>;
struct BlurState {
id: Id,
renderer_id: Option<ContextId<GlesTexture>>,
src: Size<f64, Buffer>,
offset: f64,
passes: usize,
region: Vec<Rectangle<i32, Logical>>,
commit: CommitCounter,
#[derive(Debug)]
pub struct BlurState {
pub id: Id,
pub renderer_id: Option<ContextId<GlesTexture>>,
pub src: Size<f64, Buffer>,
pub offset: f64,
pub passes: usize,
pub region: Vec<Rectangle<i32, Logical>>,
pub commit: CommitCounter,
}
unsafe impl Send for BlurState {}
unsafe impl Sync for BlurState {}
impl BlurState {
fn new() -> Self {
impl Default for BlurState {
fn default() -> Self {
BlurState {
id: Id::new(),
renderer_id: None,
@ -159,6 +160,27 @@ pub struct BlurElement {
}
impl BlurElement {
pub fn from_state<R: ImportAll + AsGlowRenderer>(
renderer: &mut R,
state: &mut BlurState,
geometry: Rectangle<f64, Logical>,
output_scale: f64,
radii: [u8; 4],
strength: usize,
) -> Result<Option<Self>, R::Error> {
let region = vec![Rectangle::from_size(geometry.size.to_i32_round())];
Self::internal(
renderer,
state,
geometry,
&region,
output_scale,
radii,
strength,
)
}
pub fn from_surface<R: ImportAll + AsGlowRenderer>(
renderer: &mut R,
states: &SurfaceData,
@ -172,9 +194,37 @@ impl BlurElement {
return Ok(None);
};
let state = states
.data_map
.get_or_insert_threadsafe::<Mutex<BlurState>, _>(Default::default);
Self::internal(
renderer,
&mut state.lock().unwrap(),
geometry,
region,
output_scale,
radii,
strength,
)
}
pub fn internal<R: ImportAll + AsGlowRenderer>(
renderer: &mut R,
state: &mut BlurState,
geometry: Rectangle<f64, Logical>,
region: &Vec<Rectangle<i32, Logical>>,
output_scale: f64,
radii: [u8; 4],
strength: usize,
) -> Result<Option<Self>, R::Error> {
if strength == 0 {
return Ok(None);
}
let geo = geometry.to_physical_precise_round(output_scale);
let mut extended_geo = geo;
let radius = BLUR_PARAMS[strength.min(MAX_STEPS - 1)].extended_radius as f64;
let radius = BLUR_PARAMS[(strength + 2).min(MAX_STEPS - 1)].extended_radius as f64;
extended_geo.loc -= Point::<f64, Physical>::new(radius, radius);
extended_geo.size += Size::<f64, Physical>::new(radius, radius).upscale(2.);
@ -217,32 +267,9 @@ impl BlurElement {
Uniform::new("noise", UniformValue::_1f(NOISE)),
];
let state = states
.data_map
.get_or_insert_threadsafe::<Mutex<BlurState>, _>(|| Mutex::new(BlurState::new()));
let geometry = extended_geo.to_logical(output_scale);
let extended_offset = Point::<f64, Physical>::new(radius, radius).to_logical(output_scale);
Ok(Some(Self::from_state(
renderer,
extended_geo.to_logical(output_scale),
Point::<f64, Physical>::new(radius, radius).to_logical(output_scale),
region,
output_scale,
&mut state.lock().unwrap(),
uniforms,
strength,
)?))
}
fn from_state<R: AsGlowRenderer>(
renderer: &mut R,
geometry: Rectangle<f64, Logical>,
extended_offset: Point<f64, Logical>,
region: &Vec<Rectangle<i32, Logical>>,
output_scale: f64,
state: &mut BlurState,
uniforms: Vec<Uniform<'static>>,
strength: usize,
) -> Result<Self, R::Error> {
let renderer_id = renderer.glow_renderer().context_id();
let src = geometry.size.to_buffer(output_scale, Transform::Normal);
let params = &BLUR_PARAMS[strength.min(MAX_STEPS - 1)];
@ -265,7 +292,7 @@ impl BlurElement {
state.commit.increment();
}
Ok(BlurElement {
Ok(Some(BlurElement {
id: state.id.clone(),
commit: state.commit,
src,
@ -284,7 +311,7 @@ impl BlurElement {
})
.collect(),
uniforms,
})
}))
}
}
@ -468,7 +495,7 @@ fn blit_from_active_fb(
let mut fb = renderer.as_mut().bind(to_texture)?;
std::mem::drop(renderer);
frame.blit_to(
let sync = frame.blit_to(
&mut fb_tmp,
dst,
Rectangle::from_size(dst.size),
@ -480,6 +507,7 @@ fn blit_from_active_fb(
let mut frame = renderer
.as_mut()
.render(&mut fb, tex_size, Transform::Normal)?;
frame.wait(&sync)?;
Frame::render_texture_from_to(
&mut frame,
&tmp_texture,
@ -502,16 +530,14 @@ fn blit_from_active_fb(
} else {
let mut fb = frame.renderer().as_mut().bind(to_texture)?;
frame
.blit_to(
&mut fb,
dst,
src.to_logical(1., Transform::Normal, &src.size)
.to_physical(1.)
.to_i32_round(),
TextureFilter::Linear,
)
.map(|_| SyncPoint::signaled())
frame.blit_to(
&mut fb,
dst,
src.to_logical(1., Transform::Normal, &src.size)
.to_physical(1.)
.to_i32_round(),
TextureFilter::Linear,
)
}
}

186
src/shell/element/resize_indicator.rs
View file

@ -1,4 +1,4 @@
use std::sync::Mutex;
use std::sync::{Arc, Mutex};
use crate::{
config::Config,
@ -12,9 +12,9 @@ use cosmic::{
Apply,
iced::{
Alignment,
widget::{column, container, row, space},
core::{Background, Border, Color, Length},
widget::{container, row, space},
},
iced_core::{Background, Border, Color, Length},
theme,
widget::{icon::from_name, text},
};
@ -67,120 +67,90 @@ impl Program for ResizeIndicatorInternal {
type Message = ();
fn view(&self) -> cosmic::Element<'_, Self::Message> {
let edges = self.edges.lock().unwrap();
let icon_container_style = || {
theme::Container::custom(|theme| container::Style {
row(vec![
text::heading(&self.shortcut1).into(),
text::body(fl!("grow-window")).into(),
space::horizontal().width(40).into(),
text::heading(&self.shortcut2).into(),
text::body(fl!("shrink-window")).into(),
])
.apply(container)
.align_x(Alignment::Center)
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(theme.cosmic().accent_color().into())),
background: Some(Background::Color(background.into())),
border: Border {
radius: 18.0.into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
})
};
column(vec![
if edges.contains(ResizeEdge::TOP) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-up-symbolic"
} else {
"go-down-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.width(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.into()
} else {
space::vertical().height(36).into()
},
row(vec![
if edges.contains(ResizeEdge::LEFT) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-previous-symbolic"
} else {
"go-next-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.width(Length::Shrink)
.apply(container)
.center_y(Length::Fill)
.into()
} else {
space::horizontal().width(36).into()
},
row(vec![
text::heading(&self.shortcut1).into(),
text::body(fl!("grow-window")).into(),
space::horizontal().width(40).into(),
text::heading(&self.shortcut2).into(),
text::body(fl!("shrink-window")).into(),
])
.apply(container)
.align_x(Alignment::Center)
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(icon_container_style())
.width(Length::Shrink)
.height(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.center_y(Length::Fill)
.into(),
if edges.contains(ResizeEdge::RIGHT) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-next-symbolic"
} else {
"go-previous-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.height(Length::Shrink)
.apply(container)
.center_y(Length::Fill)
.into()
} else {
space::horizontal().width(36).into()
},
])
.width(Length::Fill)
.height(Length::Fill)
.into(),
if edges.contains(ResizeEdge::BOTTOM) {
from_name(if self.direction == ResizeDirection::Outwards {
"go-down-symbolic"
} else {
"go-up-symbolic"
})
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(icon_container_style())
.width(Length::Shrink)
.apply(container)
.center_x(Length::Fill)
.into()
} else {
space::vertical().height(36).into()
},
])
}
}))
.width(Length::Shrink)
.height(Length::Shrink)
.into()
}
}
pub struct ResizeIndicatorArrow {
direction: Arc<Mutex<ResizeDirection>>,
icon_outwards: &'static str,
icon_inwards: &'static str,
}
impl Program for ResizeIndicatorArrow {
type Message = ();
fn view(&self) -> cosmic::Element<'_, Self::Message> {
from_name(
if *self.direction.lock().unwrap() == ResizeDirection::Outwards {
self.icon_outwards
} else {
self.icon_inwards
},
)
.size(20)
.prefer_svg(true)
.apply(container)
.padding(8)
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(background.into())),
border: Border {
radius: theme.cosmic().radius_s().into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
}
}))
.width(Length::Shrink)
.into()
}
}

137
src/shell/element/stack.rs
View file

@ -4,8 +4,14 @@ use super::{
};
use crate::{
backend::render::{
IndicatorShader, Key, Usage, cursor::CursorState, element::AsGlowRenderer,
shadow::ShadowShader, wayland::SurfaceRenderElement,
IndicatorShader, Key, Usage,
cursor::CursorState,
element::AsGlowRenderer,
shadow::ShadowShader,
wayland::{
SurfaceRenderElement,
blur_effect::{BlurElement, BlurState},
},
},
hooks::{Decorations, HOOKS},
shell::{
@ -23,10 +29,13 @@ use crate::{
use calloop::LoopHandle;
use cosmic::{
Apply, Element as CosmicElement, Theme,
iced::{Alignment, id::Id, widget as iced_widget},
iced_core::{Background, Border, Color, Length, border::Radius},
iced_runtime::Task,
iced_widget::scrollable::AbsoluteOffset,
iced::{
Alignment,
core::{Background, Border, Color, Length, border::Radius},
id::Id,
runtime::Task,
widget::{self as iced_widget, scrollable::AbsoluteOffset},
},
theme, widget as cosmic_widget,
};
use cosmic_comp_config::AppearanceConfig;
@ -120,6 +129,7 @@ pub struct CosmicStackInternal {
tiled: AtomicBool,
theme: Mutex<cosmic::Theme>,
appearance_conf: Mutex<AppearanceConfig>,
blur_state: Mutex<BlurState>,
}
impl CosmicStackInternal {
@ -178,6 +188,7 @@ impl CosmicStack {
tiled: AtomicBool::new(false),
theme: Mutex::new(theme.clone()),
appearance_conf: Mutex::new(appearance),
blur_state: Default::default(),
},
(width, TAB_HEIGHT),
handle,
@ -661,6 +672,12 @@ impl CosmicStack {
self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
let theme = p.theme.lock().unwrap();
let frosted = if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
0
};
windows[active].push_popup_render_elements(
renderer,
@ -668,7 +685,7 @@ impl CosmicStack {
scale,
alpha,
scanout_node,
9, // TODO
frosted,
&mut |elem| push(elem.into()),
)
})
@ -769,6 +786,30 @@ impl CosmicStack {
.to_physical_precise_round(scale);
let stack_loc = location + geometry.loc;
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
let frosted = self.0.with_program(|p| {
let theme = p.theme.lock().unwrap();
if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
0
}
});
let radii = self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
let appearance = p.appearance_conf.lock().unwrap();
let theme = p.theme.lock().unwrap();
let tiled = p.tiled.load(Ordering::Acquire);
let maximized = windows[active].is_maximized(false);
let round = (appearance.clip_tiled_windows || !tiled) && !maximized;
round.then(|| {
theme
.cosmic()
.radius_s()
.map(|x| if x < 4.0 { x } else { x + 4.0 })
.map(|x| x.round() as u8)
})
});
self.0
.push_render_elements(renderer, stack_loc, scale, alpha, &mut |elem| {
@ -779,19 +820,8 @@ impl CosmicStack {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
let theme = p.theme.lock().unwrap();
let appearance = p.appearance_conf.lock().unwrap();
let tiled = p.tiled.load(Ordering::Acquire);
let maximized = windows[active].is_maximized(false);
let round = (appearance.clip_tiled_windows || !tiled) && !maximized;
let radii = round.then(|| {
theme
.cosmic()
.radius_s()
.map(|x| if x < 4.0 { x } else { x + 4.0 })
.map(|x| x.round() as u8)
});
let mut geo = SpaceElement::geometry(&windows[active]).to_f64();
geo.loc += location.to_f64().to_logical(scale);
geo.size.h += TAB_HEIGHT as f64;
@ -809,7 +839,7 @@ impl CosmicStack {
Key::Window(Usage::Border, window_key.clone()),
geo.to_i32_round().as_local(),
1,
radii.unwrap_or([0, 0, 0, 0]),
radii.unwrap_or([0; 4]),
a * alpha,
scale.x,
[r, g, b],
@ -826,11 +856,34 @@ impl CosmicStack {
scanout_node,
radii.is_some(),
radii.unwrap_or([0; 4]),
9, // as TODO
frosted,
&mut |elem| push_above(elem.into()),
Some(&mut |elem| push_below(elem.into())),
);
});
if frosted > 0 {
let geometry = Rectangle::new(
stack_loc.to_f64().to_logical(scale),
Size::new(
geometry.size.to_f64().to_logical(scale).w,
TAB_HEIGHT as f64,
),
);
if let Ok(Some(elem)) = self.0.with_program(|p| {
let mut state = p.blur_state.lock().unwrap();
BlurElement::from_state(
renderer,
&mut state,
geometry,
scale.x,
radii.map(|[_, b, _, d]| [0, b, 0, d]).unwrap_or([0; 4]),
frosted,
)
}) {
push_below(elem.into());
}
}
}
pub(crate) fn set_theme(&self, theme: cosmic::Theme) {
@ -1342,16 +1395,29 @@ impl Decorations<CosmicStackInternal, Message> for DefaultDecorations {
.class(theme::Container::custom(move |theme| {
let cosmic_theme = theme.cosmic();
let background = if group_focused {
let mut background = if group_focused {
cosmic_theme.accent_color()
} else {
cosmic_theme.primary_container_color()
};
if cosmic_theme.frosted_windows {
background.alpha = cosmic_theme.alpha_map.blurred_alpha(cosmic_theme.frosted);
}
iced_widget::container::Style {
snap: true,
icon_color: Some(cosmic_theme.background.on.into()),
text_color: Some(cosmic_theme.background.on.into()),
icon_color: Some(
cosmic_theme
.background(cosmic_theme.frosted_windows)
.on
.into(),
),
text_color: Some(
cosmic_theme
.background(cosmic_theme.frosted_windows)
.on
.into(),
),
background: Some(Background::Color(background.into())),
border: Border {
radius,
@ -1864,6 +1930,7 @@ impl TouchTarget<State> for CosmicStack {
pub enum CosmicStackRenderElement<R: Renderer + ImportAll + ImportMem> {
Header(MemoryRenderBufferRenderElement<R>),
HeaderBlur(BlurElement),
Shadow(PixelShaderElement),
Border(PixelShaderElement),
Window(SurfaceRenderElement<R>),
@ -1877,6 +1944,12 @@ impl<R: Renderer + ImportAll + ImportMem> From<MemoryRenderBufferRenderElement<R
}
}
impl<R: Renderer + AsGlowRenderer> From<BlurElement> for CosmicStackRenderElement<R> {
fn from(value: BlurElement) -> Self {
Self::HeaderBlur(value)
}
}
impl<R: Renderer + ImportAll + ImportMem> From<SurfaceRenderElement<R>>
for CosmicStackRenderElement<R>
{
@ -1893,6 +1966,7 @@ where
fn id(&self) -> &RendererId {
match self {
CosmicStackRenderElement::Header(elem) => elem.id(),
CosmicStackRenderElement::HeaderBlur(elem) => elem.id(),
CosmicStackRenderElement::Shadow(elem) => elem.id(),
CosmicStackRenderElement::Border(elem) => elem.id(),
CosmicStackRenderElement::Window(elem) => elem.id(),
@ -1902,6 +1976,7 @@ where
fn current_commit(&self) -> CommitCounter {
match self {
CosmicStackRenderElement::Header(elem) => elem.current_commit(),
CosmicStackRenderElement::HeaderBlur(elem) => elem.current_commit(),
CosmicStackRenderElement::Shadow(elem) => elem.current_commit(),
CosmicStackRenderElement::Border(elem) => elem.current_commit(),
CosmicStackRenderElement::Window(elem) => elem.current_commit(),
@ -1911,6 +1986,7 @@ where
fn src(&self) -> Rectangle<f64, Buffer> {
match self {
CosmicStackRenderElement::Header(elem) => elem.src(),
CosmicStackRenderElement::HeaderBlur(elem) => elem.src(),
CosmicStackRenderElement::Shadow(elem) => elem.src(),
CosmicStackRenderElement::Border(elem) => elem.src(),
CosmicStackRenderElement::Window(elem) => elem.src(),
@ -1920,6 +1996,7 @@ where
fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
match self {
CosmicStackRenderElement::Header(elem) => elem.geometry(scale),
CosmicStackRenderElement::HeaderBlur(elem) => elem.geometry(scale),
CosmicStackRenderElement::Shadow(elem) => elem.geometry(scale),
CosmicStackRenderElement::Border(elem) => elem.geometry(scale),
CosmicStackRenderElement::Window(elem) => elem.geometry(scale),
@ -1929,6 +2006,7 @@ where
fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
match self {
CosmicStackRenderElement::Header(elem) => elem.location(scale),
CosmicStackRenderElement::HeaderBlur(elem) => elem.location(scale),
CosmicStackRenderElement::Shadow(elem) => elem.location(scale),
CosmicStackRenderElement::Border(elem) => elem.location(scale),
CosmicStackRenderElement::Window(elem) => elem.location(scale),
@ -1938,6 +2016,7 @@ where
fn transform(&self) -> Transform {
match self {
CosmicStackRenderElement::Header(elem) => elem.transform(),
CosmicStackRenderElement::HeaderBlur(elem) => elem.transform(),
CosmicStackRenderElement::Shadow(elem) => elem.transform(),
CosmicStackRenderElement::Border(elem) => elem.transform(),
CosmicStackRenderElement::Window(elem) => elem.transform(),
@ -1951,6 +2030,7 @@ where
) -> DamageSet<i32, Physical> {
match self {
CosmicStackRenderElement::Header(elem) => elem.damage_since(scale, commit),
CosmicStackRenderElement::HeaderBlur(elem) => elem.damage_since(scale, commit),
CosmicStackRenderElement::Shadow(elem) => elem.damage_since(scale, commit),
CosmicStackRenderElement::Border(elem) => elem.damage_since(scale, commit),
CosmicStackRenderElement::Window(elem) => elem.damage_since(scale, commit),
@ -1960,6 +2040,7 @@ where
fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
match self {
CosmicStackRenderElement::Header(elem) => elem.opaque_regions(scale),
CosmicStackRenderElement::HeaderBlur(elem) => elem.opaque_regions(scale),
CosmicStackRenderElement::Shadow(elem) => elem.opaque_regions(scale),
CosmicStackRenderElement::Border(elem) => elem.opaque_regions(scale),
CosmicStackRenderElement::Window(elem) => elem.opaque_regions(scale),
@ -1969,6 +2050,7 @@ where
fn alpha(&self) -> f32 {
match self {
CosmicStackRenderElement::Header(elem) => elem.alpha(),
CosmicStackRenderElement::HeaderBlur(elem) => elem.alpha(),
CosmicStackRenderElement::Shadow(elem) => elem.alpha(),
CosmicStackRenderElement::Border(elem) => elem.alpha(),
CosmicStackRenderElement::Window(elem) => elem.alpha(),
@ -1978,6 +2060,7 @@ where
fn kind(&self) -> Kind {
match self {
CosmicStackRenderElement::Header(elem) => elem.kind(),
CosmicStackRenderElement::HeaderBlur(elem) => elem.kind(),
CosmicStackRenderElement::Shadow(elem) => elem.kind(),
CosmicStackRenderElement::Border(elem) => elem.kind(),
CosmicStackRenderElement::Window(elem) => elem.kind(),
@ -1987,6 +2070,7 @@ where
fn is_framebuffer_effect(&self) -> bool {
match self {
CosmicStackRenderElement::Header(elem) => elem.is_framebuffer_effect(),
CosmicStackRenderElement::HeaderBlur(elem) => elem.is_framebuffer_effect(),
CosmicStackRenderElement::Shadow(elem) => elem.is_framebuffer_effect(),
CosmicStackRenderElement::Border(elem) => elem.is_framebuffer_effect(),
CosmicStackRenderElement::Window(elem) => elem.is_framebuffer_effect(),
@ -2012,6 +2096,9 @@ where
CosmicStackRenderElement::Header(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
CosmicStackRenderElement::HeaderBlur(elem) => {
RenderElement::<R>::draw(elem, frame, src, dst, damage, opaque_regions, cache)
}
CosmicStackRenderElement::Shadow(elem) | CosmicStackRenderElement::Border(elem) => {
RenderElement::<GlowRenderer>::draw(
elem,
@ -2033,6 +2120,7 @@ where
fn underlying_storage(&self, renderer: &mut R) -> Option<UnderlyingStorage<'_>> {
match self {
CosmicStackRenderElement::Header(elem) => elem.underlying_storage(renderer),
CosmicStackRenderElement::HeaderBlur(elem) => elem.underlying_storage(renderer),
CosmicStackRenderElement::Shadow(elem) | CosmicStackRenderElement::Border(elem) => {
elem.underlying_storage(renderer.glow_renderer_mut())
}
@ -2051,6 +2139,9 @@ where
CosmicStackRenderElement::Header(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
CosmicStackRenderElement::HeaderBlur(elem) => {
RenderElement::<R>::capture_framebuffer(elem, frame, src, dst, cache)
}
CosmicStackRenderElement::Shadow(elem) | CosmicStackRenderElement::Border(elem) => {
RenderElement::<GlowRenderer>::capture_framebuffer(
elem,

55
src/shell/element/stack/tab.rs
View file

@ -3,16 +3,15 @@ use cosmic::{
font::Font,
iced::{
Background,
widget::{self, container::draw_background, rule::FillMode},
core::{
Border, Clipboard, Color, Length, Rectangle, Shell, Size, alignment, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
text::{Ellipsize, EllipsizeHeightLimit, Shaping, Wrapping},
widget::{Id, Widget, operation::Operation, tree::Tree},
},
widget::{self, container::draw_background, rule::FillMode, scrollable::AbsoluteOffset},
},
iced_core::{
Border, Clipboard, Color, Length, Rectangle, Shell, Size, alignment, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
text::{Ellipsize, EllipsizeHeightLimit, Shaping, Wrapping},
widget::{Id, Widget, operation::Operation, tree::Tree},
},
iced_widget::scrollable::AbsoluteOffset,
theme,
widget::{Icon, icon::from_name, text},
};
@ -64,9 +63,20 @@ impl From<TabBackgroundTheme> for theme::Container<'_> {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent_text_color())),
text_color: Some(Color::from(theme.cosmic().accent_text_color())),
background: Some(Background::Color(
theme.cosmic().primary.component.selected.into(),
)),
background: Some(Background::Color({
let mut color = theme
.cosmic()
.primary(theme.cosmic().frosted_windows)
.component
.selected;
if theme.cosmic().frosted_windows {
color.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
color.into()
})),
border: Border {
radius: 0.0.into(),
width: 0.0,
@ -80,9 +90,20 @@ impl From<TabBackgroundTheme> for theme::Container<'_> {
snap: true,
icon_color: None,
text_color: None,
background: Some(Background::Color(
theme.cosmic().primary.component.base.into(),
)),
background: Some(Background::Color({
let mut color = theme
.cosmic()
.primary(theme.cosmic().frosted_windows)
.component
.base;
if theme.cosmic().frosted_windows {
color.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
color.into()
})),
border: Border {
radius: 0.0.into(),
width: 0.0,
@ -289,8 +310,8 @@ where
.min_height(size.height)
.width(size.width)
.height(size.height);
cosmic::iced_core::layout::flex::resolve(
cosmic::iced_core::layout::flex::Axis::Horizontal,
cosmic::iced::core::layout::flex::resolve(
cosmic::iced::core::layout::flex::Axis::Horizontal,
renderer,
&limits,
Length::Fill,

44
src/shell/element/stack/tabs.rs
View file

@ -1,24 +1,30 @@
use super::tab::{MIN_ACTIVE_TAB_WIDTH, Tab, TabBackgroundTheme, TabMessage, TabRuleTheme};
use cosmic::{
Apply,
iced::{Element, id::Id, widget},
iced_core::{
Background, Border, Clipboard, Color, Length, Point, Rectangle, Renderer, Shell, Size,
Vector, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
widget::{
Widget,
operation::{
Operation, Scrollable,
scrollable::{AbsoluteOffset, RelativeOffset},
iced::{
Element,
core::{
Background, Border, Clipboard, Color, Length, Point, Rectangle, Renderer, Shell, Size,
Vector, event,
layout::{Layout, Limits, Node},
mouse, overlay, renderer,
widget::{
Widget,
operation::{
Operation, Scrollable,
scrollable::{AbsoluteOffset, RelativeOffset},
},
tree::{self, Tree},
},
tree::{self, Tree},
},
id::Id,
widget::{
self,
container::{Catalog, draw_background},
},
},
iced_widget::container::draw_background,
theme,
widget::{container::Catalog, icon::from_name},
widget::icon::from_name,
};
use keyframe::{
ease,
@ -379,8 +385,8 @@ where
>= MIN_ACTIVE_TAB_WIDTH
{
// just use a flex layout
cosmic::iced_core::layout::flex::resolve(
cosmic::iced_core::layout::flex::Axis::Horizontal,
cosmic::iced::core::layout::flex::resolve(
cosmic::iced::core::layout::flex::Axis::Horizontal,
renderer,
&limits,
self.width,
@ -513,13 +519,11 @@ where
let background_style = Catalog::style(
theme,
&theme::Container::custom(|theme| widget::container::Style {
&theme::Container::custom(|_theme| widget::container::Style {
snap: true,
icon_color: None,
text_color: None,
background: Some(Background::Color(
theme.cosmic().primary_container_color().into(),
)),
background: Some(Background::Color(Color::TRANSPARENT)),
border: Border {
radius: 0.0.into(),
width: 0.0,

34
src/shell/element/stack_hover.rs
View file

@ -8,9 +8,9 @@ use cosmic::{
Apply,
iced::{
Alignment,
core::{Background, Border, Color, Length},
widget::{container, row},
},
iced_core::{Background, Border, Color, Length},
theme,
widget::{icon::from_name, space, text},
};
@ -47,17 +47,27 @@ impl Program for StackHoverInternal {
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(theme::Container::custom(|theme| container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(theme.cosmic().accent_color().into())),
border: Border {
radius: 18.0.into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(background.into())),
border: Border {
radius: theme.cosmic().radius_s().into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
}
}))
.width(Length::Shrink)
.height(Length::Shrink)

38
src/shell/element/swap_indicator.rs
View file

@ -6,8 +6,10 @@ use crate::{
use calloop::LoopHandle;
use cosmic::{
Apply,
iced::widget::{container, row, space},
iced_core::{Alignment, Background, Border, Color, Length},
iced::{
core::{Alignment, Background, Border, Color, Length},
widget::{container, row, space},
},
theme,
widget::{icon::from_name, text},
};
@ -43,17 +45,27 @@ impl Program for SwapIndicatorInternal {
.align_y(Alignment::Center)
.padding(16)
.apply(container)
.class(theme::Container::custom(|theme| container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(theme.cosmic().accent_color().into())),
border: Border {
radius: 18.0.into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
.class(theme::Container::custom(|theme| {
let mut background = theme.cosmic().accent_color();
if theme.transparent {
background.alpha = theme
.cosmic()
.alpha_map
.blurred_alpha(theme.cosmic().frosted);
}
container::Style {
snap: true,
icon_color: Some(Color::from(theme.cosmic().accent.on)),
text_color: Some(Color::from(theme.cosmic().accent.on)),
background: Some(Background::Color(background.into())),
border: Border {
radius: theme.cosmic().radius_s().into(),
width: 0.0,
color: Color::TRANSPARENT,
},
shadow: Default::default(),
}
}))
.width(Length::Shrink)
.height(Length::Shrink)

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

@ -1,7 +1,13 @@
use crate::{
backend::render::{
IndicatorShader, Key, Usage, cursor::CursorState, element::AsGlowRenderer,
shadow::ShadowShader, wayland::SurfaceRenderElement,
IndicatorShader, Key, Usage,
cursor::CursorState,
element::AsGlowRenderer,
shadow::ShadowShader,
wayland::{
SurfaceRenderElement,
blur_effect::{BlurElement, BlurState},
},
},
hooks::{Decorations, HOOKS},
shell::{
@ -93,6 +99,7 @@ pub struct CosmicWindowInternal {
tiled: AtomicBool,
theme: Mutex<cosmic::Theme>,
appearance_conf: Mutex<AppearanceConfig>,
blur_state: Mutex<BlurState>,
}
#[repr(u8)]
@ -213,6 +220,7 @@ impl CosmicWindow {
tiled: AtomicBool::new(false),
theme: Mutex::new(theme.clone()),
appearance_conf: Mutex::new(appearance),
blur_state: Mutex::default(),
},
(width, SSD_HEIGHT),
handle,
@ -369,13 +377,20 @@ impl CosmicWindow {
};
self.0.with_program(|p| {
let theme = p.theme.lock().unwrap();
let frosted = if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
0
};
p.window.push_popup_render_elements(
renderer,
window_loc,
scale,
alpha,
scanout_node,
9, // TODO
frosted,
&mut |elem| push(elem.into()),
)
})
@ -543,11 +558,17 @@ impl CosmicWindow {
push_above(elem);
}
self.0.with_program(|p| {
let frosted = self.0.with_program(|p| {
if has_ssd {
radii[1] = 0;
radii[3] = 0;
}
let theme = p.theme.lock().unwrap();
let frosted = if theme.cosmic().frosted_windows {
(theme.cosmic().frosted as u8 + 1) as usize
} else {
0
};
p.window.push_render_elements(
renderer,
window_loc,
@ -557,18 +578,31 @@ impl CosmicWindow {
scanout_node,
clip,
radii,
9, // TODO
frosted,
&mut |elem| push_above(elem.into()),
Some(&mut |elem| push_below(elem.into())),
)
);
frosted
});
if has_ssd {
let ssd_loc = location
+ self
.0
.with_program(|p| p.window.geometry().loc)
.to_physical_precise_round(scale);
.with_program(|p| p.window.geometry().loc.to_physical_precise_round(scale));
if frosted > 0 {
let geometry = Rectangle::new(
ssd_loc.to_f64().to_logical(scale),
Size::new(geo.size.w, SSD_HEIGHT as f64),
);
if let Ok(Some(elem)) = self.0.with_program(|p| {
let mut state = p.blur_state.lock().unwrap();
BlurElement::from_state(renderer, &mut state, geometry, scale.x, radii, frosted)
}) {
push_below(elem.into());
}
}
self.0
.push_render_elements(renderer, ssd_loc, scale, alpha, &mut |elem| {
push_above(elem.into())
@ -812,7 +846,11 @@ impl Program for CosmicWindowInternal {
fn background_color(&self, theme: &cosmic::Theme) -> Color {
if self.window.is_maximized(false) {
theme.cosmic().background.base.into()
theme
.cosmic()
.background(theme.cosmic().frosted_windows)
.base
.into()
} else {
Color::TRANSPARENT
}
@ -1231,6 +1269,7 @@ impl WaylandFocus for CosmicWindow {
pub enum CosmicWindowRenderElement<R: Renderer + ImportAll + ImportMem> {
Header(MemoryRenderBufferRenderElement<R>),
HeaderBlur(BlurElement),
Shadow(PixelShaderElement),
Border(PixelShaderElement),
Window(SurfaceRenderElement<R>),
@ -1244,6 +1283,12 @@ impl<R: Renderer + ImportAll + ImportMem> From<MemoryRenderBufferRenderElement<R
}
}
impl<R: Renderer + AsGlowRenderer> From<BlurElement> for CosmicWindowRenderElement<R> {
fn from(value: BlurElement) -> Self {
Self::HeaderBlur(value)
}
}
impl<R: Renderer + ImportAll + ImportMem> From<SurfaceRenderElement<R>>
for CosmicWindowRenderElement<R>
{
@ -1260,6 +1305,7 @@ where
fn id(&self) -> &RendererId {
match self {
CosmicWindowRenderElement::Header(elem) => elem.id(),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.id(),
CosmicWindowRenderElement::Shadow(elem) => elem.id(),
CosmicWindowRenderElement::Border(elem) => elem.id(),
CosmicWindowRenderElement::Window(elem) => elem.id(),
@ -1269,6 +1315,7 @@ where
fn current_commit(&self) -> CommitCounter {
match self {
CosmicWindowRenderElement::Header(elem) => elem.current_commit(),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.current_commit(),
CosmicWindowRenderElement::Shadow(elem) => elem.current_commit(),
CosmicWindowRenderElement::Border(elem) => elem.current_commit(),
CosmicWindowRenderElement::Window(elem) => elem.current_commit(),
@ -1278,6 +1325,7 @@ where
fn src(&self) -> Rectangle<f64, Buffer> {
match self {
CosmicWindowRenderElement::Header(elem) => elem.src(),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.src(),
CosmicWindowRenderElement::Shadow(elem) => elem.src(),
CosmicWindowRenderElement::Border(elem) => elem.src(),
CosmicWindowRenderElement::Window(elem) => elem.src(),
@ -1287,6 +1335,7 @@ where
fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
match self {
CosmicWindowRenderElement::Header(elem) => elem.geometry(scale),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.geometry(scale),
CosmicWindowRenderElement::Shadow(elem) => elem.geometry(scale),
CosmicWindowRenderElement::Border(elem) => elem.geometry(scale),
CosmicWindowRenderElement::Window(elem) => elem.geometry(scale),
@ -1296,6 +1345,7 @@ where
fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
match self {
CosmicWindowRenderElement::Header(elem) => elem.location(scale),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.location(scale),
CosmicWindowRenderElement::Shadow(elem) => elem.location(scale),
CosmicWindowRenderElement::Border(elem) => elem.location(scale),
CosmicWindowRenderElement::Window(elem) => elem.location(scale),
@ -1305,6 +1355,7 @@ where
fn transform(&self) -> Transform {
match self {
CosmicWindowRenderElement::Header(elem) => elem.transform(),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.transform(),
CosmicWindowRenderElement::Shadow(elem) => elem.transform(),
CosmicWindowRenderElement::Border(elem) => elem.transform(),
CosmicWindowRenderElement::Window(elem) => elem.transform(),
@ -1318,6 +1369,7 @@ where
) -> DamageSet<i32, Physical> {
match self {
CosmicWindowRenderElement::Header(elem) => elem.damage_since(scale, commit),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.damage_since(scale, commit),
CosmicWindowRenderElement::Shadow(elem) => elem.damage_since(scale, commit),
CosmicWindowRenderElement::Border(elem) => elem.damage_since(scale, commit),
CosmicWindowRenderElement::Window(elem) => elem.damage_since(scale, commit),
@ -1327,6 +1379,7 @@ where
fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
match self {
CosmicWindowRenderElement::Header(elem) => elem.opaque_regions(scale),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.opaque_regions(scale),
CosmicWindowRenderElement::Shadow(elem) => elem.opaque_regions(scale),
CosmicWindowRenderElement::Border(elem) => elem.opaque_regions(scale),
CosmicWindowRenderElement::Window(elem) => elem.opaque_regions(scale),
@ -1336,6 +1389,7 @@ where
fn alpha(&self) -> f32 {
match self {
CosmicWindowRenderElement::Header(elem) => elem.alpha(),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.alpha(),
CosmicWindowRenderElement::Shadow(elem) => elem.alpha(),
CosmicWindowRenderElement::Border(elem) => elem.alpha(),
CosmicWindowRenderElement::Window(elem) => elem.alpha(),
@ -1345,6 +1399,7 @@ where
fn kind(&self) -> Kind {
match self {
CosmicWindowRenderElement::Header(elem) => elem.kind(),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.kind(),
CosmicWindowRenderElement::Shadow(elem) => elem.kind(),
CosmicWindowRenderElement::Border(elem) => elem.kind(),
CosmicWindowRenderElement::Window(elem) => elem.kind(),
@ -1354,6 +1409,7 @@ where
fn is_framebuffer_effect(&self) -> bool {
match self {
CosmicWindowRenderElement::Header(elem) => elem.is_framebuffer_effect(),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.is_framebuffer_effect(),
CosmicWindowRenderElement::Shadow(elem) => elem.is_framebuffer_effect(),
CosmicWindowRenderElement::Border(elem) => elem.is_framebuffer_effect(),
CosmicWindowRenderElement::Window(elem) => elem.is_framebuffer_effect(),
@ -1379,6 +1435,9 @@ where
CosmicWindowRenderElement::Header(elem) => {
elem.draw(frame, src, dst, damage, opaque_regions, cache)
}
CosmicWindowRenderElement::HeaderBlur(elem) => {
RenderElement::<R>::draw(elem, frame, src, dst, damage, opaque_regions, cache)
}
CosmicWindowRenderElement::Shadow(elem) | CosmicWindowRenderElement::Border(elem) => {
RenderElement::<GlowRenderer>::draw(
elem,
@ -1400,6 +1459,7 @@ where
fn underlying_storage(&self, renderer: &mut R) -> Option<UnderlyingStorage<'_>> {
match self {
CosmicWindowRenderElement::Header(elem) => elem.underlying_storage(renderer),
CosmicWindowRenderElement::HeaderBlur(elem) => elem.underlying_storage(renderer),
CosmicWindowRenderElement::Shadow(elem) | CosmicWindowRenderElement::Border(elem) => {
elem.underlying_storage(renderer.glow_renderer_mut())
}
@ -1418,6 +1478,9 @@ where
CosmicWindowRenderElement::Header(elem) => {
elem.capture_framebuffer(frame, src, dst, cache)
}
CosmicWindowRenderElement::HeaderBlur(elem) => {
RenderElement::<R>::capture_framebuffer(elem, frame, src, dst, cache)
}
CosmicWindowRenderElement::Shadow(elem) | CosmicWindowRenderElement::Border(elem) => {
RenderElement::<GlowRenderer>::capture_framebuffer(
elem,

14
src/shell/grabs/menu/item.rs
View file

@ -1,10 +1,12 @@
use cosmic::{
iced::Element,
iced_core::{
Background, Border, Clipboard, Color, Event, Layout, Length, Rectangle,
Renderer as IcedRenderer, Shell, Size, layout, mouse, overlay,
renderer::{Quad, Style},
widget::{Id, Tree, Widget, tree},
iced::{
Element,
core::{
Background, Border, Clipboard, Color, Event, Layout, Length, Rectangle,
Renderer as IcedRenderer, Shell, Size, layout, mouse, overlay,
renderer::{Quad, Style},
widget::{Id, Tree, Widget, tree},
},
},
widget::button::Catalog,
};

16
src/shell/grabs/menu/mod.rs
View file

@ -9,9 +9,11 @@ use std::{
use calloop::LoopHandle;
use cosmic::{
Apply as _, Task,
iced::{Alignment, Background},
iced_core::{Border, Length, Rectangle as IcedRectangle, alignment::Horizontal},
iced_widget::{self, Column, Row, text::Style as TextStyle},
iced::{
Alignment, Background,
core::{Border, Length, Rectangle as IcedRectangle, alignment::Horizontal},
widget::{self as iced_widget, Column, Row, text::Style as TextStyle},
},
theme,
widget::{button, divider, icon::from_name, space, text},
};
@ -424,10 +426,11 @@ impl Program for ContextMenu {
.width(mode)
.class(if *disabled {
theme::Text::Custom(|theme| {
let mut color = theme.cosmic().background.component.on;
let mut color = theme.cosmic().background(false).component.on;
color.alpha *= 0.5;
TextStyle {
color: Some(color.into()),
..Default::default()
}
})
} else {
@ -442,10 +445,11 @@ impl Program for ContextMenu {
.align_x(Horizontal::Right)
.width(Length::Shrink)
.class(theme::Text::Custom(|theme| {
let mut color = theme.cosmic().background.component.on;
let mut color = theme.cosmic().background(false).component.on;
color.alpha *= 0.75;
TextStyle {
color: Some(color.into()),
..Default::default()
}
}))
.into(),
@ -470,7 +474,7 @@ impl Program for ContextMenu {
.padding(1)
.class(theme::Container::custom(|theme| {
let cosmic = theme.cosmic();
let component = &cosmic.background.component;
let component = &cosmic.background(false).component;
iced_widget::container::Style {
snap: true,
icon_color: Some(cosmic.accent.base.into()),

12
src/shell/workspace.rs
View file

@ -1686,15 +1686,15 @@ impl Workspace {
.as_logical()
.to_physical_precise_round(output_scale);
let fullscreen_geo = fullscreen.surface.0.geometry();
let scale = Scale {
x: target_geo.size.w as f64 / fullscreen_geo.size.w as f64,
y: target_geo.size.h as f64 / fullscreen_geo.size.h as f64,
};
// Only rescale geometry when animating
let animation_rescale = |elem| {
if fullscreen.is_animating() {
let fullscreen_geo = fullscreen.surface.0.geometry();
let scale = Scale {
x: target_geo.size.w as f64 / fullscreen_geo.size.w as f64,
y: target_geo.size.h as f64 / fullscreen_geo.size.h as f64,
};
RescaleRenderElement::from_element(elem, render_loc, scale).into()
} else {
Into::<WorkspaceRenderElement<_>>::into(elem)

6
src/shell/zoom.rs
View file

@ -3,8 +3,8 @@ use std::{sync::Mutex, time::Instant};
use calloop::LoopHandle;
use cosmic::{
Apply,
iced::{Alignment, Background, Border, Length, alignment::Vertical},
iced_widget, theme,
iced::{Alignment, Background, Border, Length, alignment::Vertical, widget as iced_widget},
theme,
widget::{self, icon::Named},
};
use cosmic_comp_config::ZoomMovement;
@ -515,7 +515,7 @@ impl Program for ZoomProgram {
.padding(8)
.class(theme::Container::custom(|theme| {
let cosmic = theme.cosmic();
let component = &cosmic.background.component;
let component = &cosmic.background(false).component;
iced_widget::container::Style {
snap: true,
icon_color: Some(component.on.into()),

4
src/utils/iced/mod.rs
View file

@ -12,15 +12,15 @@ use cosmic::{
iced::{
Limits, Point as IcedPoint, Size as IcedSize, Task,
advanced::{graphics::text::font_system, widget::Tree},
core::{Color, Length, Pixels, clipboard::Null as NullClipboard, id::Id, renderer::Style},
event::Event,
futures::{FutureExt, StreamExt},
keyboard::{Event as KeyboardEvent, Modifiers as IcedModifiers},
mouse::{Button as MouseButton, Cursor, Event as MouseEvent, ScrollDelta},
runtime::{Action, task::into_stream},
touch::{Event as TouchEvent, Finger},
window::Event as WindowEvent,
},
iced_core::{Color, Length, Pixels, clipboard::Null as NullClipboard, id::Id, renderer::Style},
iced_runtime::{Action, task::into_stream},
};
use iced_tiny_skia::{
Layer,

24
src/utils/iced/state.rs
View file

@ -1,12 +1,16 @@
use super::IcedProgram as Program;
use cosmic::iced::core::event::{self, Event};
use cosmic::iced::core::mouse;
use cosmic::iced::core::renderer;
use cosmic::iced::core::widget::operation::{self, Operation};
use cosmic::iced::core::{Clipboard, Size};
use cosmic::iced_core;
use cosmic::iced_runtime::Task;
use cosmic::iced_runtime::user_interface::{self, UserInterface};
use cosmic::iced::{
core::{
self as iced_core, Clipboard, Size,
event::{self, Event},
mouse, renderer,
widget::operation::{self, Operation},
},
runtime::{
Task,
user_interface::{self, UserInterface},
},
};
/// The execution state of a [`Program`]. It leverages caching, event
/// processing, and rendering primitive storage.
@ -128,7 +132,7 @@ where
messages.append(&mut self.queued_messages);
let task = if messages.is_empty() {
if let cosmic::iced_runtime::user_interface::State::Updated {
if let cosmic::iced::runtime::user_interface::State::Updated {
mouse_interaction, ..
} = state
{
@ -154,7 +158,7 @@ where
let mut user_interface =
build_user_interface(id, &mut self.program, temp_cache, renderer, bounds);
if let cosmic::iced_runtime::user_interface::State::Updated {
if let cosmic::iced::runtime::user_interface::State::Updated {
mouse_interaction, ..
} = state
{