private void FixItalics()
{
if (working || formatMap.IsInBatchUpdate)
{
return;
}
working = true;
formatMap.BeginBatchUpdate();
try {
foreach (var classifierType in formatMap.CurrentPriorityOrder)
{
if (classifierType == null)
{
continue;
}
if (classificationTypes.Contains(classifierType.Classification))
{
SetItalics(classifierType, settings.FlowControlUseItalics);
}
}
} finally {
formatMap.EndBatchUpdate();
working = false;
}
}
private void VSColorTheme_ThemeChanged(ThemeChangedEventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (_classificationFormatMapService == null || _classificationRegistry == null)
{
var componentModel = _serviceProvider.GetService <SComponentModel, IComponentModel>();
_classificationFormatMapService ??= componentModel?.GetService <IClassificationFormatMapService>();
_classificationRegistry ??= componentModel?.GetService <IClassificationTypeRegistryService>();
}
if (_classificationFormatMapService == null || _classificationRegistry == null)
{
return;
}
var logger = AcuminatorVSPackage.Instance?.AcuminatorLogger;
_fontAndColorStorage ??= _serviceProvider.GetService <SVsFontAndColorStorage, IVsFontAndColorStorage>();
_fontAndColorCacheManager ??= _serviceProvider.GetService <SVsFontAndColorCacheManager, IVsFontAndColorCacheManager>();
IClassificationFormatMap formatMap = _classificationFormatMapService.GetClassificationFormatMap(category: TextCategory);
if (_fontAndColorStorage == null || _fontAndColorCacheManager == null || formatMap == null)
{
return;
}
_fontAndColorCacheManager.CheckCache(ref _mefItemsGuid, out int _);
int openCategoryResult = _fontAndColorStorage.OpenCategory(ref _mefItemsGuid, (uint)__FCSTORAGEFLAGS.FCSF_READONLY);
if (openCategoryResult != VSConstants.S_OK)
{
logger?.LogMessage($"Error on opening category in the registry during the theme change. The error code is {openCategoryResult}", Logger.LogMode.Error);
}
try
{
var acuminatorThemeChangedEventArgs = new AcuminatorThemeChangedEventArgs(_fontAndColorStorage, _classificationRegistry, formatMap);
formatMap.BeginBatchUpdate();
AcuminatorThemeChanged?.Invoke(this, acuminatorThemeChangedEventArgs);
}
catch (Exception exception)
{
logger?.LogException(exception, logOnlyFromAcuminatorAssemblies: false, Logger.LogMode.Error);
}
finally
{
formatMap.EndBatchUpdate();
int refreshCacheResult = _fontAndColorCacheManager.RefreshCache(ref _mefItemsGuid);
if (refreshCacheResult != VSConstants.S_OK)
{
logger?.LogMessage($"Error on the refresh of MEF Items cache in the registry during the theme change. The error code is {refreshCacheResult}", Logger.LogMode.Error);
}
_fontAndColorStorage.CloseCategory();
}
}
public void UpdateClassifications(IClassificationFormatMap formatMap)
{
if (_updating || formatMap.IsInBatchUpdate)
{
return;
}
try {
_updating = true;
foreach (var identifier in _colorizerCache.Values)
{
if (!identifier.IsDirty)
{
continue;
}
if (!formatMap.IsInBatchUpdate)
{
formatMap.BeginBatchUpdate();
}
var textProperties = formatMap.GetTextProperties(identifier.Classification);
textProperties = textProperties.SetForeground(identifier.Color.ToColor());
formatMap.SetTextProperties(identifier.Classification, textProperties);
identifier.IsDirty = false;
}
} finally {
if (formatMap.IsInBatchUpdate)
{
formatMap.EndBatchUpdate();
}
_updating = false;
}
}
internal void FixComments()
{
if (_inUpdate || _formatMap == null || (_view != null && _view.IsClosed))
{
return;
}
bool batch = false;
try
{
_inUpdate = true;
if (!_formatMap.IsInBatchUpdate)
{
_formatMap.BeginBatchUpdate();
batch = true;
}
// First, go through the ones we know about:
// 1) Known comment types are italicized
foreach (var type in CommentTypes.Select(t => _typeRegistry.GetClassificationType(t)).Where(t => t != null))
{
Italicize(type);
}
// 2) Known doc tags
foreach (var type in DocTagTypes.Select(t => _typeRegistry.GetClassificationType(t)).Where(t => t != null))
{
Italicize(type);
}
// 3) Grab everything else that looks like a comment or doc tag
foreach (var classification in _formatMap.CurrentPriorityOrder.Where(c => c != null))
{
string name = classification.Classification;
var comparer = StringComparer.OrdinalIgnoreCase;
if (CommentTypes.Contains(name, comparer) || DocTagTypes.Contains(name, comparer))
{
continue;
}
if (name.IndexOf("comment", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("doc tag", StringComparison.OrdinalIgnoreCase) >= 0)
{
Italicize(classification);
}
}
}
finally
{
if (batch && _formatMap.IsInBatchUpdate)
{
_formatMap.EndBatchUpdate();
}
_inUpdate = false;
}
}
static void ResetStyleCache()
{
lock (_syncRoot) {
DefaultClassificationFormatMap.BeginBatchUpdate();
foreach (var item in _BackupFormattings)
{
DefaultClassificationFormatMap.SetTextProperties(item.Key, item.Value);
}
DefaultClassificationFormatMap.EndBatchUpdate();
var cache = new Dictionary <string, StyleBase>(_SyntaxStyleCache.Count, StringComparer.OrdinalIgnoreCase);
LoadSyntaxStyleCache(cache);
_SyntaxStyleCache = cache;
}
}
private void UpdateTheme(EventArgs e)
{
Color defaultBackground = VSColorTheme.GetThemedColor(EnvironmentColors.ToolWindowBackgroundColorKey);
Color defaultForeground = VSColorTheme.GetThemedColor(EnvironmentColors.ToolWindowTextColorKey);
IClassificationFormatMap formatMap = ClassificationFormatMapService.GetClassificationFormatMap(category: "code");
try
{
formatMap.BeginBatchUpdate();
}
finally
{
formatMap.EndBatchUpdate();
}
}
internal void UpdateColors(IEnumerable <CategoryItemDecorationSettings> changedItems)
{
if (_classificationFormatMapService == null || _registryService == null)
{
SatisfyImports();
}
if (_classificationFormatMap == null)
{
_classificationFormatMap = _classificationFormatMapService.GetClassificationFormatMap(_textView);
}
if (_T4Types == null)
{
_T4Types = _classificationFormatMap.CurrentPriorityOrder.Where(x => x?.Classification.Contains("T4") == true).ToList();
}
try
{
if (_classificationFormatMap.IsInBatchUpdate)
{
return;
}
_classificationFormatMap.BeginBatchUpdate();
foreach (CategoryItemDecorationSettings changedItem in changedItems)
{
string classificationKey = changedItem.DisplayName;
IClassificationType classificationType = _T4Types.FirstOrDefault(x => x.Classification.Contains(classificationKey));
if (classificationType == null)
{
continue;
}
TextFormattingRunProperties textProperties = CreateTextProperties(changedItem);
_classificationFormatMap.SetExplicitTextProperties(classificationType, textProperties);
}
}
catch (Exception)
{
//TO-DO: Log exception
}
finally
{
_classificationFormatMap.EndBatchUpdate();
}
}
void DecorateClassificationTypes()
{
if (_ClassificationFormatMap.IsInBatchUpdate)
{
return;
}
_ClassificationFormatMap.BeginBatchUpdate();
var textProperty = _ClassificationFormatMap.GetTextProperties(_RegService.GetClassificationType("text"));
foreach (var item in _ClassificationFormatMap.CurrentPriorityOrder)
{
if (item == null)
{
continue;
}
#if DEBUG
Debug.Write(item.Classification);
Debug.Write(' ');
foreach (var type in item.BaseTypes)
{
Debug.Write('/');
Debug.Write(type.Classification);
}
Debug.WriteLine('/');
#endif
StyleBase style;
if (__Styles.TryGetValue(item.Classification, out style))
{
TextFormattingRunProperties initialProperty;
if (__InitialProperties.TryGetValue(item.Classification, out initialProperty) == false)
{
var p = _ClassificationFormatMap.GetExplicitTextProperties(item);
if (p == null)
{
continue;
}
__InitialProperties[item.Classification] = initialProperty = p;
}
_ClassificationFormatMap.SetTextProperties(item, SetProperties(initialProperty, style, textProperty.FontRenderingEmSize));
}
}
_ClassificationFormatMap.EndBatchUpdate();
}
private void UpdateClassificationColors(IClassificationFormatMap formatMap)
{
try
{
formatMap.BeginBatchUpdate();
foreach (var pair in ThemeColors.Colors)
{
var type = pair.Key;
var color = pair.Value;
var classificationType = _classificationTypeRegistry.GetClassificationType(type);
if (classificationType == null)
{
Error.LogError($"Cannot find classification type related to {type}", Module);
continue;
}
var oldProp = formatMap.GetTextProperties(classificationType);
var foregroundBrush = color.Foreground == null
? null
: new SolidColorBrush(color.Foreground.Value);
var backgroundBrush = color.Background == null
? null
: new SolidColorBrush(color.Background.Value);
var newProp = TextFormattingRunProperties.CreateTextFormattingRunProperties(
foregroundBrush, backgroundBrush, oldProp.Typeface, null, null, oldProp.TextDecorations,
oldProp.TextEffects, oldProp.CultureInfo);
formatMap.SetTextProperties(classificationType, newProp);
}
}
finally
{
formatMap.EndBatchUpdate();
}
}
public CodeViewDecorator(IWpfTextView view)
{
view.Closed += View_Closed;
view.VisualElement.IsVisibleChanged += VisualElement_IsVisibleChanged;
if (_Initialized == false)
{
view.VisualElement.IsVisibleChanged += MarkInitialized;
}
Config.Updated += SettingsUpdated;
_ClassificationFormatMap = ServicesHelper.Instance.ClassificationFormatMap.GetClassificationFormatMap(view);
_EditorFormatMap = ServicesHelper.Instance.EditorFormatMap.GetEditorFormatMap(view);
//_ClassificationFormatMap.ClassificationFormatMappingChanged += FormatUpdated;
_RegService = ServicesHelper.Instance.ClassificationTypeRegistry;
_TextView = view;
_IsViewActive = true;
if (_Initialized)
{
Debug.WriteLine("Decorate known types");
Decorate(FormatStore.ClassificationTypeStore.Keys, true);
_EditorFormatMap.FormatMappingChanged += FormatUpdated;
}
else
{
_EditorFormatMap.FormatMappingChanged += BackupFormat;
_ClassificationFormatMap.BeginBatchUpdate();
foreach (var item in _ClassificationFormatMap.CurrentPriorityOrder)
{
if (item != null)
{
_ClassificationFormatMap.SetTextProperties(item, _ClassificationFormatMap.GetExplicitTextProperties(item));
}
}
_ClassificationFormatMap.EndBatchUpdate();
}
}
private void MakeBoldItalics()
{
bool enabled = settings.BoldAsItalicsEnabled;
if (!enabled || working || formatMap.IsInBatchUpdate)
{
return;
}
working = true;
formatMap.BeginBatchUpdate();
try {
foreach (var classifierType in formatMap.CurrentPriorityOrder)
{
if (classifierType == null)
{
continue;
}
MakeItalicsIfApplies(classifierType);
}
} finally {
formatMap.EndBatchUpdate();
working = false;
}
}
void DecorateClassificationTypes()
{
if (_ClassificationFormatMap.IsInBatchUpdate)
{
return;
}
_ClassificationFormatMap.BeginBatchUpdate();
var defaultSize = _ClassificationFormatMap.DefaultTextProperties.FontRenderingEmSize;
foreach (var item in _ClassificationFormatMap.CurrentPriorityOrder)
{
StyleBase style;
TextFormattingRunProperties textFormatting;
if (item == null ||
(style = TextEditorHelper.GetStyle(item.Classification)) == null ||
(textFormatting = TextEditorHelper.GetBackupFormatting(item.Classification)) == null)
{
continue;
}
_ClassificationFormatMap.SetTextProperties(item, SetProperties(textFormatting, style, defaultSize));
}
_ClassificationFormatMap.EndBatchUpdate();
Debug.WriteLine("Decorated");
}
public void EndBatchUpdate() => categoryMap.EndBatchUpdate();
void DecorateClassificationTypes(IEnumerable <IClassificationType> classifications, bool fullUpdate)
{
if (_ClassificationFormatMap.IsInBatchUpdate)
{
return;
}
var defaultSize = _ClassificationFormatMap.DefaultTextProperties.FontRenderingEmSize;
var updated = new Dictionary <IClassificationType, TextFormattingRunProperties>();
StyleBase style;
TextFormattingRunProperties textFormatting;
foreach (var item in classifications)
{
if (item == null ||
(style = FormatStore.GetOrCreateStyle(item)) == null ||
(textFormatting = FormatStore.GetOrSaveBackupFormatting(item, _Initialized == false)) == null)
{
continue;
}
var p = SetProperties(textFormatting, style, defaultSize);
if (p != textFormatting || fullUpdate)
{
updated[item] = p;
}
}
var refreshList = new List <(IClassificationType type, TextFormattingRunProperties property)>();
foreach (var item in updated)
{
foreach (var subType in item.Key.GetSubTypes())
{
if (updated.ContainsKey(subType) == false)
{
if ((style = FormatStore.GetOrCreateStyle(subType)) == null ||
(textFormatting = FormatStore.GetBackupFormatting(subType)) == null)
{
continue;
}
refreshList.Add((subType, SetProperties(textFormatting, style, defaultSize)));
}
}
}
if (refreshList.Count > 0)
{
foreach (var item in refreshList)
{
updated[item.type] = item.property;
}
}
if (updated.Count > 0)
{
_ClassificationFormatMap.BeginBatchUpdate();
foreach (var item in updated)
{
_ClassificationFormatMap.SetTextProperties(item.Key, item.Value);
Debug.WriteLine("Update format: " + item.Key.Classification);
}
_ClassificationFormatMap.EndBatchUpdate();
Debug.WriteLine($"Decorated {updated.Count} formats");
}
}
private void VSColorTheme_ThemeChanged(ThemeChangedEventArgs e)
{
if (AcuminatorVSPackage.Instance?.ClassificationFormatMapService == null ||
AcuminatorVSPackage.Instance.ClassificationRegistry == null ||
classificationTypeName == null)
{
return;
}
var fontAndColorStorage =
ServiceProvider.GlobalProvider.GetService(typeof(SVsFontAndColorStorage)) as IVsFontAndColorStorage;
var fontAndColorCacheManager =
ServiceProvider.GlobalProvider.GetService(typeof(SVsFontAndColorCacheManager)) as IVsFontAndColorCacheManager;
if (fontAndColorStorage == null || fontAndColorCacheManager == null)
{
return;
}
Guid guidTextEditorFontCategory = DefGuidList.guidTextEditorFontCategory;
fontAndColorCacheManager.CheckCache(ref guidTextEditorFontCategory, out int _);
if (fontAndColorStorage.OpenCategory(ref guidTextEditorFontCategory, (uint)__FCSTORAGEFLAGS.FCSF_READONLY) != VSConstants.S_OK)
{
//TODO Log error
}
Color?foregroundColorForTheme = VSColors.GetThemedColor(classificationTypeName);
if (foregroundColorForTheme == null)
{
return;
}
IClassificationFormatMap formatMap = AcuminatorVSPackage.Instance.ClassificationFormatMapService
.GetClassificationFormatMap(category: textCategory);
if (formatMap == null)
{
return;
}
try
{
formatMap.BeginBatchUpdate();
ForegroundColor = foregroundColorForTheme;
var bqlOperatorClasType = AcuminatorVSPackage.Instance.ClassificationRegistry
.GetClassificationType(classificationTypeName);
if (bqlOperatorClasType == null)
{
return;
}
ColorableItemInfo[] colorInfo = new ColorableItemInfo[1];
if (fontAndColorStorage.GetItem(classificationTypeName, colorInfo) != VSConstants.S_OK) //comment from F# repo: "we don't touch the changes made by the user"
{
var properties = formatMap.GetTextProperties(bqlOperatorClasType);
var newProperties = properties.SetForeground(ForegroundColor.Value);
formatMap.SetTextProperties(bqlOperatorClasType, newProperties);
}
}
catch (Exception)
{
//TODO Log error here
}
finally
{
formatMap.EndBatchUpdate();
}
}