public override void TraverseRecursive(VisualElement element, int depth)
{
int count = this.m_Matchers.Count;
int count2 = this.m_Matchers.Count;
for (int i = 0; i < count2; i++)
{
RuleMatcher ruleMatcher = this.m_Matchers[i];
StyleComplexSelector arg_51_1 = ruleMatcher.complexSelector;
Action <VisualElement, MatchResultInfo> arg_51_2;
if ((arg_51_2 = UQuery.UQueryMatcher.< > c.< > 9__5_0) == null)
{
arg_51_2 = (UQuery.UQueryMatcher.< > c.< > 9__5_0 = new Action <VisualElement, MatchResultInfo>(UQuery.UQueryMatcher.< > c.< > 9. < TraverseRecursive > b__5_0));
}
bool flag = StyleSelectorHelper.MatchRightToLeft(element, arg_51_1, arg_51_2);
if (flag)
{
bool flag2 = this.OnRuleMatchedElement(ruleMatcher, element);
if (flag2)
{
return;
}
}
}
base.Recurse(element, depth);
bool flag3 = this.m_Matchers.Count > count;
if (flag3)
{
this.m_Matchers.RemoveRange(count, this.m_Matchers.Count - count);
return;
}
}
private void FinishSelector()
{
FinishCurrentSelector();
if (styleSelectors.Count > 0)
{
var selector = new StyleComplexSelector();
selector.selectors = styleSelectors.ToArray();
styleSelectors.Clear();
m_Matchers.Add(new RuleMatcher {
complexSelector = selector
});
}
}
unsafe public bool IsCandidate(StyleComplexSelector complexSel)
{
// We traverse the hash values for the complex selector parts to detect if any part isn't found
// in the Bloom filter, in which case the selector is not a candidate for the exhaustive search.
// Also, if a value of 0 is found during the search, then all parts have been visited without a
// Bloom filter rejection, in which case we must proceed with the exhaustive search.
for (int i = 0; i < Hashes.kSize; i++)
{
// A default part hash value means that all parts have been visited without a Bloom filter rejection.
if (complexSel.ancestorHashes.hashes[i] == 0)
{
return(true);
}
// A negative search in the Bloom filter means that the exhaustive search can be skipped for this selector.
if (!m_CountingBloomFilter.ContainsHash((uint)complexSel.ancestorHashes.hashes[i]))
{
return(false);
}
}
return(true);
}
private void SetupReferences()
{
bool flag = this.complexSelectors == null || this.rules == null;
if (!flag)
{
StyleRule[] rules = this.rules;
for (int i = 0; i < rules.Length; i++)
{
StyleRule styleRule = rules[i];
StyleProperty[] properties = styleRule.properties;
for (int j = 0; j < properties.Length; j++)
{
StyleProperty styleProperty = properties[j];
bool flag2 = StyleSheet.CustomStartsWith(styleProperty.name, StyleSheet.kCustomPropertyMarker);
if (flag2)
{
styleRule.customPropertiesCount++;
styleProperty.isCustomProperty = true;
}
StyleValueHandle[] values = styleProperty.values;
for (int k = 0; k < values.Length; k++)
{
StyleValueHandle handle = values[k];
bool flag3 = handle.IsVarFunction();
if (flag3)
{
styleProperty.requireVariableResolve = true;
break;
}
}
}
}
int l = 0;
int num = this.complexSelectors.Length;
while (l < num)
{
this.complexSelectors[l].CachePseudoStateMasks();
l++;
}
this.orderedClassSelectors = new Dictionary <string, StyleComplexSelector>(StringComparer.Ordinal);
this.orderedNameSelectors = new Dictionary <string, StyleComplexSelector>(StringComparer.Ordinal);
this.orderedTypeSelectors = new Dictionary <string, StyleComplexSelector>(StringComparer.Ordinal);
int m = 0;
while (m < this.complexSelectors.Length)
{
StyleComplexSelector styleComplexSelector = this.complexSelectors[m];
bool flag4 = styleComplexSelector.ruleIndex < this.rules.Length;
if (flag4)
{
styleComplexSelector.rule = this.rules[styleComplexSelector.ruleIndex];
}
styleComplexSelector.orderInStyleSheet = m;
StyleSelector styleSelector = styleComplexSelector.selectors[styleComplexSelector.selectors.Length - 1];
StyleSelectorPart styleSelectorPart = styleSelector.parts[0];
string key = styleSelectorPart.value;
Dictionary <string, StyleComplexSelector> dictionary = null;
switch (styleSelectorPart.type)
{
case StyleSelectorType.Wildcard:
case StyleSelectorType.Type:
key = (styleSelectorPart.value ?? "*");
dictionary = this.orderedTypeSelectors;
break;
case StyleSelectorType.Class:
dictionary = this.orderedClassSelectors;
break;
case StyleSelectorType.PseudoClass:
key = "*";
dictionary = this.orderedTypeSelectors;
break;
case StyleSelectorType.RecursivePseudoClass:
goto IL_22B;
case StyleSelectorType.ID:
dictionary = this.orderedNameSelectors;
break;
default:
goto IL_22B;
}
IL_249:
bool flag5 = dictionary != null;
if (flag5)
{
StyleComplexSelector nextInTable;
bool flag6 = dictionary.TryGetValue(key, out nextInTable);
if (flag6)
{
styleComplexSelector.nextInTable = nextInTable;
}
dictionary[key] = styleComplexSelector;
}
m++;
continue;
IL_22B:
Debug.LogError(string.Format("Invalid first part type {0}", styleSelectorPart.type));
goto IL_249;
}
}
}
void SetupReferences()
{
if (complexSelectors == null || rules == null)
{
return;
}
// Setup rules and properties for var
foreach (var rule in rules)
{
foreach (var property in rule.properties)
{
if (property.name.StartsWith("--"))
{
++rule.customPropertiesCount;
property.isCustomProperty = true;
}
}
}
for (int i = 0, count = complexSelectors.Length; i < count; i++)
{
complexSelectors[i].CachePseudoStateMasks();
}
orderedClassSelectors = new TableType(StringComparer.Ordinal);
orderedNameSelectors = new TableType(StringComparer.Ordinal);
orderedTypeSelectors = new TableType(StringComparer.Ordinal);
for (int i = 0; i < complexSelectors.Length; i++)
{
// Here we set-up runtime-only pointers
StyleComplexSelector complexSel = complexSelectors[i];
if (complexSel.ruleIndex < rules.Length)
{
complexSel.rule = rules[complexSel.ruleIndex];
}
complexSel.orderInStyleSheet = i;
StyleSelector lastSelector = complexSel.selectors[complexSel.selectors.Length - 1];
StyleSelectorPart part = lastSelector.parts[0];
string key = part.value;
TableType tableToUse = null;
switch (part.type)
{
case StyleSelectorType.Class:
tableToUse = orderedClassSelectors;
break;
case StyleSelectorType.ID:
tableToUse = orderedNameSelectors;
break;
case StyleSelectorType.Type:
case StyleSelectorType.Wildcard:
key = part.value ?? "*";
tableToUse = orderedTypeSelectors;
break;
// in this case we assume a wildcard selector
// since a selector such as ":selected" applies to all elements
case StyleSelectorType.PseudoClass:
key = "*";
tableToUse = orderedTypeSelectors;
break;
default:
Debug.LogError($"Invalid first part type {part.type}");
break;
}
if (tableToUse != null)
{
StyleComplexSelector previous;
if (tableToUse.TryGetValue(key, out previous))
{
complexSel.nextInTable = previous;
}
tableToUse[key] = complexSel;
}
}
}
public RuleMatcher(StyleSheet sheet, StyleComplexSelector complexSelector, int styleSheetIndexInStack)
{
this.sheet = sheet;
this.complexSelector = complexSelector;
}
