ChangeLog: When resizing the window, try to keep the focus item visible if it's in a scrollview (flickable).

Fixes #3067

Author: anlumo

internal/core/api.rs

@@ -674,6 +674,9 @@ impl Window {
             crate::platform::WindowEvent::Resized { size } => {
                 self.0.set_window_item_geometry(size.to_euclid());
                 self.0.window_adapter().renderer().resize(size.to_physical(self.scale_factor()))?;
+                if let Some(item_rc) = self.0.focus_item.borrow().upgrade() {
+                    item_rc.try_scroll_into_visible();
+                }
             }
             crate::platform::WindowEvent::CloseRequested => {
                 if self.0.request_close() {

internal/core/item_tree.rs

@@ -512,6 +512,35 @@ impl ItemRc {
         result
     }
 
+    /// Returns an absolute position of `p` in the `ancestor`'s coordinate system
+    /// (does not add this item's x and y)
+    /// Don't rely on any specific behavior if `self` isn't a descendant of `ancestor`.
+    fn map_to_ancestor(&self, p: LogicalPoint, ancestor: &Self) -> LogicalPoint {
+        let mut current = self.clone();
+        let mut result = p;
+        if &current == ancestor {
+            return result;
+        }
+        let supports_transformations = self
+            .window_adapter()
+            .map(|adapter| adapter.renderer().supports_transformations())
+            .unwrap_or(true);
+        while let Some(parent) = current.parent_item(ParentItemTraversalMode::StopAtPopups) {
+            if &parent == ancestor {
+                break;
+            }
+            let geometry = parent.geometry();
+            if supports_transformations {
+                if let Some(transform) = parent.children_transform() {
+                    result = transform.transform_point(result.cast()).cast();
+                }
+            }
+            result += geometry.origin.to_vector();
+            current = parent;
+        }
+        result
+    }
+
     /// Return the index of the item within the ItemTree
     pub fn index(&self) -> u32 {
         self.index
@@ -847,6 +876,40 @@ impl ItemRc {
             // Should practically always be possible.
             .and_then(|child_transform| child_transform.inverse())
     }
+
+    pub(crate) fn try_scroll_into_visible(&self) {
+        let mut parent = self.parent_item(ParentItemTraversalMode::StopAtPopups);
+        while let Some(item_rc) = parent.as_ref() {
+            let item_ref = item_rc.borrow();
+            if let Some(flickable) = vtable::VRef::downcast_pin::<crate::items::Flickable>(item_ref)
+            {
+                let geo = self.geometry();
+
+                flickable.reveal_points(
+                    item_rc,
+                    &[
+                        self.map_to_ancestor(
+                            LogicalPoint::new(
+                                geo.origin.x - flickable.viewport_x().0,
+                                geo.origin.y - flickable.viewport_y().0,
+                            ),
+                            &item_rc,
+                        ),
+                        self.map_to_ancestor(
+                            LogicalPoint::new(
+                                geo.max_x() - flickable.viewport_x().0,
+                                geo.max_y() - flickable.viewport_y().0,
+                            ),
+                            &item_rc,
+                        ),
+                    ],
+                );
+                break;
+            }
+
+            parent = item_rc.parent_item(ParentItemTraversalMode::StopAtPopups);
+        }
+    }
 }
 
 impl PartialEq for ItemRc {

internal/core/items/flickable.rs

@@ -259,6 +259,8 @@ impl Flickable {
         }
     }
 
+    /// Scroll the Flickable so that all of the points are visible at the same time (if possible).
+    /// The points have to be in the parent's coordinate space.
     pub(crate) fn reveal_points(self: Pin<&Self>, self_rc: &ItemRc, pts: &[LogicalPoint]) {
         if pts.is_empty() {
             return;

internal/core/window.rs

@@ -963,22 +963,9 @@ impl WindowInner {
                     &self.window_adapter(),
                     item,
                 );
-                if result == crate::input::FocusEventResult::FocusAccepted && !item.is_visible() {
-                    let mut parent = item.parent_item(ParentItemTraversalMode::StopAtPopups);
-                    while let Some(item_rc) = parent.as_ref() {
-                        let item_ref = item_rc.borrow();
-                        if let Some(flickable) =
-                            vtable::VRef::downcast_pin::<crate::items::Flickable>(item_ref)
-                        {
-                            let geo = item.geometry();
-                            flickable.reveal_points(
-                                item_rc,
-                                &[geo.origin, LogicalPoint::new(geo.max_x(), geo.max_y())],
-                            );
-                        }
-
-                        parent = item.parent_item(ParentItemTraversalMode::StopAtPopups);
-                    }
+                // Reveal offscreen item when it gains focus
+                if result == crate::input::FocusEventResult::FocusAccepted {
+                    item.try_scroll_into_visible();
                 }
 
                 result