Flutter: Differentiate between Widget param = null and an unset param - flutter

Question

I have a CustomButton like so:
class CustomButton extends StatelessWidget {
const CustomButton(
{Key key, this.onPressed, this.child, this.padding})
: super(key: key);
final VoidCallback onPressed;
final Widget child;
final EdgeInsetsGeometry padding;
#override
Widget build(BuildContext context) {
final defaultPadding = EdgeInsets.symmetric(vertical: 13);
return FlatButton(
padding: padding ?? defaultPadding,
child: child,
onPressed: onPressed,
// + some irrelevant custom properties
);
}
}
I've included various applications of the widget, along with the desired outcome:
CustomButton(child: Text('👋'), onPressed: () {}) // 1⃣ no padding specified; use default
CustomButton(..., padding: null) // 2⃣ use NO padding
CustomButton(..., padding: EdgeInsets.only(left:1)) // 3⃣ use specified padding
The issue is that I can't differentiate between when padding is not passed 1⃣ and when padding: null is passed 2⃣ . In both cases, defaultPadding is applied -- whereas I want padding: null to result in no padding being applied.
How can I do this?

Answer 1

In your case, why not just let the default value for padding be your desired default? EdgeInsets.symmetric is a const constructor, so it can be used to create a default argument:
class CustomButton extends StatelessWidget {
static const defaultPadding = EdgeInsets.symmetric(vertical: 13);
const CustomButton(
{Key key, this.onPressed, this.child, this.padding = defaultPadding})
: super(key: key);
Normally you should use default arguments when you can. You'd use ?? for defaults when you can't (because the default you want isn't const) or when you do want null and an omitted argument to be handled in the same way.
In general, there is no built-way to distinguish between a default value being explicitly passed and a default value being used because it was omitted. In some cases you maybe could create a sentinel value that would be impossible for callers outside your library to pass:
class Foo {
const Foo(this.x);
final int x;
}
// Private so that nothing outside the library can pass it.
const _defaultFoo = Foo(0);
void bar({Foo foo = _defaultFoo}) {
if (foo == _defaultFoo) {
// Argument omitted.
} else {
// Argument was explicitly supplied.
}
}

Answer 2

final EdgeInsetsGeometry padding;
The padding doesn't have any initial value, thus whether you pass it null or nothing it will be null anyway.
you could fix this by changing your class constructor to this :
const CustomButton({Key key, this.onPressed, this.child, this.padding = EdgeInsets.zero})
this way the padding will have zero value instead of null if it is not given any value when it's being instantiated.
This will do what you want but vice versa, when it's passed null it will get default padding, if not passed anything, zero padding.
Hope it helps.

Answer 3

See the following example
class A {
final int a;
const A({this.a = 10});
}
void callMe({A par1 = const A(a: 10)}) {
if(par1 != null)
{
print(par1.a);
}
else {
print("null");
}
}
void main() {
callMe(par1: null);
callMe();
callMe(par1: A(a: 100));
}
So in your case you can do this simply tweak your constructor.
const CustomButton(
{Key key, this.onPressed, this.child, this.padding = EdgeInsets.symmetric(vertical: 13)})
: super(key: key);