public IEnumerable <ICssCompletionListEntry> GetListEntries(CssCompletionContext context)
{
Declaration dec = context.ContextItem.FindType <Declaration>();
if (dec == null || dec.PropertyName == null || (!dec.PropertyName.Text.EndsWith("animation-name", StringComparison.OrdinalIgnoreCase) && dec.PropertyName.Text != "animation"))
{
yield break;
}
StyleSheet stylesheet = context.ContextItem.StyleSheet;
var visitor = new CssItemCollector <KeyFramesDirective>();
stylesheet.Accept(visitor);
foreach (string name in visitor.Items.Select(d => d.Name.Text).Distinct(StringComparer.OrdinalIgnoreCase))
{
yield return(new CompletionListEntry(name));
}
}
private void UpdateCache(ParseItem item)
{
var visitor = new CssItemCollector <Declaration>(true);
item.Accept(visitor);
foreach (Declaration dec in visitor.Items)
{
string text = dec.Text;
if (text.StartsWith("var-", StringComparison.Ordinal))
{
if (!_cache.Contains(dec))
{
_cache.Add(dec);
}
}
}
}
private void UpdateCache(ParseItem item)
{
var visitor = new CssItemCollector <SimpleSelector>(true);
item.Accept(visitor);
foreach (SimpleSelector ss in visitor.Items)
{
string text = ss.Text;
if (ModernizrProvider.IsModernizr(text))
{
if (!Cache.Contains(ss))
{
Cache.Add(ss);
}
}
}
}
public IEnumerable <ISmartTagAction> GetSmartTagActions(ParseItem item, int position, ITrackingSpan itemTrackingSpan, ITextView view)
{
AtDirective directive = (AtDirective)item;
if (!item.IsValid || !directive.IsVendorSpecific())
{
yield break;
}
ICssSchemaInstance schema = CssSchemaManager.SchemaManager.GetSchemaRootForBuffer(view.TextBuffer);
var visitor = new CssItemCollector <AtDirective>();
directive.Parent.Accept(visitor);
ICssCompletionListEntry entry = VendorHelpers.GetMatchingStandardEntry(directive, schema);
if (entry != null && !visitor.Items.Any(d => d.Keyword != null && "@" + d.Keyword.Text == entry.DisplayText))
{
yield return(new MissingStandardDirectiveSmartTagAction(itemTrackingSpan, directive, entry.DisplayText, view));
}
}
public IEnumerable <ICssCompletionListEntry> GetListEntries(CssCompletionContext context)
{
HashSet <string> classNames = new HashSet <string>();
HashSet <ICssCompletionListEntry> entries = new HashSet <ICssCompletionListEntry>();
StyleSheet stylesheet = context.ContextItem.StyleSheet;
var visitorRules = new CssItemCollector <ClassSelector>();
stylesheet.Accept(visitorRules);
foreach (ClassSelector item in visitorRules.Items)
{
if (item != context.ContextItem && !classNames.Contains(item.Text))
{
classNames.Add(item.Text);
entries.Add(new CompletionListEntry(item.Text));
}
}
return(entries);
}
public IEnumerable <ITagSpan <IOutliningRegionTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0 || !EnsureInitialized())
{
yield break;
}
var visitor = new CssItemCollector <UrlItem>();
_tree.StyleSheet.Accept(visitor);
foreach (UrlItem url in visitor.Items.Where(u => u.UrlString != null && u.Start >= spans[0].Start))
{
if (url.UrlString.Text.IndexOf("base64,") > -1 && buffer.CurrentSnapshot.Length >= url.UrlString.AfterEnd)
{
var image = ImageQuickInfo.CreateImage(url.UrlString.Text.Trim('"', '\''));
var span = new SnapshotSpan(new SnapshotPoint(buffer.CurrentSnapshot, url.UrlString.Start), url.UrlString.Length);
var tag = new OutliningRegionTag(true, true, url.UrlString.Length + " characters", image);
yield return(new TagSpan <IOutliningRegionTag>(span, tag));
}
}
}
private void UpdateDeclarationCache(ParseItem item)
{
var visitor = new CssItemCollector <Declaration>(true);
item.Accept(visitor);
HashSet <RuleBlock> rules = new HashSet <RuleBlock>();
foreach (Declaration dec in visitor.Items)
{
RuleBlock rule = dec.Parent as RuleBlock;
if (rule == null || rules.Contains(rule))
{
continue;
}
var vendors = rule.Declarations.Where(d => d.IsValid && d.IsVendorSpecific());
foreach (Declaration vendor in vendors)
{
string name = GetStandardName(vendor);
Declaration standard = rule.Declarations.FirstOrDefault(d => d.IsValid && d.PropertyName.Text == name);
if (standard != null)
{
if (!Cache.Contains(standard))
{
Cache.Add(standard);
}
if (GetValueText(standard) == GetValueText(vendor) && !Cache.Contains(vendor))
{
Cache.Add(vendor);
}
}
}
rules.Add(rule);
}
}
void Tree_ItemsChanged(object sender, CssItemsChangedEventArgs e)
{
CssTree tree = (CssTree)sender;
foreach (ParseItem item in e.InsertedItems)
{
var visitor = new CssItemCollector <Declaration>(true);
item.Accept(visitor);
foreach (Declaration dec in visitor.Items)
{
if (dec.PropertyName != null && dec.PropertyName.Text == "display" && dec.Values.Any(v => v.Text == "inline"))
{
_cache.Add(dec);
ParseItem rule = dec.Parent;
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => Update(rule, tree)), DispatcherPriority.Normal);
}
}
}
foreach (ParseItem item in e.DeletedItems)
{
var visitor = new CssItemCollector <Declaration>(true);
item.Accept(visitor);
foreach (Declaration deleted in visitor.Items)
{
if (_cache.Contains(deleted))
{
_cache.Remove(deleted);
ParseItem rule = deleted.Parent;
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => Update(rule, tree)), DispatcherPriority.Normal);
}
}
}
}
private IList <ParseItem> FindItems()
{
if (_item is HexColorValue)
{
var visitor = new CssItemCollector <HexColorValue>();
_item.StyleSheet.Accept(visitor);
return(visitor.Items.Where(i => i.Text == _item.Text).ToArray());
}
else if (_item is FunctionColor)
{
var visitor = new CssItemCollector <FunctionColor>();
_item.StyleSheet.Accept(visitor);
return(visitor.Items.Where(i => i.Text == _item.Text).ToArray());
}
else if (_item is TokenItem)
{
var visitor = new CssItemCollector <TokenItem>();
_item.StyleSheet.Accept(visitor);
return(visitor.Items.Where(i => i.TokenType == CssTokenType.Identifier && i.Text == _item.Text && i.FindType <Declaration>() != null).ToArray());
}
return(null);
}
private string RemoveDuplicateProperties(StringBuilder sb, CssEditorDocument doc)
{
var visitor = new CssItemCollector <RuleBlock>(true);
doc.Tree.StyleSheet.Accept(visitor);
foreach (RuleBlock rule in visitor.Items.Reverse())
{
HashSet <string> list = new HashSet <string>();
foreach (Declaration dec in rule.Declarations.Reverse())
{
if (list.Contains(dec.Text))
{
sb.Remove(dec.Start, dec.Length);
continue;
}
list.Add(dec.Text);
}
}
return(sb.ToString());
}
private string AddMissingVendorDeclarations(StringBuilder sb, CssEditorDocument doc, ICssSchemaInstance rootSchema)
{
var visitor = new CssItemCollector <Declaration>(true);
doc.Tree.StyleSheet.Accept(visitor);
var items = visitor.Items.Where(d => d.IsValid && !d.IsVendorSpecific() && d.PropertyName.Text != "filter");
foreach (Declaration dec in items.Reverse())
{
ICssSchemaInstance schema = CssSchemaManager.SchemaManager.GetSchemaForItem(rootSchema, dec);
var missingEntries = dec.GetMissingVendorSpecifics(schema);
if (missingEntries.Any())
{
var missingPrefixes = missingEntries.Select(e => e.Substring(0, e.IndexOf('-', 1) + 1));
string vendors = GetVendorDeclarations(missingPrefixes, dec);
sb.Insert(dec.Start, vendors);
}
}
return(sb.ToString());
}
private void Calculate()
{
// IDs
var visitorIDs = new CssItemCollector <IdSelector>();
_selector.Accept(visitorIDs);
if (visitorIDs.Items.Count > 0)
{
IDs = visitorIDs.Items.Count;// *100;
}
// Classes
var visitorClasses = new CssItemCollector <ClassSelector>();
_selector.Accept(visitorClasses);
if (visitorClasses.Items.Count > 0)
{
Classes = visitorClasses.Items.Count;// *10;
}
// Attributes
var visitorAttribute = new CssItemCollector <AttributeSelector>();
_selector.Accept(visitorAttribute);
if (visitorAttribute.Items.Count > 0)
{
Attributes = visitorAttribute.Items.Count;// *10;
}
// Elements
var visitorElements = new CssItemCollector <ItemName>();
_selector.Accept(visitorElements);
Elements = visitorElements.Items.Where(i => i.Text != "*" && i.FindType <AttributeSelector>() == null).Count();
// Pseudo Elements
var visitorPseudoElementSelector = new CssItemCollector <PseudoElementSelector>();
_selector.Accept(visitorPseudoElementSelector);
var visitorPseudoElementFunctionSelector = new CssItemCollector <PseudoElementFunctionSelector>();
_selector.Accept(visitorPseudoElementFunctionSelector);
PseudoElements = visitorPseudoElementSelector.Items.Count + visitorPseudoElementFunctionSelector.Items.Count;
// Pseudo Classes
var visitorPseudoClassSelector = new CssItemCollector <PseudoClassSelector>();
_selector.Accept(visitorPseudoClassSelector);
var visitorPseudoClassFunctionSelector = new CssItemCollector <PseudoClassFunctionSelector>(true);
_selector.Accept(visitorPseudoClassFunctionSelector);
int pseudoClases = visitorPseudoClassSelector.Items.Count(p => !p.IsPseudoElement());
pseudoClases += visitorPseudoClassFunctionSelector.Items.Where(p => !p.Text.StartsWith(":not(", StringComparison.Ordinal) && !p.Text.StartsWith(":matches(", StringComparison.Ordinal)).Count();
Elements += visitorPseudoClassSelector.Items.Count(p => p.IsPseudoElement());
if (pseudoClases > 0)
{
PseudoClasses = pseudoClases;// *10;
}
// Total
//Total = IDs + Classes + Attributes + Elements + PseudoElements + PseudoClasses;
}
