Sorting model by boolean field causes unexpected behavior

[0-Patient]

Bug Description

I have a structure DiscrChannel defined as follows:

export struct DiscrChannel {
    id: int,
    name: string,
    is-selected: bool,
    is-inversed: bool,
}

A ListView in the UI displays a Vec<DiscrChannel>. When clicking on any row, the is-selected property of the corresponding DiscrChannel element toggles.

However, when I sort the model by the is-inversed field, toggling the is-selected property causes the model to behave as if it is being filtered by both fields (is-inversed and is-selected). This behavior does not occur when sorting by non-boolean fields (e.g., id), which works correctly and does not break the list.

Reproducible Code (if applicable)

use std::error::Error;
use std::rc::Rc;

use slint::SortModel;

slint::slint! {
    import { ListView, Button } from "std-widgets.slint";

    export struct DiscrChannel {
        id: int,
        name: string,
        is-selected: bool,
        is-inversed: bool,
    }

    export component App inherits Window {
        title: "test";
        in property <[DiscrChannel]> discr-list;

        callback sort-id();
        callback sort-inversed();

        VerticalLayout {
            HorizontalLayout {
                Button {text: "Sort id"; clicked => {sort-id();}}
                Button {text: "Sort inversed"; clicked => {sort-inversed();}}
            }
            
            ListView {
                width: 500px;
                height: 500px;

                for channel in discr-list: TouchArea {
                    clicked => {
                        channel.is-selected = !channel.is-selected;
                    }
                    bg := Rectangle {
                        background: channel.is-selected ? #80d0d6 : #e0e0e0;
                        
                        HorizontalLayout {
                            padding: 10px;

                            Text {text: channel.id;}
                            Text {text: channel.name;}
                            Text {text: channel.is-inversed ? "+" : "-";}
                        }
                    }
                }
            }
        }
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let ui = App::new()?;
    let ui_weak = ui.as_weak();

    let model_discr = Rc::new(slint::VecModel::from(vec![
        DiscrChannel { id: 2, name: "item 2".into(), is_selected: false, is_inversed: true },
        DiscrChannel { id: 1, name: "item 1".into(), is_selected: false, is_inversed: false },
        DiscrChannel { id: 4, name: "item 4".into(), is_selected: false, is_inversed: true },
        DiscrChannel { id: 3, name: "item 3".into(), is_selected: false, is_inversed: false },
        DiscrChannel { id: 5, name: "item 5".into(), is_selected: false, is_inversed: true },
    ]));

    ui.set_discr_list(model_discr.clone().into());

    {
        let ui_weak = ui_weak.clone();
        let model_discr = model_discr.clone();
        
        ui.on_sort_id(move || {
            let ui = ui_weak.unwrap();
            let model_discr = model_discr.clone();

            ui.set_discr_list(
                Rc::new(SortModel::new(model_discr, |a, b| a.id.cmp(&b.id))).into()
            );
        });
    }

    {
        let ui_weak = ui_weak.clone();
        let model_discr = model_discr.clone();
        
        ui.on_sort_inversed(move || {
            let ui = ui_weak.unwrap();
            let model_discr = model_discr.clone();

            ui.set_discr_list(
                Rc::new(SortModel::new(model_discr, |a, b| a.is_inversed.cmp(&b.is_inversed))).into()
            );
        });
    }

    ui.run()?;

    Ok(())
}

Environment Details

• Slint Version: 1.10
• Platform/OS: Windows 10
• Programming Language: Rust 1.85
• Backend/Renderer: winit-femtovg

Product Impact

No response

[0-Patient]

After further observation, I realized that the issue is not related to boolean fields specifically. During sorting by any field, elements with the same value are additionally sorted by the is-selected property every time its value changes

[tronical]

I can reproduce this. I think the row_changed changed handler of the sort model isn't preserving the order, i.e. it isn't stable.

[tronical]

I tried to fix this, but I couldn't quite figure out a good way. Last attempt was an almost brute-force check with is_sorted_by() on the mapping, in an attempt to short-cut row changes that shouldn't affect the sort order, but ALAS no luck.

Implementation wise, I think this affects Rust, C++, as well as future JavaScript and Python models.

[ogoffart]

Is it not enough to check, in row_whanged the next and the previous element to check if the element is already at the right place?

[tronical]

That's what I thought, too, but somehow that didn't work with the example:(. Maybe I need to give it another shot.

(I wish I knew a trick to add Debug easily to the type constraints within model)