skyler
/
egui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use a lot more let-else (#7582)

This commit is contained in:
Emil Ernerfeldt 2025-10-02 19:47:00 +02:00 committed by GitHub
parent 4c1f344ef8
commit bd45406fad
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
45 changed files with 812 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/rust.yml vendored
View File

@ -5,7 +5,7 @@ name: Rust
env:
RUSTFLAGS: -D warnings
RUSTDOCFLAGS: -D warnings
NIGHTLY_VERSION: nightly-2025-04-22
NIGHTLY_VERSION: nightly-2025-09-16
jobs:
fmt-crank-check-test:

15
crates/eframe/src/native/app_icon.rs
View File

@ -14,11 +14,11 @@ pub struct AppTitleIconSetter {
impl AppTitleIconSetter {
pub fn new(title: String, mut icon_data: Option<Arc<IconData>>) -> Self {
if let Some(icon) = &icon_data {
if **icon == IconData::default() {
if let Some(icon) = &icon_data
&& **icon == IconData::default()
{
icon_data = None;
}
}
Self {
title,
@ -275,14 +275,13 @@ fn set_title_and_icon_mac(title: &str, icon_data: Option<&IconData>) -> AppIconS
}
// Change the title in the top bar - for python processes this would be again "python" otherwise.
if let Some(main_menu) = app.mainMenu() {
if let Some(item) = main_menu.itemAtIndex(0) {
if let Some(app_menu) = item.submenu() {
if let Some(main_menu) = app.mainMenu()
&& let Some(item) = main_menu.itemAtIndex(0)
&& let Some(app_menu) = item.submenu()
{
profiling::scope!("setTitle_");
app_menu.setTitle(&NSString::from_str(title));
}
}
}
// The title in the Dock apparently can't be changed.
// At least these people didn't figure it out either:

11
crates/eframe/src/native/epi_integration.rs
View File

@ -52,15 +52,14 @@ pub fn viewport_builder(
viewport_builder = viewport_builder.with_position(pos);
}
if clamp_size_to_monitor_size {
if let Some(initial_window_size) = viewport_builder.inner_size {
if clamp_size_to_monitor_size && let Some(initial_window_size) = viewport_builder.inner_size
{
let initial_window_size = egui::NumExt::at_most(
initial_window_size,
largest_monitor_point_size(egui_zoom_factor, event_loop),
);
viewport_builder = viewport_builder.with_inner_size(initial_window_size);
}
}
viewport_builder.inner_size
};
@ -332,8 +331,9 @@ impl EpiIntegration {
if let Some(storage) = self.frame.storage_mut() {
profiling::function_scope!();
if let Some(window) = _window {
if self.persist_window {
if let Some(window) = _window
&& self.persist_window
{
profiling::scope!("native_window");
epi::set_value(
storage,
@ -341,7 +341,6 @@ impl EpiIntegration {
&WindowSettings::from_window(self.egui_ctx.zoom_factor(), window),
);
}
}
if _app.persist_egui_memory() {
profiling::scope!("egui_memory");
self.egui_ctx

9
crates/eframe/src/native/file_storage.rs
View File

@ -193,13 +193,12 @@ impl crate::Storage for FileStorage {
fn save_to_disk(file_path: &PathBuf, kv: &HashMap<String, String>) {
profiling::function_scope!();
if let Some(parent_dir) = file_path.parent() {
if !parent_dir.exists() {
if let Err(err) = std::fs::create_dir_all(parent_dir) {
if let Some(parent_dir) = file_path.parent()
&& !parent_dir.exists()
&& let Err(err) = std::fs::create_dir_all(parent_dir)
{
log::warn!("Failed to create directory {parent_dir:?}: {err}");
}
}
}
match std::fs::File::create(file_path) {
Ok(file) => {

49
crates/eframe/src/native/glow_integration.rs
View File

@ -281,11 +281,10 @@ impl<'app> GlowWinitApp<'app> {
.viewport
.mouse_passthrough
.unwrap_or(false)
&& let Err(err) = glutin.window(ViewportId::ROOT).set_cursor_hittest(false)
{
if let Err(err) = glutin.window(ViewportId::ROOT).set_cursor_hittest(false) {
log::warn!("set_cursor_hittest(false) failed: {err}");
}
}
let app_creator = std::mem::take(&mut self.app_creator)
.expect("Single-use AppCreator has unexpectedly already been taken");
@ -440,8 +439,9 @@ impl WinitApp for GlowWinitApp<'_> {
_: winit::event::DeviceId,
event: winit::event::DeviceEvent,
) -> crate::Result<EventResult> {
if let winit::event::DeviceEvent::MouseMotion { delta } = event {
if let Some(running) = &mut self.running {
if let winit::event::DeviceEvent::MouseMotion { delta } = event
&& let Some(running) = &mut self.running
{
let mut glutin = running.glutin.borrow_mut();
if let Some(viewport) = glutin
.focused_viewport
@ -456,7 +456,6 @@ impl WinitApp for GlowWinitApp<'_> {
}
}
}
}
Ok(EventResult::Wait)
}
@ -480,9 +479,10 @@ impl WinitApp for GlowWinitApp<'_> {
if let Some(running) = &self.running {
let mut glutin = running.glutin.borrow_mut();
if let Some(viewport_id) = glutin.viewport_from_window.get(&event.window_id).copied() {
if let Some(viewport) = glutin.viewports.get_mut(&viewport_id) {
if let Some(egui_winit) = &mut viewport.egui_winit {
if let Some(viewport_id) = glutin.viewport_from_window.get(&event.window_id).copied()
&& let Some(viewport) = glutin.viewports.get_mut(&viewport_id)
&& let Some(egui_winit) = &mut viewport.egui_winit
{
return Ok(winit_integration::on_accesskit_window_event(
egui_winit,
event.window_id,
@ -490,8 +490,6 @@ impl WinitApp for GlowWinitApp<'_> {
));
}
}
}
}
Ok(EventResult::Wait)
}
@ -527,11 +525,11 @@ impl GlowWinitRunning<'_> {
if is_immediate && viewport_id != ViewportId::ROOT {
// This will only happen if this is an immediate viewport.
// That means that the viewport cannot be rendered by itself and needs his parent to be rendered.
if let Some(parent_viewport) = glutin.viewports.get(&viewport.ids.parent) {
if let Some(window) = parent_viewport.window.as_ref() {
if let Some(parent_viewport) = glutin.viewports.get(&viewport.ids.parent)
&& let Some(window) = parent_viewport.window.as_ref()
{
return Ok(EventResult::RepaintNext(window.id()));
}
}
return Ok(EventResult::Wait);
}
}
@ -727,11 +725,11 @@ impl GlowWinitRunning<'_> {
// give it time to settle:
#[cfg(feature = "__screenshot")]
if integration.egui_ctx.cumulative_pass_nr() == 2 {
if let Ok(path) = std::env::var("EFRAME_SCREENSHOT_TO") {
if integration.egui_ctx.cumulative_pass_nr() == 2
&& let Ok(path) = std::env::var("EFRAME_SCREENSHOT_TO")
{
save_screenshot_and_exit(&path, &painter, screen_size_in_pixels);
}
}
glutin.handle_viewport_output(event_loop, &integration.egui_ctx, &viewport_output);
@ -785,13 +783,14 @@ impl GlowWinitRunning<'_> {
// Resize with 0 width and height is used by winit to signal a minimize event on Windows.
// See: https://github.com/rust-windowing/winit/issues/208
// This solves an issue where the app would panic when minimizing on Windows.
if 0 < physical_size.width && 0 < physical_size.height {
if let Some(viewport_id) = viewport_id {
if 0 < physical_size.width
&& 0 < physical_size.height
&& let Some(viewport_id) = viewport_id
{
repaint_asap = true;
glutin.resize(viewport_id, *physical_size);
}
}
}
winit::event::WindowEvent::CloseRequested => {
if viewport_id == Some(ViewportId::ROOT) && self.integration.should_close() {
@ -803,8 +802,9 @@ impl GlowWinitRunning<'_> {
log::debug!("Received WindowEvent::CloseRequested for viewport {viewport_id:?}");
if let Some(viewport_id) = viewport_id {
if let Some(viewport) = glutin.viewports.get_mut(&viewport_id) {
if let Some(viewport_id) = viewport_id
&& let Some(viewport) = glutin.viewports.get_mut(&viewport_id)
{
// Tell viewport it should close:
viewport.info.events.push(egui::ViewportEvent::Close);
@ -817,7 +817,6 @@ impl GlowWinitRunning<'_> {
.request_repaint_of(viewport.ids.parent);
}
}
}
_ => {}
}
@ -1232,8 +1231,9 @@ impl GlutinWindowContext {
let width_px = NonZeroU32::new(physical_size.width).unwrap_or(NonZeroU32::MIN);
let height_px = NonZeroU32::new(physical_size.height).unwrap_or(NonZeroU32::MIN);
if let Some(viewport) = self.viewports.get(&viewport_id) {
if let Some(gl_surface) = &viewport.gl_surface {
if let Some(viewport) = self.viewports.get(&viewport_id)
&& let Some(gl_surface) = &viewport.gl_surface
{
change_gl_context(
&mut self.current_gl_context,
&mut self.not_current_gl_context,
@ -1248,7 +1248,6 @@ impl GlutinWindowContext {
);
}
}
}
fn get_proc_address(&self, addr: &std::ffi::CStr) -> *const std::ffi::c_void {
self.gl_config.display().get_proc_address(addr)

6
crates/eframe/src/native/run.rs
View File

@ -94,8 +94,9 @@ impl<T: WinitApp> WinitAppWrapper<T> {
let mut event_result = event_result;
if cfg!(target_os = "windows") {
if let Ok(EventResult::RepaintNow(window_id)) = event_result {
if cfg!(target_os = "windows")
&& let Ok(EventResult::RepaintNow(window_id)) = event_result
{
log::trace!("RepaintNow of {window_id:?}");
self.windows_next_repaint_times
.insert(window_id, Instant::now());
@ -103,7 +104,6 @@ impl<T: WinitApp> WinitAppWrapper<T> {
// Fix flickering on Windows, see https://github.com/emilk/egui/pull/2280
event_result = self.winit_app.run_ui_and_paint(event_loop, window_id);
}
}
let combined_result = event_result.map(|event_result| match event_result {
EventResult::Wait => {

43
crates/eframe/src/native/wgpu_integration.rs
View File

@ -429,8 +429,9 @@ impl WinitApp for WgpuWinitApp<'_> {
_: winit::event::DeviceId,
event: winit::event::DeviceEvent,
) -> crate::Result<EventResult> {
if let winit::event::DeviceEvent::MouseMotion { delta } = event {
if let Some(running) = &mut self.running {
if let winit::event::DeviceEvent::MouseMotion { delta } = event
&& let Some(running) = &mut self.running
{
let mut shared = running.shared.borrow_mut();
if let Some(viewport) = shared
.focused_viewport
@ -445,7 +446,6 @@ impl WinitApp for WgpuWinitApp<'_> {
}
}
}
}
Ok(EventResult::Wait)
}
@ -478,8 +478,8 @@ impl WinitApp for WgpuWinitApp<'_> {
if let Some(viewport) = viewport_from_window
.get(&event.window_id)
.and_then(|id| viewports.get_mut(id))
&& let Some(egui_winit) = &mut viewport.egui_winit
{
if let Some(egui_winit) = &mut viewport.egui_winit {
return Ok(winit_integration::on_accesskit_window_event(
egui_winit,
event.window_id,
@ -487,7 +487,6 @@ impl WinitApp for WgpuWinitApp<'_> {
));
}
}
}
Ok(EventResult::Wait)
}
@ -563,11 +562,11 @@ impl WgpuWinitRunning<'_> {
if viewport.viewport_ui_cb.is_none() {
// This will only happen if this is an immediate viewport.
// That means that the viewport cannot be rendered by itself and needs his parent to be rendered.
if let Some(viewport) = viewports.get(&viewport.ids.parent) {
if let Some(window) = viewport.window.as_ref() {
if let Some(viewport) = viewports.get(&viewport.ids.parent)
&& let Some(window) = viewport.window.as_ref()
{
return Ok(EventResult::RepaintNext(window.id()));
}
}
return Ok(EventResult::Wait);
}
}
@ -730,14 +729,14 @@ impl WgpuWinitRunning<'_> {
integration.maybe_autosave(app.as_mut(), window.map(|w| w.as_ref()));
if let Some(window) = window {
if window.is_minimized() == Some(true) {
if let Some(window) = window
&& window.is_minimized() == Some(true)
{
// On Mac, a minimized Window uses up all CPU:
// https://github.com/emilk/egui/issues/325
profiling::scope!("minimized_sleep");
std::thread::sleep(std::time::Duration::from_millis(10));
}
}
if integration.should_close() {
Ok(EventResult::CloseRequested)
@ -784,16 +783,16 @@ impl WgpuWinitRunning<'_> {
// Resize with 0 width and height is used by winit to signal a minimize event on Windows.
// See: https://github.com/rust-windowing/winit/issues/208
// This solves an issue where the app would panic when minimizing on Windows.
if let Some(viewport_id) = viewport_id {
if let (Some(width), Some(height)) = (
if let Some(viewport_id) = viewport_id
&& let (Some(width), Some(height)) = (
NonZeroU32::new(physical_size.width),
NonZeroU32::new(physical_size.height),
) {
)
{
repaint_asap = true;
shared.painter.on_window_resized(viewport_id, width, height);
}
}
}
winit::event::WindowEvent::CloseRequested => {
if viewport_id == Some(ViewportId::ROOT) && integration.should_close() {
@ -805,8 +804,9 @@ impl WgpuWinitRunning<'_> {
log::debug!("Received WindowEvent::CloseRequested for viewport {viewport_id:?}");
if let Some(viewport_id) = viewport_id {
if let Some(viewport) = shared.viewports.get_mut(&viewport_id) {
if let Some(viewport_id) = viewport_id
&& let Some(viewport) = shared.viewports.get_mut(&viewport_id)
{
// Tell viewport it should close:
viewport.info.events.push(egui::ViewportEvent::Close);
@ -817,7 +817,6 @@ impl WgpuWinitRunning<'_> {
integration.egui_ctx.request_repaint_of(viewport.ids.parent);
}
}
}
_ => {}
}
@ -1087,17 +1086,17 @@ fn handle_viewport_output(
// For Wayland : https://github.com/emilk/egui/issues/4196
if cfg!(target_os = "linux") {
let new_inner_size = window.inner_size();
if new_inner_size != old_inner_size {
if let (Some(width), Some(height)) = (
if new_inner_size != old_inner_size
&& let (Some(width), Some(height)) = (
NonZeroU32::new(new_inner_size.width),
NonZeroU32::new(new_inner_size.height),
) {
)
{
painter.on_window_resized(viewport_id, width, height);
}
}
}
}
}
remove_viewports_not_in(viewports, painter, viewport_from_window, viewport_output);
}

10
crates/egui-wgpu/src/winit.rs
View File

@ -498,8 +498,7 @@ impl Painter {
&screen_descriptor,
);
if capture {
if let Some(capture_state) = &mut self.screen_capture_state {
if capture && let Some(capture_state) = &mut self.screen_capture_state {
capture_buffer = Some(capture_state.copy_textures(
&render_state.device,
&output_frame,
@ -507,7 +506,6 @@ impl Painter {
));
}
}
}
let encoded = {
profiling::scope!("CommandEncoder::finish");
@ -535,8 +533,9 @@ impl Painter {
}
}
if let Some(capture_buffer) = capture_buffer {
if let Some(screen_capture_state) = &mut self.screen_capture_state {
if let Some(capture_buffer) = capture_buffer
&& let Some(screen_capture_state) = &mut self.screen_capture_state
{
screen_capture_state.read_screen_rgba(
self.context.clone(),
capture_buffer,
@ -545,7 +544,6 @@ impl Painter {
viewport_id,
);
}
}
{
profiling::scope!("present");

29
crates/egui-winit/src/lib.rs
View File

@ -574,8 +574,9 @@ impl State {
state: winit::event::ElementState,
button: winit::event::MouseButton,
) {
if let Some(pos) = self.pointer_pos_in_points {
if let Some(button) = translate_mouse_button(button) {
if let Some(pos) = self.pointer_pos_in_points
&& let Some(button) = translate_mouse_button(button)
{
let pressed = state == winit::event::ElementState::Pressed;
self.egui_input.events.push(egui::Event::PointerButton {
@ -612,7 +613,6 @@ impl State {
}
}
}
}
fn on_cursor_moved(
&mut self,
@ -913,13 +913,13 @@ impl State {
}
#[cfg(feature = "accesskit")]
if let Some(accesskit) = self.accesskit.as_mut() {
if let Some(update) = accesskit_update {
if let Some(accesskit) = self.accesskit.as_mut()
&& let Some(update) = accesskit_update
{
profiling::scope!("accesskit");
accesskit.update_if_active(|| update);
}
}
}
fn set_cursor_icon(&mut self, window: &Window, cursor_icon: egui::CursorIcon) {
if self.current_cursor_icon == Some(cursor_icon) {
@ -1378,12 +1378,12 @@ fn process_viewport_command(
}
ViewportCommand::StartDrag => {
// If `.has_focus()` is not checked on x11 the input will be permanently taken until the app is killed!
if window.has_focus() {
if let Err(err) = window.drag_window() {
if window.has_focus()
&& let Err(err) = window.drag_window()
{
log::warn!("{command:?}: {err}");
}
}
}
ViewportCommand::InnerSize(size) => {
let width_px = pixels_per_point * size.x.max(1.0);
let height_px = pixels_per_point * size.y.max(1.0);
@ -1795,11 +1795,11 @@ pub fn apply_viewport_builder_to_window(
window: &Window,
builder: &ViewportBuilder,
) {
if let Some(mouse_passthrough) = builder.mouse_passthrough {
if let Err(err) = window.set_cursor_hittest(!mouse_passthrough) {
if let Some(mouse_passthrough) = builder.mouse_passthrough
&& let Err(err) = window.set_cursor_hittest(!mouse_passthrough)
{
log::warn!("set_cursor_hittest failed: {err}");
}
}
{
// In `create_winit_window_builder` we didn't know
@ -1809,8 +1809,8 @@ pub fn apply_viewport_builder_to_window(
let pixels_per_point = pixels_per_point(egui_ctx, window);
if let Some(size) = builder.inner_size {
if window
if let Some(size) = builder.inner_size
&& window
.request_inner_size(PhysicalSize::new(
pixels_per_point * size.x,
pixels_per_point * size.y,
@ -1819,7 +1819,6 @@ pub fn apply_viewport_builder_to_window(
{
log::debug!("Failed to set window size");
}
}
if let Some(size) = builder.min_inner_size {
window.set_min_inner_size(Some(PhysicalSize::new(
pixels_per_point * size.x,

6
crates/egui/src/callstack.rs
View File

@ -20,11 +20,11 @@ pub fn capture() -> String {
backtrace::resolve_frame(frame, |symbol| {
let mut file_and_line = symbol.filename().map(shorten_source_file_path);
if let Some(file_and_line) = &mut file_and_line {
if let Some(line_nr) = symbol.lineno() {
if let Some(file_and_line) = &mut file_and_line
&& let Some(line_nr) = symbol.lineno()
{
file_and_line.push_str(&format!(":{line_nr}"));
}
}
let file_and_line = file_and_line.unwrap_or_default();
let name = symbol

13
crates/egui/src/containers/area.rs
View File

@ -525,11 +525,12 @@ impl Area {
true,
);
if movable && move_response.dragged() {
if let Some(pivot_pos) = &mut state.pivot_pos {
if movable
&& move_response.dragged()
&& let Some(pivot_pos) = &mut state.pivot_pos
{
*pivot_pos += move_response.drag_delta();
}
}
if (move_response.dragged() || move_response.clicked())
|| pointer_pressed_on_area(ctx, layer_id)
@ -606,8 +607,9 @@ impl Prepared {
let mut ui = Ui::new(ctx.clone(), self.layer_id.id, ui_builder);
ui.set_clip_rect(self.constrain_rect); // Don't paint outside our bounds
if self.fade_in {
if let Some(last_became_visible_at) = self.state.last_became_visible_at {
if self.fade_in
&& let Some(last_became_visible_at) = self.state.last_became_visible_at
{
let age =
ctx.input(|i| (i.time - last_became_visible_at) as f32 + i.predicted_dt / 2.0);
let opacity = crate::remap_clamp(age, 0.0..=ctx.style().animation_time, 0.0..=1.0);
@ -617,7 +619,6 @@ impl Prepared {
ctx.request_repaint();
}
}
}
ui
}

11
crates/egui/src/containers/panel.rs
View File

@ -266,15 +266,13 @@ impl SidePanel {
resize_hover = resize_response.hovered();
is_resizing = resize_response.dragged();
if is_resizing {
if let Some(pointer) = resize_response.interact_pointer_pos() {
if is_resizing && let Some(pointer) = resize_response.interact_pointer_pos() {
width = (pointer.x - side.side_x(panel_rect)).abs();
width = clamp_to_range(width, width_range).at_most(available_rect.width());
side.set_rect_width(&mut panel_rect, width);
}
}
}
}
panel_rect = panel_rect.round_ui();
@ -765,16 +763,13 @@ impl TopBottomPanel {
resize_hover = resize_response.hovered();
is_resizing = resize_response.dragged();
if is_resizing {
if let Some(pointer) = resize_response.interact_pointer_pos() {
if is_resizing && let Some(pointer) = resize_response.interact_pointer_pos() {
height = (pointer.y - side.side_y(panel_rect)).abs();
height =
clamp_to_range(height, height_range).at_most(available_rect.height());
height = clamp_to_range(height, height_range).at_most(available_rect.height());
side.set_rect_height(&mut panel_rect, height);
}
}
}
}
panel_rect = panel_rect.round_ui();

12
crates/egui/src/containers/resize.rs
View File

@ -241,14 +241,12 @@ impl Resize {
let corner_id = self.resizable.any().then(|| id.with("__resize_corner"));
if let Some(corner_id) = corner_id {
if let Some(corner_response) = ui.ctx().read_response(corner_id) {
if let Some(pointer_pos) = corner_response.interact_pointer_pos() {
if let Some(corner_id) = corner_id
&& let Some(corner_response) = ui.ctx().read_response(corner_id)
&& let Some(pointer_pos) = corner_response.interact_pointer_pos()
{
// Respond to the interaction early to avoid frame delay.
user_requested_size =
Some(pointer_pos - position + 0.5 * corner_response.rect.size());
}
}
user_requested_size = Some(pointer_pos - position + 0.5 * corner_response.rect.size());
}
if let Some(user_requested_size) = user_requested_size {

6
crates/egui/src/containers/scene.rs
View File

@ -240,8 +240,9 @@ impl Scene {
resp.mark_changed();
}
if let Some(mouse_pos) = ui.input(|i| i.pointer.latest_pos()) {
if resp.contains_pointer() {
if let Some(mouse_pos) = ui.input(|i| i.pointer.latest_pos())
&& resp.contains_pointer()
{
let pointer_in_scene = to_global.inverse() * mouse_pos;
let zoom_delta = ui.ctx().input(|i| i.zoom_delta());
let pan_delta = ui.ctx().input(|i| i.smooth_scroll_delta);
@ -273,5 +274,4 @@ impl Scene {
resp.mark_changed();
}
}
}
}

6
crates/egui/src/containers/scroll_area.rs
View File

@ -829,13 +829,13 @@ impl ScrollArea {
if let Some(cursor) = on_drag_cursor {
response.on_hover_cursor(cursor);
}
} else if response.hovered() {
if let Some(cursor) = on_hover_cursor {
} else if response.hovered()
&& let Some(cursor) = on_hover_cursor
{
response.on_hover_cursor(cursor);
}
}
}
}
// Scroll with an animation if we have a target offset (that hasn't been cleared by the code
// above).

12
crates/egui/src/containers/window.rs
View File

@ -645,11 +645,11 @@ impl Window<'_> {
let full_response = area.end(ctx, area_content_ui);
if full_response.should_close() {
if let Some(open) = open {
if full_response.should_close()
&& let Some(open) = open
{
*open = false;
}
}
let inner_response = InnerResponse {
inner: content_inner,
@ -839,12 +839,12 @@ fn resize_response(
// TODO(emilk): add this to a Window state instead as a command "move here next frame"
area.state_mut().set_left_top_pos(new_rect.left_top());
if resize_interaction.any_dragged() {
if let Some(mut state) = resize::State::load(ctx, resize_id) {
if resize_interaction.any_dragged()
&& let Some(mut state) = resize::State::load(ctx, resize_id)
{
state.requested_size = Some(new_rect.size() - margins);
state.store(ctx, resize_id);
}
}
ctx.memory_mut(|mem| mem.areas_mut().move_to_top(area_layer_id));
}

21
crates/egui/src/context.rs
View File

@ -426,8 +426,7 @@ impl ContextImpl {
let viewport = self.viewports.entry(viewport_id).or_default();
if is_outermost_viewport {
if let Some(new_zoom_factor) = self.new_zoom_factor.take() {
if is_outermost_viewport && let Some(new_zoom_factor) = self.new_zoom_factor.take() {
let ratio = self.memory.options.zoom_factor / new_zoom_factor;
self.memory.options.zoom_factor = new_zoom_factor;
@ -440,7 +439,6 @@ impl ContextImpl {
// We should really scale everything else in the input too,
// but the `screen_rect` is the most important part.
}
}
let native_pixels_per_point = new_raw_input
.viewport()
.native_pixels_per_point
@ -1105,8 +1103,9 @@ impl Context {
)
};
if let Some(pointer_pos) = self.pointer_hover_pos() {
if text_rect.contains(pointer_pos) {
if let Some(pointer_pos) = self.pointer_hover_pos()
&& text_rect.contains(pointer_pos)
{
let tooltip_pos = if below {
text_rect.left_bottom() + vec2(2.0, 4.0)
} else {
@ -1122,7 +1121,6 @@ impl Context {
if below { "above" } else { "below" }),
);
}
}
};
let id_str = id.short_debug_format();
@ -1253,11 +1251,11 @@ impl Context {
widget_rect.map(|mut rect| {
// If the Rect is invalid the Ui hasn't registered its final Rect yet.
// We return the Rect from last frame instead.
if !(rect.rect.is_positive() && rect.rect.is_finite()) {
if let Some(prev_rect) = viewport.prev_pass.widgets.get(id) {
if !(rect.rect.is_positive() && rect.rect.is_finite())
&& let Some(prev_rect) = viewport.prev_pass.widgets.get(id)
{
rect.rect = prev_rect.rect;
}
}
rect
})
})
@ -1961,15 +1959,14 @@ impl Context {
let mut update_fonts = true;
self.read(|ctx| {
if let Some(current_fonts) = ctx.fonts.as_ref() {
if current_fonts
if let Some(current_fonts) = ctx.fonts.as_ref()
&& current_fonts
.definitions()
.font_data
.contains_key(&new_font.name)
{
update_fonts = false; // no need to update
}
}
});
if update_fonts {

11
crates/egui/src/hit_test.rs
View File

@ -317,8 +317,8 @@ fn hit_test_on_close(close: &[WidgetRect], pos: Pos2) -> WidgetHits {
pos,
);
if let Some(closest_drag) = closest_drag {
if hit_drag
if let Some(closest_drag) = closest_drag
&& hit_drag
.interact_rect
.contains_rect(closest_drag.interact_rect)
{
@ -330,7 +330,6 @@ fn hit_test_on_close(close: &[WidgetRect], pos: Pos2) -> WidgetHits {
..Default::default()
};
}
}
WidgetHits {
click: None,
@ -425,15 +424,15 @@ fn find_closest_within(
let dist_sq = widget.interact_rect.distance_sq_to_pos(pos);
if let Some(closest) = closest {
if dist_sq == closest_dist_sq {
if let Some(closest) = closest
&& dist_sq == closest_dist_sq
{
// It's a tie! Pick the thin candidate over the thick one.
// This makes it easier to hit a thin resize-handle, for instance:
if should_prioritize_hits_on_back(closest.interact_rect, widget.interact_rect) {
continue;
}
}
}
// In case of a tie, take the last one = the one on top.
if dist_sq <= closest_dist_sq {

19
crates/egui/src/input_state/mod.rs
View File

@ -884,11 +884,12 @@ impl InputState {
) -> impl Iterator<Item = &accesskit::ActionRequest> {
let accesskit_id = id.accesskit_id();
self.events.iter().filter_map(move |event| {
if let Event::AccessKitActionRequest(request) = event {
if request.target == accesskit_id && request.action == action {
if let Event::AccessKitActionRequest(request) = event
&& request.target == accesskit_id
&& request.action == action
{
return Some(request);
}
}
None
})
}
@ -901,11 +902,11 @@ impl InputState {
) {
let accesskit_id = id.accesskit_id();
self.events.retain(|event| {
if let Event::AccessKitActionRequest(request) = event {
if request.target == accesskit_id {
if let Event::AccessKitActionRequest(request) = event
&& request.target == accesskit_id
{
return !consume(request);
}
}
true
});
}
@ -1468,11 +1469,11 @@ impl PointerState {
return false;
}
if let Some(press_start_time) = self.press_start_time {
if self.time - press_start_time > self.options.max_click_duration {
if let Some(press_start_time) = self.press_start_time
&& self.time - press_start_time > self.options.max_click_duration
{
return false;
}
}
true
} else {

24
crates/egui/src/interaction.rs
View File

@ -115,20 +115,20 @@ pub(crate) fn interact(
) -> InteractionSnapshot {
profiling::function_scope!();
if let Some(id) = interaction.potential_click_id {
if !widgets.contains(id) {
if let Some(id) = interaction.potential_click_id
&& !widgets.contains(id)
{
// The widget we were interested in clicking is gone.
interaction.potential_click_id = None;
}
}
if let Some(id) = interaction.potential_drag_id {
if !widgets.contains(id) {
if let Some(id) = interaction.potential_drag_id
&& !widgets.contains(id)
{
// The widget we were interested in dragging is gone.
// This is fine! This could be drag-and-drop,
// and the widget being dragged is now "in the air" and thus
// not registered in the new frame.
}
}
let mut clicked = None;
let mut dragged = prev_snapshot.dragged;
@ -172,14 +172,14 @@ pub(crate) fn interact(
}
PointerEvent::Released { click, button: _ } => {
if click.is_some() && !input.pointer.is_decidedly_dragging() {
if let Some(widget) = interaction
if click.is_some()
&& !input.pointer.is_decidedly_dragging()
&& let Some(widget) = interaction
.potential_click_id
.and_then(|id| widgets.get(id))
{
clicked = Some(widget.id);
}
}
interaction.potential_drag_id = None;
interaction.potential_click_id = None;
@ -190,8 +190,9 @@ pub(crate) fn interact(
if dragged.is_none() {
// Check if we started dragging something new:
if let Some(widget) = interaction.potential_drag_id.and_then(|id| widgets.get(id)) {
if widget.enabled {
if let Some(widget) = interaction.potential_drag_id.and_then(|id| widgets.get(id))
&& widget.enabled
{
let is_dragged = if widget.sense.senses_click() && widget.sense.senses_drag() {
// This widget is sensitive to both clicks and drags.
// When the mouse first is pressed, it could be either,
@ -207,7 +208,6 @@ pub(crate) fn interact(
}
}
}
}
if !input.pointer.could_any_button_be_click() {
interaction.potential_click_id = None;

6
crates/egui/src/layers.rs
View File

@ -236,8 +236,9 @@ impl GraphicLayers {
// First do the layers part of area_order:
for layer_id in area_order {
if layer_id.order == order {
if let Some(list) = order_map.get_mut(&layer_id.id) {
if layer_id.order == order
&& let Some(list) = order_map.get_mut(&layer_id.id)
{
if let Some(to_global) = to_global.get(layer_id) {
for clipped_shape in &mut list.0 {
clipped_shape.transform(*to_global);
@ -246,7 +247,6 @@ impl GraphicLayers {
all_shapes.append(&mut list.0);
}
}
}
// Also draw areas that are missing in `area_order`:
// NOTE: We don't think we end up here in normal situations.

48
crates/egui/src/memory/mod.rs
View File

@ -535,15 +535,14 @@ impl Focus {
self.focus_direction = FocusDirection::None;
for event in &new_input.events {
if !event_filter.matches(event) {
if let crate::Event::Key {
if !event_filter.matches(event)
&& let crate::Event::Key {
key,
pressed: true,
modifiers,
..
} = event
{
if let Some(cardinality) = match key {
&& let Some(cardinality) = match key {
crate::Key::ArrowUp => Some(FocusDirection::Up),
crate::Key::ArrowRight => Some(FocusDirection::Right),
crate::Key::ArrowDown => Some(FocusDirection::Down),
@ -561,11 +560,10 @@ impl Focus {
Some(FocusDirection::None)
}
_ => None,
} {
}
{
self.focus_direction = cardinality;
}
}
}
#[cfg(feature = "accesskit")]
{
@ -582,11 +580,11 @@ impl Focus {
}
pub(crate) fn end_pass(&mut self, used_ids: &IdMap<Rect>) {
if self.focus_direction.is_cardinal() {
if let Some(found_widget) = self.find_widget_in_direction(used_ids) {
if self.focus_direction.is_cardinal()
&& let Some(found_widget) = self.find_widget_in_direction(used_ids)
{
self.focused_widget = Some(FocusWidget::new(found_widget));
}
}
if let Some(focused_widget) = self.focused_widget {
// Allow calling `request_focus` one frame and not using it until next frame
@ -858,14 +856,14 @@ impl Memory {
///
/// You must first give focus to the widget before calling this.
pub fn set_focus_lock_filter(&mut self, id: Id, event_filter: EventFilter) {
if self.had_focus_last_frame(id) && self.has_focus(id) {
if let Some(focused) = &mut self.focus_mut().focused_widget {
if focused.id == id {
if self.had_focus_last_frame(id)
&& self.has_focus(id)
&& let Some(focused) = &mut self.focus_mut().focused_widget
&& focused.id == id
{
focused.filter = event_filter;
}
}
}
}
/// Give keyboard focus to a specific widget.
/// See also [`crate::Response::request_focus`].
@ -933,14 +931,14 @@ impl Memory {
/// Limit focus to widgets on the given layer and above.
/// If this is called multiple times per frame, the top layer wins.
pub fn set_modal_layer(&mut self, layer_id: LayerId) {
if let Some(current) = self.focus().and_then(|f| f.top_modal_layer_current_frame) {
if matches!(
if let Some(current) = self.focus().and_then(|f| f.top_modal_layer_current_frame)
&& matches!(
self.areas().compare_order(layer_id, current),
std::cmp::Ordering::Less
) {
)
{
return;
}
}
self.focus_mut().set_modal_layer(layer_id);
}
@ -1047,12 +1045,12 @@ impl Memory {
/// being rendered.
#[deprecated = "Use Popup::show instead"]
pub fn keep_popup_open(&mut self, popup_id: Id) {
if let Some(state) = self.popups.get_mut(&self.viewport_id) {
if state.id == popup_id {
if let Some(state) = self.popups.get_mut(&self.viewport_id)
&& state.id == popup_id
{
state.open_this_frame = true;
}
}
}
/// Open the popup and remember its position.
#[deprecated = "Use Popup with PopupAnchor::Position instead"]
@ -1200,8 +1198,9 @@ impl Areas {
layer_to_global: &HashMap<LayerId, TSTransform>,
) -> Option<LayerId> {
for layer in self.order.iter().rev() {
if self.is_visible(layer) {
if let Some(state) = self.areas.get(&layer.id) {
if self.is_visible(layer)
&& let Some(state) = self.areas.get(&layer.id)
{
let mut rect = state.rect();
if state.interactable {
if let Some(to_global) = layer_to_global.get(layer) {
@ -1214,7 +1213,6 @@ impl Areas {
}
}
}
}
None
}

21
crates/egui/src/menu.rs
View File

@ -420,19 +420,16 @@ impl MenuRoot {
} else if button
.ctx
.input(|i| i.pointer.any_pressed() && i.pointer.primary_down())
&& let Some(pos) = button.ctx.input(|i| i.pointer.interact_pos())
&& let Some(root) = root.inner.as_mut()
&& root.id == id
{
if let Some(pos) = button.ctx.input(|i| i.pointer.interact_pos()) {
if let Some(root) = root.inner.as_mut() {
if root.id == id {
// pressed somewhere while this menu is open
let in_menu = root.menu_state.read().area_contains(pos);
if !in_menu {
return MenuResponse::Close;
}
}
}
}
}
MenuResponse::Stay
}
@ -728,22 +725,22 @@ impl MenuState {
return false;
}
if let Some(sub_menu) = self.current_submenu() {
if let Some(pos) = pointer.hover_pos() {
if let Some(sub_menu) = self.current_submenu()
&& let Some(pos) = pointer.hover_pos()
{
let rect = sub_menu.read().rect;
return rect.intersects_ray(pos, pointer.direction().normalized());
}
}
false
}
/// Check if pointer is hovering current submenu.
fn hovering_current_submenu(&self, pointer: &PointerState) -> bool {
if let Some(sub_menu) = self.current_submenu() {
if let Some(pos) = pointer.hover_pos() {
if let Some(sub_menu) = self.current_submenu()
&& let Some(pos) = pointer.hover_pos()
{
return sub_menu.read().area_contains(pos);
}
}
false
}

22
crates/egui/src/text_selection/label_text_selection.rs
View File

@ -316,10 +316,11 @@ impl LabelSelectionState {
let may_select_widget =
multi_widget_text_select || selection.primary.widget_id == response.id;
if self.is_dragging && may_select_widget {
if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
let galley_rect =
global_from_galley * Rect::from_min_size(Pos2::ZERO, galley.size());
if self.is_dragging
&& may_select_widget
&& let Some(pointer_pos) = ui.ctx().pointer_interact_pos()
{
let galley_rect = global_from_galley * Rect::from_min_size(Pos2::ZERO, galley.size());
let galley_rect = galley_rect.intersect(ui.clip_rect());
let is_in_same_column = galley_rect
@ -387,7 +388,6 @@ impl LabelSelectionState {
}
}
}
}
let has_primary = response.id == selection.primary.widget_id;
let has_secondary = response.id == selection.secondary.widget_id;
@ -511,8 +511,9 @@ impl LabelSelectionState {
let old_range = cursor_state.range(galley);
if let Some(pointer_pos) = ui.ctx().pointer_interact_pos() {
if response.contains_pointer() {
if let Some(pointer_pos) = ui.ctx().pointer_interact_pos()
&& response.contains_pointer()
{
let cursor_at_pointer =
galley.cursor_from_pos((galley_from_global * pointer_pos).to_vec2());
@ -521,17 +522,16 @@ impl LabelSelectionState {
let dragged = false;
cursor_state.pointer_interaction(ui, response, cursor_at_pointer, galley, dragged);
}
}
if let Some(mut cursor_range) = cursor_state.range(galley) {
let galley_rect = global_from_galley * Rect::from_min_size(Pos2::ZERO, galley.size());
self.selection_bbox_this_frame |= galley_rect;
if let Some(selection) = &self.selection {
if selection.primary.widget_id == response.id {
if let Some(selection) = &self.selection
&& selection.primary.widget_id == response.id
{
process_selection_key_events(ui.ctx(), galley, response.id, &mut cursor_range);
}
}
if got_copy_event(ui.ctx()) {
self.copy_text(galley_rect, galley, &cursor_range);

78
crates/egui/src/viewport.rs
View File

@ -705,75 +705,75 @@ impl ViewportBuilder {
let mut commands = Vec::new();
if let Some(new_title) = new_title {
if Some(&new_title) != self.title.as_ref() {
if let Some(new_title) = new_title
&& Some(&new_title) != self.title.as_ref()
{
self.title = Some(new_title.clone());
commands.push(ViewportCommand::Title(new_title));
}
}
if let Some(new_position) = new_position {
if Some(new_position) != self.position {
if let Some(new_position) = new_position
&& Some(new_position) != self.position
{
self.position = Some(new_position);
commands.push(ViewportCommand::OuterPosition(new_position));
}
}
if let Some(new_inner_size) = new_inner_size {
if Some(new_inner_size) != self.inner_size {
if let Some(new_inner_size) = new_inner_size
&& Some(new_inner_size) != self.inner_size
{
self.inner_size = Some(new_inner_size);
commands.push(ViewportCommand::InnerSize(new_inner_size));
}
}
if let Some(new_min_inner_size) = new_min_inner_size {
if Some(new_min_inner_size) != self.min_inner_size {
if let Some(new_min_inner_size) = new_min_inner_size
&& Some(new_min_inner_size) != self.min_inner_size
{
self.min_inner_size = Some(new_min_inner_size);
commands.push(ViewportCommand::MinInnerSize(new_min_inner_size));
}
}
if let Some(new_max_inner_size) = new_max_inner_size {
if Some(new_max_inner_size) != self.max_inner_size {
if let Some(new_max_inner_size) = new_max_inner_size
&& Some(new_max_inner_size) != self.max_inner_size
{
self.max_inner_size = Some(new_max_inner_size);
commands.push(ViewportCommand::MaxInnerSize(new_max_inner_size));
}
}
if let Some(new_fullscreen) = new_fullscreen {
if Some(new_fullscreen) != self.fullscreen {
if let Some(new_fullscreen) = new_fullscreen
&& Some(new_fullscreen) != self.fullscreen
{
self.fullscreen = Some(new_fullscreen);
commands.push(ViewportCommand::Fullscreen(new_fullscreen));
}
}
if let Some(new_maximized) = new_maximized {
if Some(new_maximized) != self.maximized {
if let Some(new_maximized) = new_maximized
&& Some(new_maximized) != self.maximized
{
self.maximized = Some(new_maximized);
commands.push(ViewportCommand::Maximized(new_maximized));
}
}
if let Some(new_resizable) = new_resizable {
if Some(new_resizable) != self.resizable {
if let Some(new_resizable) = new_resizable
&& Some(new_resizable) != self.resizable
{
self.resizable = Some(new_resizable);
commands.push(ViewportCommand::Resizable(new_resizable));
}
}
if let Some(new_transparent) = new_transparent {
if Some(new_transparent) != self.transparent {
if let Some(new_transparent) = new_transparent
&& Some(new_transparent) != self.transparent
{
self.transparent = Some(new_transparent);
commands.push(ViewportCommand::Transparent(new_transparent));
}
}
if let Some(new_decorations) = new_decorations {
if Some(new_decorations) != self.decorations {
if let Some(new_decorations) = new_decorations
&& Some(new_decorations) != self.decorations
{
self.decorations = Some(new_decorations);
commands.push(ViewportCommand::Decorations(new_decorations));
}
}
if let Some(new_icon) = new_icon {
let is_new = match &self.icon {
@ -787,26 +787,26 @@ impl ViewportBuilder {
}
}
if let Some(new_visible) = new_visible {
if Some(new_visible) != self.visible {
if let Some(new_visible) = new_visible
&& Some(new_visible) != self.visible
{
self.visible = Some(new_visible);
commands.push(ViewportCommand::Visible(new_visible));
}
}
if let Some(new_mouse_passthrough) = new_mouse_passthrough {
if Some(new_mouse_passthrough) != self.mouse_passthrough {
if let Some(new_mouse_passthrough) = new_mouse_passthrough
&& Some(new_mouse_passthrough) != self.mouse_passthrough
{
self.mouse_passthrough = Some(new_mouse_passthrough);
commands.push(ViewportCommand::MousePassthrough(new_mouse_passthrough));
}
}
if let Some(new_window_level) = new_window_level {
if Some(new_window_level) != self.window_level {
if let Some(new_window_level) = new_window_level
&& Some(new_window_level) != self.window_level
{
self.window_level = Some(new_window_level);
commands.push(ViewportCommand::WindowLevel(new_window_level));
}
}
// --------------------------------------------------------------
// Things we don't have commands for require a full window recreation.

15
crates/egui/src/widgets/text_edit/builder.rs
View File

@ -573,8 +573,7 @@ impl TextEdit<'_> {
let text_clip_rect = rect;
let painter = ui.painter_at(text_clip_rect.expand(1.0)); // expand to avoid clipping cursor
if interactive {
if let Some(pointer_pos) = response.interact_pointer_pos() {
if interactive && let Some(pointer_pos) = response.interact_pointer_pos() {
if response.hovered() && text.is_mutable() {
ui.output_mut(|o| o.mutable_text_under_cursor = true);
}
@ -609,7 +608,6 @@ impl TextEdit<'_> {
state.last_interaction_time = ui.ctx().input(|i| i.time);
}
}
}
if interactive && response.hovered() {
ui.ctx().set_cursor_icon(CursorIcon::Text);
@ -718,12 +716,10 @@ impl TextEdit<'_> {
let has_focus = ui.memory(|mem| mem.has_focus(id));
if has_focus {
if let Some(cursor_range) = state.cursor.range(&galley) {
if has_focus && let Some(cursor_range) = state.cursor.range(&galley) {
// Add text selection rectangles to the galley:
paint_text_selection(&mut galley, ui.visuals(), &cursor_range, None);
}
}
if !clip_text {
// Allocate additional space if edits were made this frame that changed the size. This is important so that,
@ -762,10 +758,8 @@ impl TextEdit<'_> {
painter.galley(galley_pos, galley.clone(), text_color);
if has_focus {
if let Some(cursor_range) = state.cursor.range(&galley) {
let primary_cursor_rect =
cursor_rect(&galley, &cursor_range.primary, row_height)
if has_focus && let Some(cursor_range) = state.cursor.range(&galley) {
let primary_cursor_rect = cursor_rect(&galley, &cursor_range.primary, row_height)
.translate(galley_pos.to_vec2());
if response.changed() || selection_changed {
@ -808,7 +802,6 @@ impl TextEdit<'_> {
}
}
}
}
// Ensures correct IME behavior when the text input area gains or loses focus.
if state.ime_enabled && (response.gained_focus() || response.lost_focus()) {

6
crates/egui_demo_app/src/apps/image_viewer.rs
View File

@ -64,12 +64,12 @@ impl eframe::App for ImageViewer {
}
#[cfg(not(target_arch = "wasm32"))]
if ui.button("file…").clicked() {
if let Some(path) = rfd::FileDialog::new().pick_file() {
if ui.button("file…").clicked()
&& let Some(path) = rfd::FileDialog::new().pick_file()
{
self.uri_edit_text = format!("file://{}", path.display());
self.current_uri = self.uri_edit_text.clone();
}
}
});
});

6
crates/egui_demo_app/src/wrap_app.rs
View File

@ -194,11 +194,11 @@ impl WrapApp {
};
#[cfg(feature = "persistence")]
if let Some(storage) = cc.storage {
if let Some(state) = eframe::get_value(storage, eframe::APP_KEY) {
if let Some(storage) = cc.storage
&& let Some(state) = eframe::get_value(storage, eframe::APP_KEY)
{
slf.state = state;
}
}
slf
}

7
crates/egui_demo_lib/src/demo/demo_app_windows.rs
View File

@ -421,11 +421,12 @@ mod tests {
}
fn remove_leading_emoji(full_name: &str) -> &str {
if let Some((start, name)) = full_name.split_once(' ') {
if start.len() <= 4 && start.bytes().next().is_some_and(|byte| byte >= 128) {
if let Some((start, name)) = full_name.split_once(' ')
&& start.len() <= 4
&& start.bytes().next().is_some_and(|byte| byte >= 128)
{
return name;
}
}
full_name
}
}

2
crates/egui_demo_lib/src/demo/table_demo.rs
View File

@ -336,5 +336,5 @@ fn long_text(row_index: usize) -> String {
}
fn thick_row(row_index: usize) -> bool {
row_index % 6 == 0
row_index.is_multiple_of(6)
}

3
crates/egui_demo_lib/src/demo/tests/clipboard_test.rs
View File

@ -67,11 +67,10 @@ impl crate::View for ClipboardTest {
if let Ok(egui::load::ImagePoll::Ready { image }) =
ui.ctx().try_load_image(&uri, Default::default())
&& ui.button("📋").clicked()
{
if ui.button("📋").clicked() {
ui.ctx().copy_image((*image).clone());
}
}
});
ui.vertical_centered_justified(|ui| {

6
crates/egui_demo_lib/src/demo/tests/input_event_history.rs
View File

@ -12,12 +12,12 @@ struct DeduplicatedHistory {
impl DeduplicatedHistory {
fn add(&mut self, summary: String, full: String) {
if let Some(entry) = self.history.back_mut() {
if entry.summary == summary {
if let Some(entry) = self.history.back_mut()
&& entry.summary == summary
{
entry.entries.push(full);
return;
}
}
self.history.push_back(HistoryEntry {
summary,
entries: vec![full],

6
crates/egui_demo_lib/src/demo/tests/input_test.rs
View File

@ -10,12 +10,12 @@ struct DeduplicatedHistory {
impl DeduplicatedHistory {
fn add(&mut self, text: String) {
if let Some(entry) = self.history.back_mut() {
if entry.text == text {
if let Some(entry) = self.history.back_mut()
&& entry.text == text
{
entry.repeated += 1;
return;
}
}
self.history.push_back(HistoryEntry { text, repeated: 1 });
if self.history.len() > 100 {
self.history.pop_front();

6
crates/egui_demo_lib/src/demo/text_edit.rs
View File

@ -65,8 +65,9 @@ impl crate::View for TextEditDemo {
egui::Label::new("Press ctrl+Y to toggle the case of selected text (cmd+Y on Mac)"),
);
if ui.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::Y)) {
if let Some(text_cursor_range) = output.cursor_range {
if ui.input_mut(|i| i.consume_key(egui::Modifiers::COMMAND, egui::Key::Y))
&& let Some(text_cursor_range) = output.cursor_range
{
use egui::TextBuffer as _;
let selected_chars = text_cursor_range.as_sorted_char_range();
let selected_text = text.char_range(selected_chars.clone());
@ -79,7 +80,6 @@ impl crate::View for TextEditDemo {
text.delete_char_range(selected_chars.clone());
text.insert_text(&new_text, selected_chars.start);
}
}
ui.horizontal(|ui| {
ui.label("Move cursor to the:");

8
crates/egui_demo_lib/src/demo/undo_redo.rs
View File

@ -60,16 +60,12 @@ impl crate::View for UndoRedoDemo {
let undo = ui.add_enabled(can_undo, Button::new("⟲ Undo")).clicked();
let redo = ui.add_enabled(can_redo, Button::new("⟳ Redo")).clicked();
if undo {
if let Some(undo_text) = self.undoer.undo(&self.state) {
if undo && let Some(undo_text) = self.undoer.undo(&self.state) {
self.state = undo_text.clone();
}
}
if redo {
if let Some(redo_text) = self.undoer.redo(&self.state) {
if redo && let Some(redo_text) = self.undoer.redo(&self.state) {
self.state = redo_text.clone();
}
}
});
self.undoer

6
crates/egui_demo_lib/src/easy_mark/easy_mark_editor.rs
View File

@ -96,8 +96,9 @@ impl EasyMarkEditor {
ui.add(egui::TextEdit::multiline(code).desired_width(f32::INFINITY))
};
if let Some(mut state) = TextEdit::load_state(ui.ctx(), response.id) {
if let Some(mut ccursor_range) = state.cursor.char_range() {
if let Some(mut state) = TextEdit::load_state(ui.ctx(), response.id)
&& let Some(mut ccursor_range) = state.cursor.char_range()
{
let any_change = shortcuts(ui, code, &mut ccursor_range);
if any_change {
state.cursor.set_char_range(Some(ccursor_range));
@ -105,7 +106,6 @@ impl EasyMarkEditor {
}
}
}
}
}
pub const SHORTCUT_BOLD: KeyboardShortcut = KeyboardShortcut::new(Modifiers::COMMAND, Key::B);

12
crates/egui_demo_lib/src/easy_mark/easy_mark_parser.rs
View File

@ -113,8 +113,9 @@ impl<'a> Parser<'a> {
// ```{language}\n{code}```
fn code_block(&mut self) -> Option<Item<'a>> {
if let Some(language_start) = self.s.strip_prefix("```") {
if let Some(newline) = language_start.find('\n') {
if let Some(language_start) = self.s.strip_prefix("```")
&& let Some(newline) = language_start.find('\n')
{
let language = &language_start[..newline];
let code_start = &language_start[newline + 1..];
if let Some(end) = code_start.find("\n```") {
@ -127,7 +128,6 @@ impl<'a> Parser<'a> {
return Some(Item::CodeBlock(language, code_start));
}
}
}
None
}
@ -171,8 +171,9 @@ impl<'a> Parser<'a> {
let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
if let Some(bracket_end) = this_line.find(']') {
let text = &this_line[1..bracket_end];
if this_line[bracket_end + 1..].starts_with('(') {
if let Some(parens_end) = this_line[bracket_end + 2..].find(')') {
if this_line[bracket_end + 1..].starts_with('(')
&& let Some(parens_end) = this_line[bracket_end + 2..].find(')')
{
let parens_end = bracket_end + 2 + parens_end;
let url = &self.s[bracket_end + 2..parens_end];
self.s = &self.s[parens_end + 1..];
@ -181,7 +182,6 @@ impl<'a> Parser<'a> {
}
}
}
}
None
}
}

6
crates/egui_extras/src/loaders/image_loader.rs
View File

@ -161,13 +161,13 @@ impl ImageLoader for ImageCrateLoader {
match ctx.try_load_bytes(uri) {
Ok(BytesPoll::Ready { bytes, mime, .. }) => {
// (2)
if let Some(mime) = mime {
if !is_supported_mime(&mime) {
if let Some(mime) = mime
&& !is_supported_mime(&mime)
{
return Err(LoadError::FormatNotSupported {
detected_format: Some(mime),
});
}
}
load_image(ctx, uri, &self.cache, &bytes)
}
Ok(BytesPoll::Pending { size }) => Ok(ImagePoll::Pending { size }),

6
crates/egui_extras/src/sizing.rs
View File

@ -144,13 +144,13 @@ impl Sizing {
let mut remainder_length = length - sum_non_remainder;
let avg_remainder_length = 0.0f32.max(remainder_length / num_remainders as f32).floor();
for &size in &self.sizes {
if let Size::Remainder { range } = size {
if avg_remainder_length < range.min {
if let Size::Remainder { range } = size
&& avg_remainder_length < range.min
{
remainder_length -= range.min;
num_remainders -= 1;
}
}
}
if num_remainders > 0 {
0.0f32.max(remainder_length / num_remainders as f32)
} else {

20
crates/egui_extras/src/table.rs
View File

@ -472,12 +472,12 @@ impl<'a> TableBuilder<'a> {
for (i, column) in columns.iter_mut().enumerate() {
let column_resize_id = ui.id().with("resize_column").with(i);
if let Some(response) = ui.ctx().read_response(column_resize_id) {
if response.double_clicked() {
if let Some(response) = ui.ctx().read_response(column_resize_id)
&& response.double_clicked()
{
column.auto_size_this_frame = true;
}
}
}
let striped = striped.unwrap_or(ui.visuals().striped);
@ -864,8 +864,9 @@ impl Table<'_> {
if column.auto_size_this_frame {
// Auto-size: resize to what is needed.
*column_width = width_range.clamp(max_used_widths[i]);
} else if resize_response.dragged() {
if let Some(pointer) = ui.ctx().pointer_latest_pos() {
} else if resize_response.dragged()
&& let Some(pointer) = ui.ctx().pointer_latest_pos()
{
let mut new_width = *column_width + pointer.x - x;
if !column.clip {
// Unless we clip we don't want to shrink below the
@ -885,7 +886,6 @@ impl Table<'_> {
*column_width = new_width;
}
}
let dragging_something_else =
ui.input(|i| i.pointer.any_down() || i.pointer.any_pressed());
@ -991,7 +991,7 @@ impl<'a> TableBody<'a> {
row_index: self.row_index,
col_index: 0,
height,
striped: self.striped && self.row_index % 2 == 0,
striped: self.striped && self.row_index.is_multiple_of(2),
hovered: self.hovered_row_index == Some(self.row_index),
selected: false,
overline: false,
@ -1073,7 +1073,7 @@ impl<'a> TableBody<'a> {
row_index,
col_index: 0,
height: row_height_sans_spacing,
striped: self.striped && (row_index + self.row_index) % 2 == 0,
striped: self.striped && (row_index + self.row_index).is_multiple_of(2),
hovered: self.hovered_row_index == Some(row_index),
selected: false,
overline: false,
@ -1155,7 +1155,7 @@ impl<'a> TableBody<'a> {
row_index,
col_index: 0,
height: row_height,
striped: self.striped && (row_index + self.row_index) % 2 == 0,
striped: self.striped && (row_index + self.row_index).is_multiple_of(2),
hovered: self.hovered_row_index == Some(row_index),
selected: false,
overline: false,
@ -1178,7 +1178,7 @@ impl<'a> TableBody<'a> {
row_index,
col_index: 0,
height: row_height,
striped: self.striped && (row_index + self.row_index) % 2 == 0,
striped: self.striped && (row_index + self.row_index).is_multiple_of(2),
hovered: self.hovered_row_index == Some(row_index),
overline: false,
selected: false,

6
crates/epaint/src/text/font.rs
View File

@ -239,8 +239,9 @@ impl FontImpl {
return None; // these will result in the replacement character when rendering
}
if c == '\t' {
if let Some(space) = self.glyph_info(' ') {
if c == '\t'
&& let Some(space) = self.glyph_info(' ')
{
let glyph_info = GlyphInfo {
advance_width_unscaled: (crate::text::TAB_SIZE as f32
* space.advance_width_unscaled.0)
@ -250,7 +251,6 @@ impl FontImpl {
self.glyph_info_cache.insert(c, glyph_info);
return Some(glyph_info);
}
}
if c == '\u{2009}' {
// Thin space, often used as thousands deliminator: 1 234 567 890

4
crates/epaint/src/text/text_layout.rs
View File

@ -113,15 +113,13 @@ pub fn layout(fonts: &mut FontsImpl, pixels_per_point: f32, job: Arc<LayoutJob>)
let mut elided = false;
let mut rows = rows_from_paragraphs(paragraphs, &job, &mut elided);
if elided {
if let Some(last_placed) = rows.last_mut() {
if elided && let Some(last_placed) = rows.last_mut() {
let last_row = Arc::make_mut(&mut last_placed.row);
replace_last_glyph_with_overflow_character(fonts, pixels_per_point, &job, last_row);
if let Some(last) = last_row.glyphs.last() {
last_row.size.x = last.max_x();
}
}
}
let justify = job.justify && job.wrap.max_width.is_finite();

12
crates/epaint/src/text/text_layout_types.rs
View File

@ -957,16 +957,16 @@ impl Galley {
// Vertical margin around galley improves text selection UX
const VMARGIN: f32 = 5.0;
if let Some(first_row) = self.rows.first() {
if pos.y < first_row.min_y() - VMARGIN {
if let Some(first_row) = self.rows.first()
&& pos.y < first_row.min_y() - VMARGIN
{
return self.begin();
}
}
if let Some(last_row) = self.rows.last() {
if last_row.max_y() + VMARGIN < pos.y {
if let Some(last_row) = self.rows.last()
&& last_row.max_y() + VMARGIN < pos.y
{
return self.end();
}
}
let mut best_y_dist = f32::INFINITY;
let mut cursor = CCursor::default();

6
examples/file_dialog/src/main.rs
View File

@ -29,11 +29,11 @@ impl eframe::App for MyApp {
egui::CentralPanel::default().show(ctx, |ui| {
ui.label("Drag-and-drop files onto the window!");
if ui.button("Open file…").clicked() {
if let Some(path) = rfd::FileDialog::new().pick_file() {
if ui.button("Open file…").clicked()
&& let Some(path) = rfd::FileDialog::new().pick_file()
{
self.picked_path = Some(path.display().to_string());
}
}
if let Some(picked_path) = &self.picked_path {
ui.horizontal(|ui| {

12
examples/user_attention/src/main.rs
View File

@ -56,8 +56,9 @@ impl Application {
impl eframe::App for Application {
fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
if let Some(request_at) = self.request_at {
if request_at < SystemTime::now() {
if let Some(request_at) = self.request_at
&& request_at < SystemTime::now()
{
self.request_at = None;
ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(self.attention));
if self.auto_reset {
@ -65,16 +66,15 @@ impl eframe::App for Application {
self.reset_at = Some(SystemTime::now() + Self::attention_reset_timeout());
}
}
}
if let Some(reset_at) = self.reset_at {
if reset_at < SystemTime::now() {
if let Some(reset_at) = self.reset_at
&& reset_at < SystemTime::now()
{
self.reset_at = None;
ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(
UserAttentionType::Reset,
));
}
}
CentralPanel::default().show(ctx, |ui| {
ui.vertical(|ui| {