I don't really like special-casing 0. Either;

• Keep it as "txdelegate->unit = model->getOptionsModel()->getDisplayUnit();", and remove the parameter again

or

• Pass a valid parameter everywhere you use this function, and use txdelegate->unit = nUnit.

I'm not sure if I understand you, nUnit is non-zero, when updateDisplayUnit() is called via the displayUnitChanged() SIGNAL and 0 when called to init. Do you want me to use updateDisplayUnit(0) and remove the default-init of 0?

I don't want to use 0 at all, the argument adds unneeded complexity. IMO I think it's best to remove the argument nUnit completely, and always use the unit from the optionsmodel (as it was before).

We have a SLOT and SIGNAL, which handles the unit, why should we not use this? It's used in the other 2 files, too. I really like the ?: operator and disagree here. Can we find a consensus which leads to similar solutions for all 3 files edited in this pull :)?

Well, the other alternative is to always pass in a valid unit value.

You may like it, but there is no real need to special-case 0, no need to use ?:. You only need one function signature for this, without special magic values which are bound to bite you some day.

If you look at how I've done it in the other files it's like this:

void MyClass::setModel(model) 
{
    if(model)
    {
        /* Set initial value */
        fooChanged(model->getFoo()); 
        /* Track changes */
        connect(model, SIGNAL(fooChanged(int)), self, SLOT(fooChanged(int)))
    }
}

void MyClass::fooChanged(value)
{
    // Do something with value
}

So everywhere you call updateDisplayUnit() use updateDisplayUnit(model->getOptionsModel->getDisplayUnit()). Either that or the previous suggestion,

void MyClass::setModel(model) 
{
    if(model)
    {
        /* Set initial value */
        blaChanged(); 
        /* Track changes */
        connect(model, SIGNAL(fooChanged(int)), self, SLOT(fooChanged()))
    }
}

void MyClass::fooChanged()
{
    if(model)
    {
        value = model->getFoo();
        // Do something with value
    }
}

which IMO in this particular case is most sensible as we're always taking the value from the options model anyway. Both are valid solutions, but don't try to do them both at once.

So simply not use the int passed from fooChanged() SIGNAL... it is cleaner yes, I just was sad we didn't use it.
I'm going to change it in all 3 files.

There's ton of places where the signal argument is not used, also in Qt itself, no need to be sad about it :)