Swift – Update auto layout properties of UI components programmatically – Ios swift

You could do this with "Top-to-Bottom" constraints, but it would be rather complex.

You would need to essentially create a "Linked List" to track each view, the views above and below it, and its constraints.

So, to "insert" a new view after the 3rd view, you would need to:

• deactivate the inter-view constraints
• insert the new view into the linked list
• re-create and activate the new constraints

Putting your views in a UIStackView turns that process into a single line of code:

stackView.insertArrangedSubview(newView, at: 3)

Here’s a quick example:

class ViewController: UIViewController {
    
    let testView: SampleView = SampleView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        view.backgroundColor = .systemYellow
        
        let infoLabel: UILabel = {
            let v = UILabel()
            v.textAlignment = .center
            v.numberOfLines = 0
            v.text = "Tap to Insert "New Label"nafter "Label 3""
            return v
        }()
        let btn: UIButton = {
            let v = UIButton()
            v.setTitle("Insert", for: [])
            v.setTitleColor(.white, for: .normal)
            v.setTitleColor(.lightGray, for: .highlighted)
            v.backgroundColor = .systemBlue
            return v
        }()
        
        [infoLabel, btn, testView].forEach { v in
            v.translatesAutoresizingMaskIntoConstraints = false
            view.addSubview(v)
        }
        
        let g = view.safeAreaLayoutGuide
        NSLayoutConstraint.activate([
            
            infoLabel.topAnchor.constraint(equalTo: g.topAnchor, constant: 40.0),
            infoLabel.widthAnchor.constraint(equalTo: g.widthAnchor, multiplier: 0.75),
            infoLabel.centerXAnchor.constraint(equalTo: g.centerXAnchor),
            
            btn.topAnchor.constraint(equalTo: infoLabel.bottomAnchor, constant: 20.0),
            btn.widthAnchor.constraint(equalTo: g.widthAnchor, multiplier: 0.75),
            btn.centerXAnchor.constraint(equalTo: g.centerXAnchor),

            testView.topAnchor.constraint(equalTo: btn.bottomAnchor, constant: 40.0),
            testView.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 40.0),
            testView.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: -40.0),
            testView.bottomAnchor.constraint(equalTo: g.bottomAnchor, constant: -40.0),
            
        ])
        
        btn.addTarget(self, action: #selector(btnTapped(_:)), for: .touchUpInside)
    }
    
    @objc func btnTapped(_ sender: Any?) {
        testView.insertNew()
    }
    
}

class SampleView: UIView {
    
    var containerView: UIView!
    var stackView: UIStackView!
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        commonInit()
    }
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        commonInit()
    }
    private func commonInit() {
        backgroundColor = .red
        setupView(frame: .zero)
    }
    
    private func setupView(frame:CGRect) {
        /* START CONTAINER VIEW */
        containerView = UIView()
        containerView.translatesAutoresizingMaskIntoConstraints = false
        addSubview(containerView)
        
        stackView = UIStackView()
        stackView.axis = .vertical
        stackView.spacing = 8
        stackView.translatesAutoresizingMaskIntoConstraints = false
        containerView.addSubview(stackView)
        
        NSLayoutConstraint.activate([

            containerView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 12),
            containerView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -12),
            containerView.topAnchor.constraint(equalTo: topAnchor, constant: 12),
            containerView.bottomAnchor.constraint(equalTo: bottomAnchor),
            
            stackView.topAnchor.constraint(equalTo: containerView.topAnchor, constant: 8.0),
            stackView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor, constant: 8.0),
            stackView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor, constant: -8.0),

        ])
        
        containerView.backgroundColor = UIColor.white
        /* END CONTAINER VIEW */
        
        // add 10 labels to the stack view
        for i in 1...10 {
            let v = UILabel()
            v.text = "Label (i)"
            v.backgroundColor = .green
            stackView.addArrangedSubview(v)
        }

    }
    
    func insertNew() {
        let v = UILabel()
        v.text = "New Label"
        v.backgroundColor = .cyan
        v.translatesAutoresizingMaskIntoConstraints = false
        
        // we're adding a label after 3rd label
        stackView.insertArrangedSubview(v, at: 3)
    }
}

It starts looking like this:

after tapping the "Insert" button, it looks like this:

Edit

To explain why your current approach isn’t working…

Starting with this layout:

each label’s Top is constrained to the previous label’s Bottom (with constant: spacing).

Those constraints are indicated by the blue arrows.

You then want to "insert" Next Round Label between Round Ends In and Winners Per Round:

Your code:

• adds the label
• adds a constraint from the Top of Next Round Label to the Bottom of Round Ends In
• adds a constraint from the Top of Winners Per Round to the Bottom of Next Round Label

but… Winners Per Round already has a .topAnchor connected to Round Ends In, so it now has two top anchors.

The conflicting constraints are shown in red:

As I said, I think your description of what you’re trying to do would lend itself to using stack views, and would make "inserting" views so much easier.

But, if you need to stick with your current "Top-to-Bottom" constraints approach, you have several options.

One – remove all the labels, then re-add and re-constrain them, including the one you’re inserting.

Two – track the constraints (using an array or custom object properties) so you can deactivate the conflicting constraint(s).

Three – use some code along the lines of

let theConstraint = containerView.constraints.first(where: {($0.secondItem as? UILabel) == roundEndsInLabel})

to "find" the constraint that needs to be deactivated.