[bug] Window changes position if resizing while hidden

[tauri-bot]

This issue has been upstreamed from tauri-apps/tauri#4056

Describe the bug

Hello,

a window changes its position if the windo is resize while hidden. The size, for example, is changed with window.setSize(new LogicalSize(800, 300))

Due to this, the UX is not amazing and the window can move out of the display. If the window is resized before it is first shown, it can appear outside the display too (therefore, invisible to the user).

Reproduction

Screen.Recording.2022-05-04.at.17.09.24.mov

1. Hide window
2. Resize while hidden
3. Show the window again

---

Repository to reproduce
https://github.com/elvinaspredkelis/window_move

Note
Tauri explicitly emits tauri://move event after resizing.

Expected behavior

The window keeps the top-left point position.

Platform and versions

Environment
  › OS: Mac OS 12.0.1 X64
  › Node.js: 16.6.2
  › npm: 8.7.0
  › pnpm: Not installed!
  › yarn: 1.22.11
  › rustup: 1.24.3
  › rustc: 1.58.1
  › cargo: 1.58.0
  › Rust toolchain: stable-x86_64-apple-darwin 

Packages
  › @tauri-apps/cli [NPM]: 1.0.0-rc.9
  › @tauri-apps/api [NPM]: 1.0.0-rc.4
  › tauri [RUST]: 1.0.0-rc.8,
  › tauri-build [RUST]: 1.0.0-rc.7,
  › tao [RUST]: 0.8.3,
  › wry [RUST]: 0.15.1,

App
  › build-type: bundle
  › CSP: unset
  › distDir: ../dist
  › devPath: http://localhost:8080/
  › framework: Vue.js

App directory structure
  ├─ node_modules
  ├─ public
  ├─ src-tauri
  ├─ .git
  ├─ .vscode
  └─ src

Stack trace

No response

Additional context

If not easy to fix, I would appreciate any suggestions on how to mitigate this issue with the current setup. 🙏

[lucasfernog]

Here's a tao example to reproduce it:

// Copyright 2019-2021 Tauri Programme within The Commons Conservancy
// SPDX-License-Identifier: Apache-2.0

use tao::{
  event::{ElementState, Event, KeyEvent, WindowEvent},
  event_loop::{ControlFlow, EventLoop},
  keyboard::Key,
  window::WindowBuilder,
};

#[allow(clippy::single_match)]
fn main() {
  let event_loop = EventLoop::new();

  let mut window = Some(
    WindowBuilder::new()
      .with_title("A fantastic window!")
      .with_inner_size(tao::dpi::LogicalSize::new(128.0, 128.0))
      .build(&event_loop)
      .unwrap(),
  );

  event_loop.run(move |event, _, control_flow| {
    *control_flow = ControlFlow::Wait;
    println!("{:?}", event);

    match event {
      Event::WindowEvent {
        event:
          WindowEvent::KeyboardInput {
            event:
              KeyEvent {
                logical_key: Key::Character("f"),
                state: ElementState::Pressed,
                ..
              },
            ..
          },
        window_id: _,
        ..
      } => {
        let window = window.as_ref().unwrap();
        window.set_visible(false);
        window.set_inner_size(tao::dpi::LogicalSize::new(800, 300));
        window.set_visible(true);
      }

      Event::WindowEvent {
        event: WindowEvent::CloseRequested,
        window_id: _,
        ..
      } => {
        // drop the window to fire the `Destroyed` event
        window = None;
      }
      Event::WindowEvent {
        event: WindowEvent::Destroyed,
        window_id: _,
        ..
      } => {
        *control_flow = ControlFlow::Exit;
      }
      Event::MainEventsCleared => {
        if let Some(w) = &window {
          w.request_redraw();
        }
      }
      _ => (),
    }
  });
}

Just run the example and press f. The window shouldn't move in this case (if you comment out the window.set_visible(false) line, everything works as expected).

[lucasfernog]

This issue also happens on winit.

[keiya01]

Maybe we need to observe window position and resize event and we need to set observed position to window when window is resized.
I could not find other issue that describe same bugs.