!important

[barotto]

Hi,
implementing !important might be important (pun intended) to create a rcss lib similar to Bootstrap (at least part of it).
For example I found inconvenient to use something like

.d-none { display: none; }

in my program because without the !important rule it won't work for anything that set the display property, unless rcss files are loaded in a specific order, which might be problematic in some context, especially when inline style is used.
I'm willing to look into it myself but, knowing almost nothing about RmlUi's structure, I need some pointers for where to look in the source files to start implementing it.
Thanks.

[mikke89]

I've thought about this feature in the past. The tricky bit here is

1. Normally the specificity of properties (that is, how much priority they get) is determined by the style rule it belongs to, and the rule's order relative to other rules. By adding !important to single properties within a rule, we now have different specificity for properties within a rule. This breaks current assumptions.
2. Now we somehow need to parse the !important string in the property parsers.
3. There is also an assumption currently that inline style rules always take precedent over any style sheet rules.

Some suggestions and pointers on how we could deal with this:

1. I think the best course of action here is to add two StyleSheetNode for each rule, one for normal properties, and another for all properties declared with !important. Note that this requires some pre-parsing of all the properties. See StyleSheetParser.cpp#L560-L569 and StyleSheetNode::CalculateAndSetSpecificity. Each property also has an individual specificity value, you might be able to take advantage of that instead.
2. We could probably do a "pre-parse" (see previous) so we don't actually have to do this work in each individual property parser (there are many distinct ones for eg. number, string, transform etc.). Not sure about all the functions that would be affected by this. See PropertySpecification::ParsePropertyDeclaration.
3. So now we have to compare the specificity of all inline properties against the style sheet properties. See eg, ElementStyle::SetProperty. It is unclear if other code needs to be updated due to this change in assumptions, probably ElementStyle::GetProperty at least. All of this would of course be avoided if we say that inline styles take precedent over !important rules.

For these reasons I concluded it was not worth the implementation cost for myself, but if you want to take this on I'm all open for PRs :) I hope there are enough pointers here that could get you started if you decide to work on this. Good luck, and let me know if you could need some more help later on.

Note that this feature would be completely trivial to add if !important was part of the style rule. Then the above remarks would be avoided entirely, at least 1-2 and 3 would become easier (and a non-issue if inline styles take precedent). This may be something to consider.

[barotto]

Thanks, I'll try to look into it, though for now I used workarounds in my project so it's not really a priority for me.
Point 1 is a bit worrisome...
Point 2 I hope won't be too difficult?
Point 3 could be avoided if we accept the limitation, which might be ok given the scope of the project.

[mikke89]

Sounds good. I think Point 2 will be the easiest one. I'm also worried about Point 1, if we are optimistic it could be easier than I imagine though (heh). For Point 3 I'm also worried about performance implications, but we could always take that limitation route.