Can you save the selection of a master-detail bound NSTableView?

Question

I have a manager class for my data which is configured by two properties, one to set to a category and another to select items which correspond with that category. Based on that it will expose the relevant pieces of data. I am using a couple of different forms or making those selections, including a pair of IndexSets.

My problem is that I would also like to be able to save the selected items for each category, so that whenever the category is changed the items previously selected for it are restored. This is easy to achieve when accessed programmatically, but using bindings to allow a view in a macOS app to be able to provide that configuration unfortunately does not work properly

Changing the category causes the object bound to its selection to empty or 'preserve' the selected items before the category is actually updated. So the actual selection gets overwritten with, with noway I can see to tell the difference between this behaviour and a user action.

Here are the test code I have used for experimenting, with viewDidLoad generating some random test data to roughly mimic the structure o the real class. This does not attempt to save or restore the selection, but simply shows the overwriting behaviour.

class Thing: NSObject {
    @objc dynamic var name: String

    required init(name: String) {
        self.name = name
    }
}

class Stuff: NSObject {
    @objc dynamic var name: String
    @objc dynamic var things: [Thing]

    required init(name: String, things: [Thing]) {
        self.name = name
        self.things = things
    }
}

class StuffManager: NSObject {

    @objc dynamic var stuff = [Stuff]()
    @objc dynamic var stuffIndex = IndexSet() {
        didSet {
            print("STUFF: ", Array(stuffIndex))
        }
    }

    @objc dynamic var things = [Thing]()
    @objc dynamic var thingsIndex = IndexSet() {
        didSet {
            print("THING: ", Array(thingsIndex))
        }
    }

}

class ViewController: NSViewController {

    @objc dynamic var stuffManager = StuffManager()

    override func viewDidLoad() {
        super.viewDidLoad()
        (1...10).forEach { stuffManager.things.append(Thing(name: "Thing \($0)")) }
        (1...9).forEach {
            let randomThings = Array(stuffManager.things.shuffled()[0...Int.random(in: 0..<10)])
            stuffManager.stuff.append(Stuff(name: "Collection \($0)", things: randomThings))
        }
        stuffManager.stuff.append(Stuff(name: "Collection 10", things: []))
    }

}

In Interface Builder I have a view containing an NSPopButton to select the Stuff, a multiple selection NSTableView to select the Things, and a pair of NSArrayControllers for each. The bindings are:

Stuff Array Controller

Content Array:
Binding to: ViewController, Model Key Path: stuffManager.stuff
Selection Indexes:
Binding to: ViewController, Model Key Path: stuffManager.stuffIndex

Things Array Controller

Content Array:
Binding to: Stuff Array Controller, Controller Key: Selection, Model Key Path: things
Selection Indexes:
Binding to: ViewController, Model Key Path: stuffManager.thingIndex

The two interface objects are bound to these controllers in the standard way, the Content to the arrangedObjects and the Selection Indexes to the selectionIndexes of their respective array controller.

What this test code shows is that when the value in the popup button is changed the THING debug line appears before the STUFF debug line, that is it changes the selection of Things before it changes the Stuff. So any code in the property observer on stuffManager.things to save the new selection will save this change before being aware that the Stuff has changed.

Obviously this behaviour is to avoid the selection being made incorrect by the change to the content, or worse selecting out of bounds if the new content is shorter. But is there any way to detect when this is happening, rather than a user changing the selection? Or a way to override it to gain manual control over the process rather than having to accept the default behaviour of 'Preserve Selection' or the selection being cancelled if that option is disabled?

And what makes it more awkward is if this behaviour only occurs when the selection would change. If the selected Things exist for the new Stuff, or if nothing is selected, then nothing happens to trigger the property observer. Again this is understandable, but it prevents being able to cache the change and then only save the previous one if the Stuff has not changed.

I did wonder if using a separate IndexSet for each Stuff would avoid this problem, because then there would be no need for the NSTableView to manage the selection. I do not like the idea of keeping an IndexSet in the model but would accept it if it worked. But it does not. Again understandable, because the table view has no idea the Selection Indexes binding will be changed. Unless I am missing something?

But I tested this by updating the Stuff class to include the following:

    @objc dynamic var selected = IndexSet() {
        didSet {
            print("THING: ", Array(selected))
        }
    }

Then changing the Selection Indexes binding of the Things Array Controller to:

Binding to: Stuff Array Controller, Controller Key: selection, Model Key Path: selected

Is what I am trying to achieve impossible? I would not have thought it that strange a thing to want to do, to save and restore a selection, but it seems impossible with bindings.

The only solution I can see is to forgo the master-detail style pattern and instead just maintain a separate [Thing] property in my data manager class, bind the Things Array Controller to this (or even just bind the table directly to the property), then whenever the popup button changes update the new property to match the stuff object.

Something like this in the StuffManager, with the table content bound to availableThings:

    @objc dynamic var stuffIndex = IndexSet() {
        didSet {
            print("STUFF: ", Array(stuffIndex))
            availableThings = stuff[stuffIndex.first!].things
        }
    }

    @objc dynamic var availableThings = [Thing]()

Answer 1

It appears there is no way to prevent the NSTableView behaviour of automatically resetting its selection when the content changes. Nor any way to detect when this is happening, as it updates this before updating the selection on the NSPopupButton having changed. So here is how I have written the StuffManager class, adding a property for binding to the tableview so I can control the content changing:

class StuffManager: NSObject {

    let defaults: UserDefaults = .standard
    var canSaveThingsIndex = true

    @objc dynamic var stuff = [Stuff]()
    @objc dynamic var stuffIndex = IndexSet() {
        didSet {
            canSaveThingsIndex = false
            if stuffIndex.count > 0 {
                availableThings = stuff[stuffIndex.first!].things
                let thing = stuff[stuffIndex.first!].name
                if let items = defaults.object(forKey: thing) as? [Int] {
                    thingsIndex = IndexSet(items)
                } else if availableThings.count > 0 {
                    thingsIndex = IndexSet(0..<availableThings.count)
                } else {
                    thingsIndex.removeAll()
                }
            } else {
                availableThings.removeAll()
                thingsIndex.removeAll()
            }
            canSaveThingsIndex = true
        }
    }

    @objc dynamic var things = [Thing]()
    @objc dynamic var availableThings = [Thing]()
    @objc dynamic var thingsIndex = IndexSet() {
        didSet {
            if canSaveThingsIndex && stuffIndex.count > 0 {
                let thing = stuff[stuffIndex.first!].name
                defaults.set(Array(thingsIndex), forKey: thing)
            }

        }
    }

}

The Things Array Controller is now bound as:

Content Array:
Binding to: ViewController, Model Key Path: stuffManager.availableThings
Selection Indexes:
Binding to: ViewController, Model Key Path: stuffManager.thingsIndex

Though without being able to use the master-detail benefits of an NSArrayController they are not needed. Both the NSPopupButton and NSTableView can be bound directly to the StuffManager. And this allows the NSPopupButton's Selected Index can be bound to an Int int he Stuff Manager rather than needing to use an IndexSet despite multiple selections being impossible.

The main feature of the workaround is that because I am manually changing the content I can use the canSaveThingsIndex flag before changing the NSTableView content. So whenever its natural behaviour triggers the thingsIndex property observer, this can be ignored to prevent it overwriting the user's selection. It also avoids the unnecessary saving of a selection immediately after being restored.