The document proposes a model for handling intuitive behavior in GUI lists when multiple user actions are combined. It defines a set of deltas (Add, Remove, Change, Filter, Sort, Select) that can be applied to lists and examines scenarios where multiple deltas are combined, such as sorting then selecting items or filtering and then removing an item. The objective is to make lists behave intuitively no matter the order of actions. Future work includes generalizing the model to handle tree structures and considering the visible portion of long lists.

1. Toward an intuitive
behaviour for GUI lists
Julien Delplanque and Thomas Dupriez
Follow-up of a brainstorming during last Pharo Sprint

2. What can a user do with a
list ?
Change items
Filter items
Order items
Select item(s)}
All items
Remove item
Add item

3. Minimal API for a list
supporting these actions
• « items » : Items in the list, without filtering or sorting
applied.
• « visibleItems » : items user can see. They might be
sorted and filtered depending on previous user actions.
• « selectedItems » : visibleItems that have been selected
by users. Sorting is preserved.

4. Minimal API for a list
supporting these actions
items availableItems selectedItems⊇ ⊇
To be clear:

5. Hypothesis:
User do 1 action at a time
Add
xor
Remove
xor
Change
xor
Filter
xor
Sort
xor
Select
State n State n+1

6. Deltas
• Add(item, index) : Add the item at index in the list.
• Remove(item) : Remove the item form the list.
• Change(newItems) : Replace current items in the list by newItems.
• Filter(predicate) : Hide items that do not match the predicate from
availableItems.
• Sort(comparison) : Order availableItems items according to
comparison criteria.
• Select(indexes) : Select visibleItems items at indexes.

7. Each delta applied
separately is easy
a
b
c
d
Add(f,2)+ =
a
f
b
c
d
a
b
c
d
+ =Remove(c)
a
b
d

8. Each delta applied
separately is easy
a
b
c
d
Change(e,f,g)+ =
e
f
g
a
b
c
d
+ =Filter(:x | )x ∈ {a, b}
a
b

9. Each delta applied
separately is easy
a
b
c
d
Select(1,2)+ =
a
b
c
d
d
c
b
a
Sort(:x :y | x > y)
a
b
c
d
+ =

10. Objective
Make the lists behave intuitively.
The challenge arise when multiple deltas are combined.

11. Scenario 1
a
b
c
d
Select(1,2), Sort(:x :y | x > y)+
=
d
c
b
a

12. Scenario 2
a
b
c
d
Select(1,2,3), Filter(:x | )+
=
x ∈ {a, b}
a
b

13. Scenario 3
a
b
c
d
Select(1,2,3), Filter(:x | ),
Filter(:x | true) // Remove filter
+
=
x ∈ {a, b}
a
b
c
d

14. Scenario 4
a
b
c
d
Filter(:x | ), Select(1,2),
Filter(:x | true) // Remove filter
+
=
x ∈ {a, d}
a
b
c
d

15. Scenario 5
a
b
c
d
Select(1,2), Add(f,2)+
=
a
f
b
c
e

16. Scenario 6
a
b
c
d
Select(1,3), Remove(b)+
=
a
c
d

17. Future work
• Generalise model to handle trees?
• Handle the part of the list seen by the user?
• Connected topic: filter predicate compiler?
https://github.com/juliendelplanque/DeltaListModelIt happens here: