me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Fix clippy lints for all crates and features

Browse source 
... and check those in CI as well!
This commit is contained in:
Héctor Ramón Jiménez 2022-07-09 18:42:41 +02:00
parent d53cc5498b
commit 2065a40f64
No known key found for this signature in database
GPG key ID: 140CC052C94F138E
55 changed files with 237 additions and 232 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.github/workflows/lint.yml vendored
View file

@ -9,4 +9,4 @@ jobs:
components: clippy
- uses: actions/checkout@master
- name: Check lints
run: cargo clippy --all --no-deps
run: cargo clippy --all --all-features --no-deps

2
examples/color_palette/src/main.rs
View file

@ -84,7 +84,7 @@ impl Sandbox for ColorPalette {
}
#[derive(Debug)]
pub struct Theme {
struct Theme {
lower: Vec<Color>,
base: Color,
higher: Vec<Color>,

3
examples/component/src/main.rs
View file

@ -150,8 +150,7 @@ mod numeric_input {
self.value
.as_ref()
.map(u32::to_string)
.as_ref()
.map(String::as_str)
.as_deref()
.unwrap_or(""),
Event::InputChanged,
)

6
examples/custom_widget/src/main.rs
View file

@ -64,12 +64,12 @@ mod circle {
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for Circle
impl<'a, Message, Renderer> From<Circle> for Element<'a, Message, Renderer>
where
Renderer: renderer::Renderer,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(circle: Circle) -> Self {
Self::new(circle)
}
}
}

9
examples/download_progress/src/main.rs
View file

@ -49,7 +49,7 @@ impl Application for Example {
fn update(&mut self, message: Message) -> Command<Message> {
match message {
Message::Add => {
self.last_id = self.last_id + 1;
self.last_id += 1;
self.downloads.push(Download::new(self.last_id));
}
@ -134,8 +134,8 @@ impl Download {
}
pub fn progress(&mut self, new_progress: download::Progress) {
match &mut self.state {
State::Downloading { progress } => match new_progress {
if let State::Downloading { progress } = &mut self.state {
match new_progress {
download::Progress::Started => {
*progress = 0.0;
}
@ -152,8 +152,7 @@ impl Download {
button: button::State::new(),
};
}
},
_ => {}
}
}
}

10
examples/game_of_life/src/main.rs
View file

@ -280,7 +280,7 @@ mod grid {
}
}
pub fn view<'a>(&'a mut self) -> Element<'a, Message> {
pub fn view(&mut self) -> Element<Message> {
Canvas::new(self)
.width(Length::Fill)
.height(Length::Fill)
@ -328,7 +328,7 @@ mod grid {
}
}
impl<'a> canvas::Program<Message> for Grid {
impl canvas::Program<Message> for Grid {
fn update(
&mut self,
event: Event,
@ -826,13 +826,13 @@ struct Controls {
}
impl Controls {
fn view<'a>(
&'a mut self,
fn view(
&mut self,
is_playing: bool,
is_grid_enabled: bool,
speed: usize,
preset: Preset,
) -> Element<'a, Message> {
) -> Element<Message> {
let playback_controls = Row::new()
.spacing(10)
.push(

10
examples/game_of_life/src/preset.rs
View file

@ -1,7 +1,7 @@
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Preset {
Custom,
XKCD,
Xkcd,
Glider,
SmallExploder,
Exploder,
@ -14,7 +14,7 @@ pub enum Preset {
pub static ALL: &[Preset] = &[
Preset::Custom,
Preset::XKCD,
Preset::Xkcd,
Preset::Glider,
Preset::SmallExploder,
Preset::Exploder,
@ -30,7 +30,7 @@ impl Preset {
#[rustfmt::skip]
let cells = match self {
Preset::Custom => vec![],
Preset::XKCD => vec![
Preset::Xkcd => vec![
" xxx ",
" x x ",
" x x ",
@ -116,7 +116,7 @@ impl Preset {
impl Default for Preset {
fn default() -> Preset {
Preset::XKCD
Preset::Xkcd
}
}
@ -127,7 +127,7 @@ impl std::fmt::Display for Preset {
"{}",
match self {
Preset::Custom => "Custom",
Preset::XKCD => "xkcd #2293",
Preset::Xkcd => "xkcd #2293",
Preset::Glider => "Glider",
Preset::SmallExploder => "Small Exploder",
Preset::Exploder => "Exploder",

7
examples/geometry/src/main.rs
View file

@ -17,6 +17,7 @@ mod rainbow {
layout, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget,
};
#[derive(Default)]
pub struct Rainbow;
impl Rainbow {
@ -148,12 +149,12 @@ mod rainbow {
}
}
impl<'a, Message, B, T> Into<Element<'a, Message, Renderer<B, T>>> for Rainbow
impl<'a, Message, B, T> From<Rainbow> for Element<'a, Message, Renderer<B, T>>
where
B: Backend,
{
fn into(self) -> Element<'a, Message, Renderer<B, T>> {
Element::new(self)
fn from(rainbow: Rainbow) -> Self {
Self::new(rainbow)
}
}
}

5
examples/integration_opengl/src/main.rs
View file

@ -58,7 +58,7 @@ pub fn main() {
let mut cursor_position = PhysicalPosition::new(-1.0, -1.0);
let mut modifiers = ModifiersState::default();
let mut clipboard = Clipboard::connect(&windowed_context.window());
let mut clipboard = Clipboard::connect(windowed_context.window());
let mut renderer = Renderer::new(Backend::new(&gl, Settings::default()));
@ -73,13 +73,12 @@ pub fn main() {
);
let mut resized = false;
let scene = Scene::new(&gl, &shader_version);
let scene = Scene::new(&gl, shader_version);
event_loop.run(move |event, _, control_flow| {
*control_flow = ControlFlow::Wait;
match event {
Event::LoopDestroyed => return,
Event::WindowEvent { event, .. } => {
match event {
WindowEvent::CursorMoved { position, .. } => {

2
examples/integration_wgpu/src/controls.rs
View file

@ -112,7 +112,7 @@ impl Program for Controls {
t,
"Placeholder",
text,
move |text| Message::TextChanged(text),
Message::TextChanged,
)),
),
)

10
examples/integration_wgpu/src/main.rs
View file

@ -73,7 +73,7 @@ pub fn main() {
let instance = wgpu::Instance::new(backend);
let surface = unsafe { instance.create_surface(&window) };
let (format, (mut device, queue)) = futures::executor::block_on(async {
let (format, (device, queue)) = futures::executor::block_on(async {
let adapter = wgpu::util::initialize_adapter_from_env_or_default(
&instance,
backend,
@ -128,13 +128,13 @@ pub fn main() {
let mut staging_belt = wgpu::util::StagingBelt::new(5 * 1024);
// Initialize scene and GUI controls
let scene = Scene::new(&mut device, format);
let scene = Scene::new(&device, format);
let controls = Controls::new();
// Initialize iced
let mut debug = Debug::new();
let mut renderer =
Renderer::new(Backend::new(&mut device, Settings::default(), format));
Renderer::new(Backend::new(&device, Settings::default(), format));
let mut state = program::State::new(
controls,
@ -208,8 +208,8 @@ pub fn main() {
surface.configure(
&device,
&wgpu::SurfaceConfiguration {
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: format,
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::AutoVsync,
@ -244,7 +244,7 @@ pub fn main() {
// And then iced on top
renderer.with_primitives(|backend, primitive| {
backend.present(
&mut device,
&device,
&mut staging_belt,
&mut encoder,
&view,

69
examples/integration_wgpu/src/scene.rs
View file

@ -66,40 +66,37 @@ fn build_pipeline(
bind_group_layouts: &[],
});
let pipeline =
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: None,
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &vs_module,
entry_point: "main",
buffers: &[],
},
fragment: Some(wgpu::FragmentState {
module: &fs_module,
entry_point: "main",
targets: &[Some(wgpu::ColorTargetState {
format: texture_format,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Ccw,
..Default::default()
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
multiview: None,
});
pipeline
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: None,
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &vs_module,
entry_point: "main",
buffers: &[],
},
fragment: Some(wgpu::FragmentState {
module: &fs_module,
entry_point: "main",
targets: &[Some(wgpu::ColorTargetState {
format: texture_format,
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent::REPLACE,
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
front_face: wgpu::FrontFace::Ccw,
..Default::default()
},
depth_stencil: None,
multisample: wgpu::MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
multiview: None,
})
}

3
examples/pokedex/src/main.rs
View file

@ -192,8 +192,7 @@ impl Pokemon {
let description = entry
.flavor_text_entries
.iter()
.filter(|text| text.language.name == "en")
.next()
.find(|text| text.language.name == "en")
.ok_or(Error::LanguageError)?;
Ok(Pokemon {

3
examples/pure/component/src/main.rs
View file

@ -143,8 +143,7 @@ mod numeric_input {
self.value
.as_ref()
.map(u32::to_string)
.as_ref()
.map(String::as_str)
.as_deref()
.unwrap_or(""),
Event::InputChanged,
)

2
examples/pure/game_of_life/src/main.rs
View file

@ -350,7 +350,7 @@ mod grid {
}
}
pub fn view<'a>(&'a self) -> Element<'a, Message> {
pub fn view(&self) -> Element<Message> {
Canvas::new(self)
.width(Length::Fill)
.height(Length::Fill)

10
examples/pure/game_of_life/src/preset.rs
View file

@ -1,7 +1,7 @@
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Preset {
Custom,
XKCD,
Xkcd,
Glider,
SmallExploder,
Exploder,
@ -14,7 +14,7 @@ pub enum Preset {
pub static ALL: &[Preset] = &[
Preset::Custom,
Preset::XKCD,
Preset::Xkcd,
Preset::Glider,
Preset::SmallExploder,
Preset::Exploder,
@ -30,7 +30,7 @@ impl Preset {
#[rustfmt::skip]
let cells = match self {
Preset::Custom => vec![],
Preset::XKCD => vec![
Preset::Xkcd => vec![
" xxx ",
" x x ",
" x x ",
@ -116,7 +116,7 @@ impl Preset {
impl Default for Preset {
fn default() -> Preset {
Preset::XKCD
Preset::Xkcd
}
}
@ -127,7 +127,7 @@ impl std::fmt::Display for Preset {
"{}",
match self {
Preset::Custom => "Custom",
Preset::XKCD => "xkcd #2293",
Preset::Xkcd => "xkcd #2293",
Preset::Glider => "Glider",
Preset::SmallExploder => "Small Exploder",
Preset::Exploder => "Exploder",

28
examples/pure/todos/src/main.rs
View file

@ -167,7 +167,7 @@ impl Application for Todos {
.size(30)
.on_submit(Message::CreateTask);
let controls = view_controls(&tasks, *filter);
let controls = view_controls(tasks, *filter);
let filtered_tasks =
tasks.iter().filter(|task| filter.matches(task));
@ -446,15 +446,15 @@ struct SavedState {
#[derive(Debug, Clone)]
enum LoadError {
FileError,
FormatError,
File,
Format,
}
#[derive(Debug, Clone)]
enum SaveError {
FileError,
WriteError,
FormatError,
File,
Write,
Format,
}
#[cfg(not(target_arch = "wasm32"))]
@ -465,7 +465,7 @@ impl SavedState {
{
project_dirs.data_dir().into()
} else {
std::env::current_dir().unwrap_or(std::path::PathBuf::new())
std::env::current_dir().unwrap_or_default()
};
path.push("todos.json");
@ -480,37 +480,37 @@ impl SavedState {
let mut file = async_std::fs::File::open(Self::path())
.await
.map_err(|_| LoadError::FileError)?;
.map_err(|_| LoadError::File)?;
file.read_to_string(&mut contents)
.await
.map_err(|_| LoadError::FileError)?;
.map_err(|_| LoadError::File)?;
serde_json::from_str(&contents).map_err(|_| LoadError::FormatError)
serde_json::from_str(&contents).map_err(|_| LoadError::Format)
}
async fn save(self) -> Result<(), SaveError> {
use async_std::prelude::*;
let json = serde_json::to_string_pretty(&self)
.map_err(|_| SaveError::FormatError)?;
.map_err(|_| SaveError::Format)?;
let path = Self::path();
if let Some(dir) = path.parent() {
async_std::fs::create_dir_all(dir)
.await
.map_err(|_| SaveError::FileError)?;
.map_err(|_| SaveError::File)?;
}
{
let mut file = async_std::fs::File::create(path)
.await
.map_err(|_| SaveError::FileError)?;
.map_err(|_| SaveError::File)?;
file.write_all(json.as_bytes())
.await
.map_err(|_| SaveError::WriteError)?;
.map_err(|_| SaveError::Write)?;
}
// This is a simple way to save at most once every couple seconds

10
examples/pure/tour/src/main.rs
View file

@ -78,14 +78,6 @@ impl Sandbox for Tour {
.push(controls)
.into();
let content = if self.debug {
// TODO
//content.explain(Color::BLACK)
content
} else {
content
};
let scrollable =
scrollable(container(content).width(Length::Fill).center_x());
@ -494,7 +486,7 @@ impl<'a> Step {
.push(ferris(width))
.push(slider(100..=500, width, StepMessage::ImageWidthChanged))
.push(
text(format!("Width: {} px", width.to_string()))
text(format!("Width: {} px", width))
.width(Length::Fill)
.horizontal_alignment(alignment::Horizontal::Center),
)

3
examples/solar_system/src/main.rs
View file

@ -65,8 +65,7 @@ impl Application for SolarSystem {
}
fn subscription(&self) -> Subscription<Message> {
time::every(std::time::Duration::from_millis(10))
.map(|instant| Message::Tick(instant))
time::every(std::time::Duration::from_millis(10)).map(Message::Tick)
}
fn view(&mut self) -> Element<Message> {

7
examples/stopwatch/src/main.rs
View file

@ -67,13 +67,12 @@ impl Application for Stopwatch {
self.state = State::Idle;
}
},
Message::Tick(now) => match &mut self.state {
State::Ticking { last_tick } => {
Message::Tick(now) => {
if let State::Ticking { last_tick } = &mut self.state {
self.duration += now - *last_tick;
*last_tick = now;
}
_ => {}
},
}
Message::Reset => {
self.duration = Duration::default();
}

7
examples/system_information/src/main.rs
View file

@ -107,11 +107,8 @@ impl Application for Example {
ByteSize::kb(information.memory_total).to_string();
let memory_total = Text::new(format!(
"Memory (total): {}",
format!(
"{} kb ({})",
information.memory_total, memory_readable
)
"Memory (total): {} kb ({})",
information.memory_total, memory_readable
));
let memory_text = if let Some(memory_used) =

28
examples/todos/src/main.rs
View file

@ -168,7 +168,7 @@ impl Application for Todos {
.size(30)
.on_submit(Message::CreateTask);
let controls = controls.view(&tasks, *filter);
let controls = controls.view(tasks, *filter);
let filtered_tasks =
tasks.iter().filter(|task| filter.matches(task));
@ -493,15 +493,15 @@ struct SavedState {
#[derive(Debug, Clone)]
enum LoadError {
FileError,
FormatError,
File,
Format,
}
#[derive(Debug, Clone)]
enum SaveError {
FileError,
WriteError,
FormatError,
File,
Write,
Format,
}
#[cfg(not(target_arch = "wasm32"))]
@ -512,7 +512,7 @@ impl SavedState {
{
project_dirs.data_dir().into()
} else {
std::env::current_dir().unwrap_or(std::path::PathBuf::new())
std::env::current_dir().unwrap_or_default()
};
path.push("todos.json");
@ -527,37 +527,37 @@ impl SavedState {
let mut file = async_std::fs::File::open(Self::path())
.await
.map_err(|_| LoadError::FileError)?;
.map_err(|_| LoadError::File)?;
file.read_to_string(&mut contents)
.await
.map_err(|_| LoadError::FileError)?;
.map_err(|_| LoadError::File)?;
serde_json::from_str(&contents).map_err(|_| LoadError::FormatError)
serde_json::from_str(&contents).map_err(|_| LoadError::Format)
}
async fn save(self) -> Result<(), SaveError> {
use async_std::prelude::*;
let json = serde_json::to_string_pretty(&self)
.map_err(|_| SaveError::FormatError)?;
.map_err(|_| SaveError::Format)?;
let path = Self::path();
if let Some(dir) = path.parent() {
async_std::fs::create_dir_all(dir)
.await
.map_err(|_| SaveError::FileError)?;
.map_err(|_| SaveError::File)?;
}
{
let mut file = async_std::fs::File::create(path)
.await
.map_err(|_| SaveError::FileError)?;
.map_err(|_| SaveError::File)?;
file.write_all(json.as_bytes())
.await
.map_err(|_| SaveError::WriteError)?;
.map_err(|_| SaveError::Write)?;
}
// This is a simple way to save at most once every couple seconds

17
examples/tooltip/src/main.rs
View file

@ -54,16 +54,11 @@ impl Sandbox for Example {
tooltip::Position::Right,
);
let fixed_tooltips = Row::with_children(vec![
top.into(),
bottom.into(),
left.into(),
right.into(),
])
.width(Length::Fill)
.height(Length::Fill)
.align_items(Alignment::Center)
.spacing(50);
let fixed_tooltips = Row::with_children(vec![top, bottom, left, right])
.width(Length::Fill)
.height(Length::Fill)
.align_items(Alignment::Center)
.spacing(50);
let follow_cursor = tooltip(
"Tooltip follows cursor",
@ -78,7 +73,7 @@ impl Sandbox for Example {
.center_x()
.center_y()
.into(),
follow_cursor.into(),
follow_cursor,
])
.width(Length::Fill)
.height(Length::Fill)

2
examples/url_handler/src/main.rs
View file

@ -57,7 +57,7 @@ impl Application for App {
fn view(&mut self) -> Element<Message> {
let content = match &self.url {
Some(url) => Text::new(format!("{}", url)),
Some(url) => Text::new(url),
None => Text::new("No URL received yet!"),
};

6
examples/websocket/src/echo.rs
View file

@ -32,7 +32,7 @@ pub fn connect() -> Subscription<Event> {
)
}
Err(_) => {
let _ = tokio::time::sleep(
tokio::time::sleep(
tokio::time::Duration::from_secs(1),
)
.await;
@ -79,6 +79,7 @@ pub fn connect() -> Subscription<Event> {
}
#[derive(Debug)]
#[allow(clippy::large_enum_variant)]
enum State {
Disconnected,
Connected(
@ -101,8 +102,7 @@ pub struct Connection(mpsc::Sender<Message>);
impl Connection {
pub fn send(&mut self, message: Message) {
let _ = self
.0
self.0
.try_send(message)
.expect("Send message to echo server");
}

8
examples/websocket/src/echo/server.rs
View file

@ -27,9 +27,9 @@ use warp::Filter;
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
pub async fn run() {
let routes = warp::path::end().and(warp::ws()).map(|ws: warp::ws::Ws| {
ws.on_upgrade(move |socket| user_connected(socket))
});
let routes = warp::path::end()
.and(warp::ws())
.map(|ws: warp::ws::Ws| ws.on_upgrade(user_connected));
warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
}
@ -40,7 +40,7 @@ async fn user_connected(ws: WebSocket) {
tokio::task::spawn(async move {
while let Some(message) = rx.next().await {
let _ = user_ws_tx.send(message).await.unwrap_or_else(|e| {
user_ws_tx.send(message).await.unwrap_or_else(|e| {
eprintln!("websocket send error: {}", e);
});
}

1
glow/src/backend.rs
View file

@ -173,7 +173,6 @@ impl Backend {
glow_glyph::VerticalAlign::Bottom
}
}),
..Default::default()
};
self.text_pipeline.queue(text);

9
glow/src/quad/compatibility.rs
View file

@ -116,14 +116,7 @@ impl Pipeline {
// TODO: Remove this allocation (or allocate only when needed)
let indices: Vec<i32> = (0..instances.len().min(MAX_QUADS) as i32)
.flat_map(|i| {
[
0 + i * 4,
1 + i * 4,
2 + i * 4,
2 + i * 4,
1 + i * 4,
3 + i * 4,
]
[i * 4, 1 + i * 4, 2 + i * 4, 2 + i * 4, 1 + i * 4, 3 + i * 4]
})
.cycle()
.take(instances.len() * 6)

6
graphics/src/font/source.rs
View file

@ -37,3 +37,9 @@ impl Source {
}
}
}
impl Default for Source {
fn default() -> Self {
Self::new()
}
}

6
graphics/src/widget/canvas/path/builder.rs
View file

@ -151,3 +151,9 @@ impl Builder {
}
}
}
impl Default for Builder {
fn default() -> Self {
Self::new()
}
}

8
graphics/src/widget/pure/qr_code.rs
View file

@ -53,12 +53,12 @@ where
}
}
impl<'a, Message, B, T> Into<Element<'a, Message, Renderer<B, T>>>
for QRCode<'a>
impl<'a, Message, B, T> From<QRCode<'a>>
for Element<'a, Message, Renderer<B, T>>
where
B: Backend,
{
fn into(self) -> Element<'a, Message, Renderer<B, T>> {
Element::new(self)
fn from(qr_code: QRCode<'a>) -> Self {
Self::new(qr_code)
}
}

8
graphics/src/widget/qr_code.rs
View file

@ -125,13 +125,13 @@ where
}
}
impl<'a, Message, B, T> Into<Element<'a, Message, Renderer<B, T>>>
for QRCode<'a>
impl<'a, Message, B, T> From<QRCode<'a>>
for Element<'a, Message, Renderer<B, T>>
where
B: Backend,
{
fn into(self) -> Element<'a, Message, Renderer<B, T>> {
Element::new(self)
fn from(qr_code: QRCode<'a>) -> Self {
Self::new(qr_code)
}
}

3
graphics/src/window/gl_compositor.rs
View file

@ -35,6 +35,9 @@ pub trait GLCompositor: Sized {
/// Creates a new [`GLCompositor`] and [`Renderer`] with the given
/// [`Settings`] and an OpenGL address loader function.
///
/// # Safety
/// The `loader_function` should resolve to valid OpenGL bindings.
///
/// [`Renderer`]: crate::Renderer
/// [`Backend`]: crate::Backend
/// [`Settings`]: Self::Settings

2
lazy/src/component.rs
View file

@ -396,7 +396,7 @@ where
&mut local_shell,
)
})
.unwrap_or_else(|| iced_native::event::Status::Ignored);
.unwrap_or(iced_native::event::Status::Ignored);
local_shell.revalidate_layout(|| shell.invalidate_layout());

6
lazy/src/lib.rs
View file

@ -11,7 +11,11 @@
clippy::useless_conversion
)]
#![forbid(unsafe_code)]
#![allow(clippy::inherent_to_string, clippy::type_complexity)]
#![allow(
clippy::await_holding_refcell_ref,
clippy::inherent_to_string,
clippy::type_complexity
)]
#![cfg_attr(docsrs, feature(doc_cfg))]
pub mod component;
pub mod responsive;

2
lazy/src/pure/component.rs
View file

@ -428,7 +428,7 @@ where
&mut local_shell,
)
})
.unwrap_or_else(|| iced_native::event::Status::Ignored);
.unwrap_or(iced_native::event::Status::Ignored);
local_shell.revalidate_layout(|| shell.invalidate_layout());

2
lazy/src/pure/responsive.rs
View file

@ -383,6 +383,6 @@ where
shell,
)
})
.unwrap_or_else(|| iced_native::event::Status::Ignored)
.unwrap_or(iced_native::event::Status::Ignored)
}
}

4
lazy/src/responsive.rs
View file

@ -224,7 +224,7 @@ where
where
R: Deref<Target = Renderer>,
{
self.content.resolve(&mut self.state, renderer, f)
self.content.resolve(self.state, renderer, f)
}
}
@ -405,6 +405,6 @@ where
shell,
)
})
.unwrap_or_else(|| iced_native::event::Status::Ignored)
.unwrap_or(iced_native::event::Status::Ignored)
}
}

6
native/src/debug/basic.rs
View file

@ -186,6 +186,12 @@ impl Debug {
}
}
impl Default for Debug {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug)]
struct TimeBuffer {
head: usize,

8
pure/src/lib.rs
View file

@ -280,13 +280,13 @@ where
}
}
impl<'a, Message, Renderer> Into<iced_native::Element<'a, Message, Renderer>>
for Pure<'a, Message, Renderer>
impl<'a, Message, Renderer> From<Pure<'a, Message, Renderer>>
for iced_native::Element<'a, Message, Renderer>
where
Message: 'a,
Renderer: iced_native::Renderer + 'a,
{
fn into(self) -> iced_native::Element<'a, Message, Renderer> {
iced_native::Element::new(self)
fn from(pure: Pure<'a, Message, Renderer>) -> Self {
Self::new(pure)
}
}

10
pure/src/widget/button.rs
View file

@ -159,7 +159,7 @@ where
self.height,
self.padding,
|renderer, limits| {
self.content.as_widget().layout(renderer, &limits)
self.content.as_widget().layout(renderer, limits)
},
)
}
@ -261,14 +261,14 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Button<'a, Message, Renderer>
impl<'a, Message, Renderer> From<Button<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Message: Clone + 'a,
Renderer: iced_native::Renderer + 'a,
Renderer::Theme: StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(button: Button<'a, Message, Renderer>) -> Self {
Self::new(button)
}
}

8
pure/src/widget/checkbox.rs
View file

@ -96,14 +96,14 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Checkbox<'a, Message, Renderer>
impl<'a, Message, Renderer> From<Checkbox<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Message: 'a,
Renderer: text::Renderer + 'a,
Renderer::Theme: StyleSheet + widget::text::StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(checkbox: Checkbox<'a, Message, Renderer>) -> Self {
Self::new(checkbox)
}
}

14
pure/src/widget/column.rs
View file

@ -95,6 +95,12 @@ impl<'a, Message, Renderer> Column<'a, Message, Renderer> {
}
}
impl<'a, Message, Renderer> Default for Column<'a, Message, Renderer> {
fn default() -> Self {
Self::new()
}
}
impl<'a, Message, Renderer> Widget<Message, Renderer>
for Column<'a, Message, Renderer>
where
@ -228,13 +234,13 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Column<'a, Message, Renderer>
impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Message: 'a,
Renderer: iced_native::Renderer + 'a,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(column: Column<'a, Message, Renderer>) -> Self {
Self::new(column)
}
}

8
pure/src/widget/image.rs
View file

@ -56,14 +56,14 @@ where
}
}
impl<'a, Message, Renderer, Handle> Into<Element<'a, Message, Renderer>>
for Image<Handle>
impl<'a, Message, Renderer, Handle> From<Image<Handle>>
for Element<'a, Message, Renderer>
where
Message: Clone + 'a,
Renderer: iced_native::image::Renderer<Handle = Handle> + 'a,
Handle: Clone + Hash + 'a,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(image: Image<Handle>) -> Self {
Self::new(image)
}
}

8
pure/src/widget/pick_list.rs
View file

@ -225,8 +225,8 @@ where
}
}
impl<'a, T: 'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for PickList<'a, T, Message, Renderer>
impl<'a, T: 'a, Message, Renderer> From<PickList<'a, T, Message, Renderer>>
for Element<'a, Message, Renderer>
where
T: Clone + ToString + Eq + 'static,
[T]: ToOwned<Owned = Vec<T>>,
@ -234,7 +234,7 @@ where
Renderer: text::Renderer + 'a,
Renderer::Theme: StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(pick_list: PickList<'a, T, Message, Renderer>) -> Self {
Self::new(pick_list)
}
}

10
pure/src/widget/progress_bar.rs
View file

@ -10,7 +10,7 @@ use iced_native::{Clipboard, Length, Point, Rectangle, Shell};
pub use iced_native::widget::progress_bar::*;
impl<'a, Message, Renderer> Widget<Message, Renderer> for ProgressBar<Renderer>
impl<Message, Renderer> Widget<Message, Renderer> for ProgressBar<Renderer>
where
Renderer: iced_native::Renderer,
Renderer::Theme: StyleSheet,
@ -93,13 +93,13 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for ProgressBar<Renderer>
impl<'a, Message, Renderer> From<ProgressBar<Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: iced_native::Renderer + 'a,
Renderer::Theme: StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(progress_bar: ProgressBar<Renderer>) -> Self {
Self::new(progress_bar)
}
}

8
pure/src/widget/radio.rs
View file

@ -96,14 +96,14 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Radio<Message, Renderer>
impl<'a, Message, Renderer> From<Radio<Message, Renderer>>
for Element<'a, Message, Renderer>
where
Message: 'a + Clone,
Renderer: text::Renderer + 'a,
Renderer::Theme: StyleSheet + widget::text::StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(radio: Radio<Message, Renderer>) -> Self {
Self::new(radio)
}
}

14
pure/src/widget/row.rs
View file

@ -85,6 +85,12 @@ impl<'a, Message, Renderer> Row<'a, Message, Renderer> {
}
}
impl<'a, Message, Renderer> Default for Row<'a, Message, Renderer> {
fn default() -> Self {
Self::new()
}
}
impl<'a, Message, Renderer> Widget<Message, Renderer>
for Row<'a, Message, Renderer>
where
@ -215,13 +221,13 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Row<'a, Message, Renderer>
impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Message: 'a,
Renderer: iced_native::Renderer + 'a,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(row: Row<'a, Message, Renderer>) -> Self {
Self::new(row)
}
}

10
pure/src/widget/rule.rs
View file

@ -10,7 +10,7 @@ use iced_native::{Clipboard, Length, Point, Rectangle, Shell};
pub use iced_native::widget::rule::*;
impl<'a, Message, Renderer> Widget<Message, Renderer> for Rule<Renderer>
impl<Message, Renderer> Widget<Message, Renderer> for Rule<Renderer>
where
Renderer: iced_native::Renderer,
Renderer::Theme: StyleSheet,
@ -93,13 +93,13 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Rule<Renderer>
impl<'a, Message, Renderer> From<Rule<Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: iced_native::Renderer + 'a,
Renderer::Theme: StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(rule: Rule<Renderer>) -> Self {
Self::new(rule)
}
}

8
pure/src/widget/space.rs
View file

@ -9,7 +9,7 @@ use iced_native::{Clipboard, Length, Point, Rectangle, Shell};
pub use iced_native::widget::Space;
impl<'a, Message, Renderer> Widget<Message, Renderer> for Space
impl<Message, Renderer> Widget<Message, Renderer> for Space
where
Renderer: iced_native::Renderer,
{
@ -91,11 +91,11 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for Space
impl<'a, Message, Renderer> From<Space> for Element<'a, Message, Renderer>
where
Renderer: iced_native::Renderer + 'a,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(space: Space) -> Self {
Self::new(space)
}
}

6
pure/src/widget/svg.rs
View file

@ -54,12 +54,12 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for Svg
impl<'a, Message, Renderer> From<Svg> for Element<'a, Message, Renderer>
where
Message: Clone + 'a,
Renderer: iced_native::svg::Renderer + 'a,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(svg: Svg) -> Self {
Self::new(svg)
}
}

14
pure/src/widget/text.rs
View file

@ -55,23 +55,23 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Text<Renderer>
impl<'a, Message, Renderer> From<Text<Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: text::Renderer + 'a,
Renderer::Theme: widget::text::StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(text: Text<Renderer>) -> Self {
Self::new(text)
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for &'a str
impl<'a, Message, Renderer> From<&'a str> for Element<'a, Message, Renderer>
where
Renderer: text::Renderer + 'a,
Renderer::Theme: widget::text::StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Text::new(self).into()
fn from(contents: &'a str) -> Self {
Text::new(contents).into()
}
}

8
pure/src/widget/toggler.rs
View file

@ -96,14 +96,14 @@ where
}
}
impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
for Toggler<'a, Message, Renderer>
impl<'a, Message, Renderer> From<Toggler<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Message: 'a,
Renderer: text::Renderer + 'a,
Renderer::Theme: StyleSheet + widget::text::StyleSheet,
{
fn into(self) -> Element<'a, Message, Renderer> {
Element::new(self)
fn from(toggler: Toggler<'a, Message, Renderer>) -> Self {
Self::new(toggler)
}
}

1
src/application.rs
View file

@ -215,6 +215,7 @@ pub trait Application: Sized {
where
Self: 'static,
{
#[allow(clippy::needless_update)]
let renderer_settings = crate::renderer::Settings {
default_font: settings.default_font,
default_text_size: settings.default_text_size,

2
wgpu/src/image/raster.rs
View file

@ -103,7 +103,7 @@ impl Cache {
if let Memory::Host(image) = memory {
let (width, height) = image.dimensions();
let entry = atlas.upload(width, height, &image, device, encoder)?;
let entry = atlas.upload(width, height, image, device, encoder)?;
*memory = Memory::Device(entry);
}