Drag move flickers position of window

Question

I'm implementing a Rust alternative to .NET's DragMove method however the result causes the application to flicker between two relative positions.

See screencast and sample project.

Code I'm using to perform the drag move:

let mut mouse_down = false;
let mut last_pos: Option<PhysicalPosition<f64>> = None;
event_loop.run(move |event, _, control_flow| match event {
Event::WindowEvent {
        event: WindowEvent::CursorMoved {
            position,
            ..
        },
        ..
    } => {
        let gl_window = display.gl_window();
        let window = gl_window.window();
        if mouse_down {
            if last_pos.is_some() {
                let previous_pos = last_pos.unwrap();
                let delta_x = previous_pos.x - position.x;
                let delta_y = previous_pos.y - position.y;
                window.set_outer_position(PhysicalPosition::new(position.x + delta_x, position.y + delta_y));
            }
            last_pos = Some(position);
        }
    }
    Event::WindowEvent {
        event: WindowEvent::MouseInput{
            state,
            button,
            ..
        },
        ..
    } => {
        mouse_down = button == MouseButton::Left && state == ElementState::Pressed;
        if !mouse_down {
            last_pos = None;
        }
    }
    _ => {}
});

Answer 1

CursorMoved reports

(x,y) coords in pixels relative to the top-left corner of the window.

When you're later using that position to set_outer_position, you are essentially reinterpreting window-relative coordinates as screen-relative.

You should instead apply the offset to the position returned from outer_position.

While that fixes the immediate problem, I'm not sure it is enough to account for the window movement. When you're handling the next CursorMoved event, the coordinates are still window-relative, but the window has since moved. That may produce artifacts all over.

A more robust solution would store the window's position when the drag-move operation starts, and offset that position by the accumulated deltas.