private void DoListAction(string name, ListKind list, bool isAdd, bool generateUpdate = true)
{
Dispatcher.Invoke(() =>
{
var result = isAdd
? characterManager.Add(name, list)
: characterManager.Remove(name, list);
var character = characterManager.Find(name);
if (isAdd && character.Status == StatusType.Offline)
{
characterManager.SignOff(name);
}
character.IsInteresting = characterManager.IsOfInterest(name);
if (!generateUpdate || !result) return;
var eventargs = new CharacterListChangedEventArgs
{
IsAdded = isAdd,
ListArgument = list
};
events.NewCharacterUpdate(character, eventargs);
});
}
public virtual bool Add(string name, ListKind listKind, bool isTemporary = false)
{
lock (Locker)
{
CollectionPair toModify;
return CollectionDictionary.TryGetValue(listKind, out toModify) && toModify.Add(name, isTemporary);
}
}
public virtual bool IsOnList(string name, ListKind listKind, bool onlineOnly = true)
{
lock (Locker)
{
if (listKind == ListKind.Online)
{
return(CharacterDictionary.ContainsKey(name));
}
CollectionPair list;
return(CollectionDictionary.TryGetValue(listKind, out list) && list.IsOnList(name, onlineOnly));
}
}
public ICollection <string> GetNames(ListKind listKind, bool onlineOnly = true)
{
lock (Locker)
{
CollectionPair list;
if (CollectionDictionary.TryGetValue(listKind, out list))
{
return(onlineOnly ? list.OnlineList : list.List);
}
return(null);
}
}
public static TriggerState GetTriggerState(
string expression, char typedChar, bool isCondition,
out int triggerLength, out ExpressionNode triggerExpression, out ListKind listKind,
out IReadOnlyList <ExpressionNode> comparandVariables)
{
comparandVariables = null;
if (isCondition)
{
listKind = ListKind.None;
return(GetConditionTriggerState(expression, typedChar, out triggerLength, out triggerExpression, out comparandVariables));
}
return(GetTriggerState(expression, typedChar, out triggerLength, out triggerExpression, out listKind));
}
void List1(ListKind kind)
{
++_list;
if (_list > 1)
{
Throw(ErrNestedList);
}
_listKind = kind;
_itemCount = 0;
_termCount = 0;
Writer.WriteLine();
}
// ========================================
// constructor
// ========================================
public SetStyledTextListKindCommand(
IEditor target,
Func <StyledText> styledTextProvider,
ListKind listKind,
bool on
)
{
_target = target;
_styledTextProvider = styledTextProvider;
_listKind = listKind;
_on = on;
_command = null;
}
public virtual bool Add(string name, ListKind listKind, bool isTemporary = false)
{
lock (Locker)
{
CollectionPair toModify;
var toReturn = CollectionDictionary.TryGetValue(listKind, out toModify) &&
toModify.Add(name, isTemporary);
if (toReturn && listKind != ListKind.Online && IsOnList(name, ListKind.Online))
toModify.SignOn(name);
return toReturn;
}
}
private void ToggleListBase(ListKind listKind)
{
if (_selection.IsEmpty)
{
var target = _target.GetBlockAt(_caretIndex) as Paragraph;
if (target != null)
{
if (target.ListKind == listKind)
{
/// listからnoneに戻す
_executor.Execute(new SetListKindOfParagraphCommand(target, ListKind.None));
}
else
{
/// listにする
_executor.Execute(new SetListKindOfParagraphCommand(target, listKind));
}
}
}
else
{
var targets = GetParagraphsInSelection();
/// すべてのParagraphがlistならlist解除，そうでなければすべてlistにする
var cmd = new CompositeCommand();
var cancel = !targets.Any(target => target.ListKind != listKind);
foreach (var target in targets)
{
if (cancel)
{
if (target.ListKind != ListKind.None)
{
cmd.Chain(new SetListKindOfParagraphCommand(target, ListKind.None));
}
}
else
{
if (target.ListKind != listKind)
{
cmd.Chain(new SetListKindOfParagraphCommand(target, listKind));
}
}
}
if (cmd.Children.Count > 0)
{
_executor.Execute(cmd);
}
}
}
public void OpenListWindow(ListKind listKind)
{
if (listKind == ListKind.Error)
{
GotoPad("MonoDevelop.Ide.Gui.Pads.ErrorListPad");
return;
}
if (listKind == ListKind.Location)
{
// This abstraction is not quite right as VSMac can have multiple search results pads open
GotoPad("SearchPad - Search Results - 0");
return;
}
}
public virtual bool Add(string name, ListKind listKind, bool isTemporary = false)
{
lock (Locker)
{
CollectionPair toModify;
var toReturn = CollectionDictionary.TryGetValue(listKind, out toModify) &&
toModify.Add(name, isTemporary);
if (toReturn && listKind != ListKind.Online && IsOnList(name, ListKind.Online))
{
toModify.SignOn(name);
}
return(toReturn);
}
}
public static TriggerState GetTriggerState(
string expression, TriggerReason reason, char typedChar, bool isCondition,
out int triggerLength, out ExpressionNode triggerExpression, out ListKind listKind,
out IReadOnlyList <ExpressionNode> comparandVariables)
{
comparandVariables = null;
var state = GetTriggerState(expression, reason, typedChar, isCondition, out triggerLength, out triggerExpression, out var triggerNode, out listKind);
if (state != TriggerState.None && isCondition)
{
comparandVariables = GetComparandVariables(triggerNode).ToList();
}
return(state);
}
/// <summary>Initializes a new instance of the <see cref="T:System.Object" /> class.</summary>
static ListKindSet()
{
Simple = new ListKind {
ListKindID = 1, Title = "Простой"
};
Marker = new ListKind {
ListKindID = 2, Title = "Маркер"
};
Numerable = new ListKind {
ListKindID = 3, Title = "Нумерованный"
};
Kinds = new List <ListKind>
{
Simple,
Marker,
Numerable
};
}
public virtual void Set(IEnumerable <string> names, ListKind listKind)
{
lock (Locker)
{
CollectionPair list;
if (!CollectionDictionary.TryGetValue(listKind, out list))
{
return;
}
var namesCollection = names as IList <string> ?? names.ToList();
list.Set(namesCollection);
if (CharacterCount > 0 && listKind != ListKind.Online)
{
namesCollection.Each(name => list.SignOn(name));
}
}
}
// ========================================
// constructor
// ========================================
public SetParagraphPropertiesCommand(
Paragraph target,
Insets padding,
int lineSpace,
HorizontalAlignment horizontalAlignment,
ParagraphKind paragraphKind,
ListKind listKind,
int indentLevel,
ListStateKind listState
)
{
_target = target;
_padding = padding;
_lineSpace = lineSpace;
_horizontalAlignment = horizontalAlignment;
_paragraphKind = paragraphKind;
_listKind = listKind;
_indentLevel = indentLevel;
_listState = listState;
}
public override bool Remove(string name, ListKind listKind, bool isTemporary = false)
{
var toReturn = base.Remove(name, listKind, isTemporary);
if (listKind == ListKind.Interested || listKind == ListKind.NotInterested)
{
SyncInterestedMarks(name, listKind, false, isTemporary);
}
if (listKind == ListKind.IgnoreUpdates)
{
UpdateIgnoreUpdatesMark(name, false);
}
if (!isTemporary)
{
TrySyncSavedLists(listKind);
}
return(toReturn);
}
//validates CommaValue and SemicolonValue, and collapses them to Value
public static bool ValidateListPermitted(ListKind listKind, MSBuildValueKind kind)
{
switch (listKind)
{
case ListKind.Comma:
if (kind.AllowCommaLists())
{
return(true);
}
return(false);
case ListKind.Semicolon:
if (kind.AllowLists())
{
return(true);
}
return(false);
default:
return(true);
}
}
// ========================================
// method
// ========================================
public override void Execute()
{
_oldPadding = _target.Padding;
_oldLineSpace = _target.LineSpace;
_oldHorizontalAlignment = _target.HorizontalAlignment;
_oldParagraphKind = _target.ParagraphKind;
_oldListKind = _target.ListKind;
_oldIndentLevel = _target.ListLevel;
_oldListState = _target.ListState;
if (_padding != _oldPadding)
{
_target.Padding = _padding;
}
if (_lineSpace != _oldLineSpace)
{
_target.LineSpace = _lineSpace;
}
if (_horizontalAlignment != _oldHorizontalAlignment)
{
_target.HorizontalAlignment = _horizontalAlignment;
}
if (_paragraphKind != _oldParagraphKind)
{
_target.ParagraphKind = _paragraphKind;
}
if (_listKind != _oldListKind)
{
_target.ListKind = _listKind;
}
if (_indentLevel != _oldIndentLevel)
{
_target.ListLevel = _indentLevel;
}
if (_listState != _oldListState)
{
_target.ListState = _listState;
}
}
private void SetListItemProps(Paragraph para, ListKind kind, int level)
{
var list = new SetListKindOfParagraphCommand(para, kind);
list.Execute();
if (para.ListLevel < level)
{
for (int i = para.ListLevel; i < level; ++i)
{
var indent = new IndentParagraphCommand(para);
indent.Execute();
}
}
else if (para.ListLevel > level)
{
for (int i = para.ListLevel; i > level; --i)
{
var outdent = new IndentParagraphCommand(para, -1);
outdent.Execute();
}
}
}
public async Task NavTo(string courseId, ListKind listKind = ListKind.Null, string itemId = null)
{
if (courseId != VM.CourseId)
{
VM.ChangeCourse(courseId);
if (listKind == ListKind.Null || listKind == ListKind.Notice)
{
listPivot.SelectedIndex = 0;
await VM.PrepareNoticeList();
}
else if (listKind == ListKind.File)
{
listPivot.SelectedIndex = 1;
await VM.PrepareFileList();
}
else
{
listPivot.SelectedIndex = 2;
await VM.PrepareWorkList();
}
HideDetailColumn();
}
}
private void TrySyncSavedLists(ListKind listKind, bool save = true)
{
IList <string> savedCollection;
if (!savedCollections.TryGetValue(listKind, out savedCollection))
{
return;
}
CollectionPair currentCollection;
if (!CollectionDictionary.TryGetValue(listKind, out currentCollection))
{
return;
}
savedCollection.Clear();
currentCollection.List.Each(savedCollection.Add);
if (save)
{
SettingsService.SaveApplicationSettingsToXml(currentCharacter);
}
}
public abstract IList<string> List(string path, bool recurse, ListKind kind);
public void Set(IEnumerable<string> names, ListKind listKind)
{
lock (Locker)
{
CollectionPair list;
if (CollectionDictionary.TryGetValue(listKind, out list))
list.Set(names);
}
}
private IEnumerable<ICharacter> GetList(ICharacterManager characters, ListKind listKind, bool onlineOnly = true)
=>
characters.GetCharacters(listKind, onlineOnly)
.Where(MeetsFilter)
.OrderBy(x => x.Name);
public ImportListStatement(uint start, uint end, ListKind kind, StatementNode[] elements, Token[] commas) : base(start, end)
{
Kind = kind;
Elements = elements;
Separators = commas;
}
public ListInfo(ListKind kind)
{
Kind = kind;
}
private void ShouldNotBeOnList(ListKind list, params ICharacter[] characters)
{
ShouldBe(list, false, true, characters);
}
static TriggerState GetTriggerState(
string expression, TriggerReason reason, char typedChar, bool isCondition,
out int triggerLength, out ExpressionNode triggerExpression, out ExpressionNode triggerNode, out ListKind listKind)
{
triggerLength = 0;
listKind = ListKind.None;
var isNewline = typedChar == '\n';
var isTypedChar = reason == TriggerReason.TypedChar;
if (isTypedChar && !isNewline && expression.Length > 0 && expression[expression.Length - 1] != typedChar)
{
triggerExpression = null;
triggerNode = null;
LoggingService.LogWarning($"Expression text '{expression}' is not consistent with typed character '{typedChar}'");
return(TriggerState.None);
}
if (expression.Length == 0)
{
//automatically trigger at the start of an expression regardless
triggerExpression = new ExpressionText(0, expression, true);
triggerNode = triggerExpression;
return(TriggerState.Value);
}
if (isCondition)
{
triggerExpression = ExpressionParser.ParseCondition(expression);
}
else
{
const ExpressionOptions options = ExpressionOptions.ItemsMetadataAndLists | ExpressionOptions.CommaLists;
triggerExpression = ExpressionParser.Parse(expression, options);
}
return(GetTriggerState(triggerExpression, reason, typedChar, out triggerLength, out triggerNode, out listKind));
}
private IEnumerable<ICharacter> GetChannelList(ListKind listKind, bool onlineOnly)
{
var channel = ChatModel.CurrentChannel as GeneralChannelModel;
if (HasUsers && channel != null)
return GetList(channel.CharacterManager, listKind, onlineOnly);
return new List<ICharacter>();
}
private void SyncInterestedMarks(string name, ListKind listKind, bool isAdd, bool isTemporary)
{
lock (Locker)
{
var isInteresting = listKind == ListKind.Interested;
var oppositeList = isInteresting ? notInterested : interested;
var sameList = isInteresting ? interested : notInterested;
Action<CollectionPair> addRemove = c =>
{
if (isAdd)
c.Add(name, isTemporary);
else
c.Remove(name, isTemporary);
};
if (isAdd) // if we're adding to one, then we have to remove from the other
oppositeList.Remove(name, isTemporary);
// now we do the actual action on the list specified
addRemove(sameList);
ICharacter toModify;
if (CharacterDictionary.TryGetValue(name, out toModify))
toModify.IsInteresting = isInteresting && isAdd;
}
}
private void TrySyncSavedLists(ListKind listKind)
{
IList<string> savedCollection;
if (!savedCollections.TryGetValue(listKind, out savedCollection)) return;
CollectionPair currentCollection;
if (!CollectionDictionary.TryGetValue(listKind, out currentCollection)) return;
savedCollection.Clear();
currentCollection.List.Each(savedCollection.Add);
SettingsService.SaveApplicationSettingsToXml(currentCharacter);
}
public override bool Remove(string name, ListKind listKind, bool isTemporary = false)
{
var toReturn = base.Remove(name, listKind, isTemporary);
if (listKind == ListKind.Interested || listKind == ListKind.NotInterested)
SyncInterestedMarks(name, listKind, false, isTemporary);
if (!isTemporary)
TrySyncSavedLists(listKind);
if (listKind == ListKind.IgnoreUpdates)
UpdateIgnoreUpdatesMark(name, false);
return toReturn;
}
public override bool IsOnList(string name, ListKind listKind, bool onlineOnly = true)
{
var toReturn = base.IsOnList(name, listKind, onlineOnly);
if (listKind == ListKind.Friend && !ApplicationSettings.FriendsAreAccountWide)
toReturn = localFriends.List.Contains(name);
return toReturn;
}
public override ICollection<ICharacter> GetCharacters(ListKind listKind, bool isOnlineOnly = true)
{
var characters = base.GetCharacters(listKind, isOnlineOnly);
if (listKind == ListKind.Friend && !ApplicationSettings.FriendsAreAccountWide)
characters = characters.Where(x => localFriends.List.Contains(x.Name)).ToList();
return characters;
}
public override void Set(IEnumerable<string> names, ListKind listKind)
{
base.Set(names, listKind);
if (savedCollections.Select(x => x.Key).Contains(listKind))
TrySyncSavedLists(listKind, false);
}
public IList<string> List(string path, bool recurse, ListKind kind)
{
return Client.List (path, recurse, kind);
}
FSharpOption <ListItem> IVimHost.NavigateToListItem(ListKind listKind, NavigationKind navigationKind, FSharpOption <int> argument, bool hasBang)
{
return(NavigateToListItemFunc(listKind, navigationKind, argument, hasBang));
}
void List1(ListKind kind)
{
++_list;
if (_list > 1)
Throw(ErrNestedList);
_listKind = kind;
_itemCount = 0;
_termCount = 0;
Writer.WriteLine();
}
private void ShouldBe(ListKind listKind, bool on, bool offlineOnly, params ICharacter[] characters)
{
if (on)
{
characters.Each(x => Assert.IsTrue(manager.IsOnList(x.Name, listKind, offlineOnly)));
return;
}
characters.Each(x => Assert.IsFalse(manager.IsOnList(x.Name, listKind, offlineOnly)));
}
void List2()
{
--_list;
_countParaInItem = 0;
_listKind = ListKind.None;
}
private void ShouldNotBeOnOfflineListOf(ListKind list, params ICharacter[] characters)
{
ShouldBe(list, false, false, characters);
}
public ICollection<string> GetNames(ListKind listKind, bool onlineOnly = true)
{
lock (Locker)
{
CollectionPair list;
if (CollectionDictionary.TryGetValue(listKind, out list))
return onlineOnly ? list.OnlineList : list.List;
return null;
}
}
static TriggerState GetTriggerState(string expression, char typedChar, out int triggerLength, out ExpressionNode triggerExpression, out ListKind listKind)
{
var isExplicit = typedChar == '\0';
var isNewline = typedChar == '\n';
triggerLength = 0;
listKind = ListKind.None;
if (!isExplicit && !isNewline && expression.Length > 0 && expression[expression.Length - 1] != typedChar)
{
triggerExpression = null;
LoggingService.LogWarning($"Expression text '{expression}' is not consistent with typed character '{typedChar}'");
return(TriggerState.None);
}
if (expression.Length == 0)
{
triggerExpression = new ExpressionText(0, expression, true);
}
else
{
const ExpressionOptions options = ExpressionOptions.ItemsMetadataAndLists | ExpressionOptions.CommaLists;
triggerExpression = ExpressionParser.Parse(expression, options);
}
if (triggerExpression is ListExpression el)
{
//the last list entry is the thing that triggered it
triggerExpression = el.Nodes.Last();
if (triggerExpression is ExpressionError e && e.Kind == ExpressionErrorKind.EmptyListEntry)
{
triggerLength = 0;
listKind = LastChar() == ',' ? ListKind.Comma : ListKind.Semicolon;
return(TriggerState.Value);
}
var separator = expression[triggerExpression.Offset - 1];
listKind = separator == ',' ? ListKind.Comma : ListKind.Semicolon;
}
if (triggerExpression is ExpressionText text)
{
var val = text.Value;
int leadingWhitespace = 0;
for (int i = 0; i < val.Length; i++)
{
if (char.IsWhiteSpace(val[i]))
{
leadingWhitespace++;
}
else
{
break;
}
}
var length = val.Length - leadingWhitespace;
if (length == 0)
{
triggerLength = 0;
return(isExplicit ? TriggerState.Value : TriggerState.None);
}
var firstChar = val[leadingWhitespace];
if (length == 1)
{
triggerLength = 1;
switch (firstChar)
{
case '$': return(TriggerState.PropertyOrValue);
case '@': return(TriggerState.ItemOrValue);
case '%': return(TriggerState.MetadataOrValue);
default:
if (char.IsLetterOrDigit(firstChar))
{
return(TriggerState.Value);
}
break;
}
}
else if (isExplicit && char.IsLetterOrDigit(firstChar))
{
triggerLength = length;
return(TriggerState.Value);
}
triggerLength = 0;
return(TriggerState.None);
}
//find the deepest node that touches the end
var lastNode = triggerExpression.Find(expression.Length);
if (lastNode == null)
{
return(TriggerState.None);
}
if (lastNode is ExpressionText lit)
{
if (LastChar() == '\\')
{
return(TriggerState.DirectorySeparator);
}
if (lit.Value.Length >= 2 && PenultimateChar() == '\\' && IsPossiblePathSegment(LastChar()))
{
triggerLength = 1;
return(TriggerState.DirectorySeparator);
}
}
//find the deepest error
var error = lastNode as ExpressionError;
ExpressionNode parent = lastNode.Parent;
while (parent != null && error == null)
{
error = parent as ExpressionError;
parent = parent.Parent;
}
if (error is IncompleteExpressionError iee && iee.WasEOF)
{
switch (lastNode)
{
case ExpressionItem i:
if (iee.Kind == ExpressionErrorKind.ExpectingMethodOrTransform)
{
return(TriggerState.ItemFunctionName);
}
break;
case ExpressionItemName ein:
if (iee.Kind == ExpressionErrorKind.ExpectingRightParenOrDash)
{
if (isExplicit || ein.Name.Length == 1)
{
triggerLength = ein.Name.Length;
return(TriggerState.ItemName);
}
return(TriggerState.None);
}
break;
case ExpressionPropertyName pn:
if (iee.Kind == ExpressionErrorKind.ExpectingRightParenOrPeriod)
{
if (isExplicit || pn.Name.Length == 1)
{
triggerLength = pn.Name.Length;
return(TriggerState.PropertyName);
}
return(TriggerState.None);
}
break;
case ExpressionFunctionName fn:
if (iee.Kind == ExpressionErrorKind.IncompleteProperty)
{
if (isExplicit || fn.Name.Length == 1)
{
triggerLength = fn.Name.Length;
return(TriggerState.PropertyFunctionName);
}
return(TriggerState.None);
}
if (iee.Kind == ExpressionErrorKind.ExpectingLeftParen)
{
if (isExplicit || fn.Name.Length == 1)
{
triggerLength = fn.Name.Length;
return(TriggerState.ItemFunctionName);
}
return(TriggerState.None);
}
break;
case ExpressionPropertyFunctionInvocation pfi:
if (iee.Kind == ExpressionErrorKind.ExpectingMethodName)
{
return(TriggerState.PropertyFunctionName);
}
if (iee.Kind == ExpressionErrorKind.ExpectingClassName)
{
return(TriggerState.PropertyFunctionClassName);
}
break;
case ExpressionClassReference cr:
if (iee.Kind == ExpressionErrorKind.ExpectingBracketColonColon ||
((iee.Kind == ExpressionErrorKind.ExpectingRightParenOrValue || iee.Kind == ExpressionErrorKind.ExpectingRightParenOrComma) && cr.Parent is ExpressionArgumentList)
)
{
if (isExplicit || cr.Name.Length == 1)
{
triggerLength = cr.Name.Length;
return(cr.Parent is ExpressionArgumentList? TriggerState.BareFunctionArgumentValue : TriggerState.PropertyFunctionClassName);
}
return(TriggerState.None);
}
break;
case ExpressionMetadata m:
if (iee.Kind == ExpressionErrorKind.ExpectingMetadataName)
{
return(TriggerState.MetadataName);
}
if (iee.Kind == ExpressionErrorKind.ExpectingRightParenOrPeriod)
{
if (m.ItemName.Length == 1 || isExplicit)
{
triggerLength = m.ItemName.Length;
return(TriggerState.MetadataOrItemName);
}
return(TriggerState.None);
}
if (iee.Kind == ExpressionErrorKind.ExpectingRightParen)
{
if (m.MetadataName.Length == 1 || isExplicit)
{
triggerLength = m.MetadataName.Length;
return(TriggerState.MetadataName);
}
return(TriggerState.None);
}
break;
case ExpressionText expressionText: {
if (
(error.Kind == ExpressionErrorKind.IncompleteString && (expressionText.Parent is ExpressionArgumentList || expressionText.Parent is ExpressionItemTransform)) ||
(error.Kind == ExpressionErrorKind.ExpectingRightParenOrValue && expressionText.Parent is ExpressionArgumentList)
)
{
return(GetTriggerState(expressionText.Value, typedChar, out triggerLength, out triggerExpression, out _));
}
}
break;
case ExpressionArgumentList argList: {
if (error.Kind == ExpressionErrorKind.ExpectingRightParenOrValue)
{
return(TriggerState.BareFunctionArgumentValue);
}
}
break;
}
}
if (error != null)
{
switch (error.Kind)
{
case ExpressionErrorKind.ExpectingPropertyName:
return(TriggerState.PropertyName);
case ExpressionErrorKind.ExpectingItemName:
return(TriggerState.ItemName);
case ExpressionErrorKind.ExpectingMetadataOrItemName:
return(TriggerState.MetadataOrItemName);
}
return(TriggerState.None);
}
return(TriggerState.None);
char LastChar() => expression[expression.Length - 1];
char PenultimateChar() => expression[expression.Length - 2];
bool IsPossiblePathSegment(char c) => c == '_' || char.IsLetterOrDigit(c) || c == '.';
}
public virtual void Set(IEnumerable<string> names, ListKind listKind)
{
lock (Locker)
{
CollectionPair list;
if (!CollectionDictionary.TryGetValue(listKind, out list)) return;
var namesCollection = names as IList<string> ?? names.ToList();
list.Set(namesCollection);
if (CharacterCount > 0 && listKind != ListKind.Online)
namesCollection.Each(name => list.SignOn(name));
}
}
static TriggerState GetTriggerState(
string expression, TriggerReason reason, char typedChar,
out int triggerLength, out ExpressionNode triggerExpression, out ListKind listKind)
{
triggerLength = 0;
listKind = ListKind.None;
var isExplicit = reason == TriggerReason.Invocation;
var isNewline = typedChar == '\n';
var isBackspace = reason == TriggerReason.Backspace;
var isTypedChar = reason == TriggerReason.TypedChar;
if (isTypedChar && !isNewline && expression.Length > 0 && expression[expression.Length - 1] != typedChar)
{
triggerExpression = null;
LoggingService.LogWarning($"Expression text '{expression}' is not consistent with typed character '{typedChar}'");
return(TriggerState.None);
}
if (expression.Length == 0)
{
//automatically trigger at the start of an expression regardless
triggerExpression = new ExpressionText(0, expression, true);
return(TriggerState.Value);
}
const ExpressionOptions options = ExpressionOptions.ItemsMetadataAndLists | ExpressionOptions.CommaLists;
triggerExpression = ExpressionParser.Parse(expression, options);
if (triggerExpression is ListExpression el)
{
//the last list entry is the thing that triggered it
triggerExpression = el.Nodes.Last();
if (triggerExpression is ExpressionError e && e.Kind == ExpressionErrorKind.EmptyListEntry)
{
triggerLength = 0;
listKind = LastChar() == ',' ? ListKind.Comma : ListKind.Semicolon;
return(TriggerState.Value);
}
var separator = expression[triggerExpression.Offset - 1];
listKind = separator == ',' ? ListKind.Comma : ListKind.Semicolon;
}
if (triggerExpression is ExpressionText text)
{
if (typedChar == '\\' || (!isTypedChar && LastChar() == '\\'))
{
triggerLength = 0;
return(TriggerState.DirectorySeparator);
}
var val = text.Value;
int leadingWhitespace = 0;
for (int i = 0; i < val.Length; i++)
{
if (char.IsWhiteSpace(val[i]))
{
leadingWhitespace++;
}
else
{
break;
}
}
var length = val.Length - leadingWhitespace;
if (length == 0)
{
triggerLength = 0;
return(isExplicit ? TriggerState.Value : TriggerState.None);
}
//auto trigger on first char
if (length == 1 && !isBackspace)
{
triggerLength = 1;
return(TriggerState.Value);
}
if (isExplicit)
{
var lastSlash = text.Value.LastIndexOf('\\');
if (lastSlash != -1)
{
triggerLength = text.Length - lastSlash - 1;
return(TriggerState.DirectorySeparator);
}
triggerLength = length;
return(TriggerState.Value);
}
triggerLength = 0;
return(TriggerState.None);
}
//find the deepest node that touches the end
var lastNode = triggerExpression.Find(expression.Length);
if (lastNode == null)
{
return(TriggerState.None);
}
if (lastNode is ExpressionText lit)
{
if (LastChar() == '\\')
{
return(TriggerState.DirectorySeparator);
}
//explicit trigger grabs back to last slash, if any
if (isExplicit)
{
var lastSlash = lit.Value.LastIndexOf('\\');
if (lastSlash != -1)
{
triggerLength = lit.Length - lastSlash - 1;
return(TriggerState.DirectorySeparator);
}
}
//eager trigger on first char after /
if (!isExplicit && PenultimateChar() == '\\' && IsPossiblePathSegmentStart(typedChar))
{
triggerLength = 1;
return(TriggerState.DirectorySeparator);
}
}
//find the deepest error
var error = lastNode as ExpressionError;
ExpressionNode parent = lastNode.Parent;
while (parent != null && error == null)
{
error = parent as ExpressionError;
parent = parent.Parent;
}
if (error is IncompleteExpressionError iee && iee.WasEOF)
{
switch (lastNode)
{
case ExpressionItem _:
if (iee.Kind == ExpressionErrorKind.ExpectingMethodOrTransform)
{
return(TriggerState.ItemFunctionName);
}
break;
case ExpressionItemName ein:
if (iee.Kind == ExpressionErrorKind.ExpectingRightParenOrDash)
{
if (ShouldTriggerName(ein.Name))
{
triggerLength = ein.Name.Length;
return(TriggerState.ItemName);
}
return(TriggerState.None);
}
break;
case ExpressionPropertyName pn:
if (iee.Kind == ExpressionErrorKind.ExpectingRightParenOrPeriod)
{
if (ShouldTriggerName(pn.Name))
{
triggerLength = pn.Name.Length;
return(TriggerState.PropertyName);
}
return(TriggerState.None);
}
break;
case ExpressionFunctionName fn:
if (iee.Kind == ExpressionErrorKind.IncompleteProperty)
{
if (ShouldTriggerName(fn.Name))
{
triggerLength = fn.Name.Length;
return(TriggerState.PropertyFunctionName);
}
return(TriggerState.None);
}
if (iee.Kind == ExpressionErrorKind.ExpectingLeftParen)
{
if (ShouldTriggerName(fn.Name))
{
triggerLength = fn.Name.Length;
return(TriggerState.ItemFunctionName);
}
return(TriggerState.None);
}
break;
case ExpressionPropertyFunctionInvocation _:
if (iee.Kind == ExpressionErrorKind.ExpectingMethodName)
{
return(TriggerState.PropertyFunctionName);
}
if (iee.Kind == ExpressionErrorKind.ExpectingClassName)
{
return(TriggerState.PropertyFunctionClassName);
}
break;
case ExpressionClassReference cr:
if (iee.Kind == ExpressionErrorKind.ExpectingBracketColonColon ||
((iee.Kind == ExpressionErrorKind.ExpectingRightParenOrValue || iee.Kind == ExpressionErrorKind.ExpectingRightParenOrComma) && cr.Parent is ExpressionArgumentList)
)
{
if (ShouldTriggerName(cr.Name))
{
triggerLength = cr.Name.Length;
return(cr.Parent is ExpressionArgumentList? TriggerState.BareFunctionArgumentValue : TriggerState.PropertyFunctionClassName);
}
return(TriggerState.None);
}
break;
case ExpressionMetadata m:
if (iee.Kind == ExpressionErrorKind.ExpectingMetadataName)
{
return(TriggerState.MetadataName);
}
if (iee.Kind == ExpressionErrorKind.ExpectingRightParenOrPeriod)
{
if (ShouldTriggerName(m.ItemName))
{
triggerLength = m.ItemName.Length;
return(TriggerState.MetadataOrItemName);
}
return(TriggerState.None);
}
if (iee.Kind == ExpressionErrorKind.ExpectingRightParen)
{
if (ShouldTriggerName(m.MetadataName))
{
triggerLength = m.MetadataName.Length;
return(TriggerState.MetadataName);
}
return(TriggerState.None);
}
break;
case ExpressionText expressionText: {
if (
(error.Kind == ExpressionErrorKind.IncompleteString && (expressionText.Parent is ExpressionArgumentList || expressionText.Parent is ExpressionItemTransform)) ||
(error.Kind == ExpressionErrorKind.ExpectingRightParenOrValue && expressionText.Parent is ExpressionArgumentList)
)
{
var s = GetTriggerState(
expressionText.Value, reason, typedChar,
out triggerLength, out triggerExpression, out _);
if (error.Kind != ExpressionErrorKind.IncompleteString && s == TriggerState.Value)
{
return(TriggerState.BareFunctionArgumentValue);
}
return(s);
}
}
break;
case ExpressionArgumentList _: {
if (error.Kind == ExpressionErrorKind.ExpectingRightParenOrValue)
{
return(TriggerState.BareFunctionArgumentValue);
}
}
break;
}
}
if (error != null)
{
switch (error.Kind)
{
case ExpressionErrorKind.ExpectingPropertyName:
return(TriggerState.PropertyName);
case ExpressionErrorKind.ExpectingItemName:
return(TriggerState.ItemName);
case ExpressionErrorKind.ExpectingMetadataOrItemName:
return(TriggerState.MetadataOrItemName);
}
return(TriggerState.None);
}
return(TriggerState.None);
char LastChar() => expression[expression.Length - 1];
char PenultimateChar() => expression[expression.Length - 2];
bool IsPossiblePathSegmentStart(char c) => c == '_' || char.IsLetterOrDigit(c) || c == '.';
bool ShouldTriggerName(string n) =>
isExplicit ||
(isTypedChar && n.Length == 1) ||
(isBackspace && n.Length == 0);
}
public void Set(JsonArray array, ListKind listKind)
{
var names = array.ConvertAll(x => x.ToString()).Where(x => !string.IsNullOrWhiteSpace(x));
Set(names, listKind);
}
public override System.Collections.Generic.IList<string> List(string path, bool recurse, ListKind kind)
{
List<string> found = new List<string>();
List<IntPtr> pylist = null;
string[] list = null;
string relpath = string.Empty;
StringBuilder command = new StringBuilder();
command.AppendFormat("tree,relpath = workingtree.WorkingTree.open_containing(path=ur\"{0}\")\n", NormalizePath(path));
command.AppendFormat("mylist = \"\"\ntree.lock_read()\n");
command.AppendFormat("try:\n for entry in tree.list_files():\n mylist = mylist+entry[0]+\"|\"+entry[2]+\"\\n\"\n");
command.AppendFormat("finally:\n tree.unlock()\n");
lock (lockme)
{
try
{
pylist = run(new List<string>{ "mylist", "relpath" }, command.ToString());
list = StringFromPython(pylist[0]).Split('\n');
relpath = StringFromPython(pylist[1]);
}
catch
{
return found;
}
}// lock
foreach (string line in list)
{
string[] tokens = line.Split('|');
if ((tokens[0].StartsWith(relpath, StringComparison.Ordinal)) &&
(ListKind.All == kind || listKinds[kind].Equals(tokens[1], StringComparison.Ordinal)) &&
(recurse || !tokens[0].Substring(relpath.Length).Contains("/")))
{
found.Add(tokens[0]);
}// if valid match
}
return found;
}
public virtual bool IsOnList(string name, ListKind listKind, bool onlineOnly = true)
{
lock (Locker)
{
if (listKind == ListKind.Online)
return CharacterDictionary.ContainsKey(name);
CollectionPair list;
return CollectionDictionary.TryGetValue(listKind, out list) && list.IsOnList(name, onlineOnly);
}
}
public abstract IList <string> List(string path, bool recurse, ListKind kind);
public virtual ICollection<ICharacter> GetCharacters(ListKind listKind, bool isOnlineOnly = true)
{
lock (Locker)
{
var names = GetNames(listKind, isOnlineOnly);
return names.Select(Find).ToList();
}
}
static TriggerState GetTriggerState(
ExpressionNode triggerExpression, TriggerReason reason, char typedChar,
out int triggerLength, out ExpressionNode triggerNode, out ListKind listKind)
{
triggerLength = 0;
listKind = ListKind.None;
var isExplicit = reason == TriggerReason.Invocation;
var isBackspace = reason == TriggerReason.Backspace;
var isTypedChar = reason == TriggerReason.TypedChar;
if (triggerExpression is ListExpression el)
{
//the last list entry is the thing that triggered it
triggerExpression = el.Nodes.Last();
listKind = el.Separator == ',' ? ListKind.Comma : ListKind.Semicolon;
if (triggerExpression is ExpressionError e && e.Kind == ExpressionErrorKind.EmptyListEntry)
{
triggerLength = 0;
triggerNode = triggerExpression;
return(TriggerState.Value);
}
}
if (triggerExpression is ExpressionText text)
{
//automatically trigger at the start of an expression regardless
if (text.Length == 0)
{
triggerNode = triggerExpression;
return(TriggerState.Value);
}
if (typedChar == '\\' || (!isTypedChar && text.Value[text.Length - 1] == '\\'))
{
triggerLength = 0;
triggerNode = triggerExpression;
return(TriggerState.DirectorySeparator);
}
var val = text.Value;
int leadingWhitespace = 0;
for (int i = 0; i < val.Length; i++)
{
if (char.IsWhiteSpace(val[i]))
{
leadingWhitespace++;
}
else
{
break;
}
}
var length = val.Length - leadingWhitespace;
if (length == 0)
{
triggerLength = 0;
triggerNode = triggerExpression;
return(isExplicit ? TriggerState.Value : TriggerState.None);
}
//auto trigger on first char
if (length == 1 && !isBackspace)
{
triggerLength = 1;
triggerNode = triggerExpression;
return(TriggerState.Value);
}
if (isExplicit)
{
var lastSlash = text.Value.LastIndexOf('\\');
if (lastSlash != -1)
{
triggerLength = text.Length - lastSlash - 1;
triggerNode = triggerExpression;
return(TriggerState.DirectorySeparator);
}
triggerLength = length;
triggerNode = triggerExpression;
return(TriggerState.Value);
}
triggerLength = 0;
triggerNode = null;
return(TriggerState.None);
}
//find the deepest node that touches the end
triggerNode = triggerExpression.Find(triggerExpression.End);
if (triggerNode == null)
{
return(TriggerState.None);
}
// if inside a quoted expression, scope down
if (triggerNode != triggerExpression)
{
ExpressionNode p = triggerNode.Parent;
while (p != null && p != triggerExpression)
{
if (p is QuotedExpression quotedExpr)
{
return(GetTriggerState(
quotedExpr.Expression, reason, typedChar,
out triggerLength, out triggerNode, out _));
}
p = p.Parent;
}
}
// path separator completion
if (triggerNode is ExpressionText lit)
{
if (lit.Length > 0 && lit.Value[lit.Length - 1] == '\\')
{
return(TriggerState.DirectorySeparator);
}
//explicit trigger grabs back to last slash, if any
if (isExplicit)
{
var lastSlash = lit.Value.LastIndexOf('\\');
if (lastSlash != -1)
{
triggerLength = lit.Length - lastSlash - 1;
return(TriggerState.DirectorySeparator);
}
}
//eager trigger on first char after /
if (!isExplicit && lit.Length > 1 && lit.Value[lit.Value.Length - 2] == '\\' && IsPossiblePathSegmentStart(typedChar))
{
triggerLength = 1;
return(TriggerState.DirectorySeparator);
}
}
//find the deepest error
var error = triggerNode as ExpressionError;
if (error == null)
{
ExpressionNode p = triggerNode.Parent;
while (p != null && error == null)
{
error = p as IncompleteExpressionError;
if (p == triggerExpression)
{
break;
}
p = p.Parent;
}
}
if (triggerNode == error && !(error is IncompleteExpressionError))
{
triggerNode = error.Parent;
}
if (error is ExpressionError ee && ee.WasEOF)
{
ExpressionNode parent = triggerNode.Parent is ExpressionError err ? err.Parent : triggerNode.Parent;
switch (triggerNode)
{
case ExpressionItem _:
if (ee.Kind == ExpressionErrorKind.ExpectingMethodOrTransform)
{
return(TriggerState.ItemFunctionName);
}
break;
case ExpressionItemName ein:
if (ee.Kind == ExpressionErrorKind.ExpectingRightParenOrDash)
{
if (ShouldTriggerName(ein.Name))
{
triggerLength = ein.Name.Length;
return(TriggerState.ItemName);
}
return(TriggerState.None);
}
break;
case ExpressionPropertyName pn:
if (ee.Kind == ExpressionErrorKind.ExpectingRightParenOrPeriod)
{
if (ShouldTriggerName(pn.Name))
{
triggerLength = pn.Name.Length;
return(TriggerState.PropertyName);
}
return(TriggerState.None);
}
break;
case ExpressionFunctionName fn:
if (ee.Kind == ExpressionErrorKind.IncompleteProperty)
{
if (ShouldTriggerName(fn.Name))
{
triggerLength = fn.Name.Length;
if (IsConditionFunctionError(ee))
{
return(TriggerState.ConditionFunctionName);
}
return(TriggerState.PropertyFunctionName);
}
return(TriggerState.None);
}
if (ee.Kind == ExpressionErrorKind.ExpectingLeftParen)
{
if (ShouldTriggerName(fn.Name))
{
triggerLength = fn.Name.Length;
if (IsConditionFunctionError(ee))
{
return(TriggerState.ConditionFunctionName);
}
return(TriggerState.ItemFunctionName);
}
return(TriggerState.None);
}
break;
case ExpressionPropertyFunctionInvocation _:
if (ee.Kind == ExpressionErrorKind.ExpectingMethodName)
{
return(TriggerState.PropertyFunctionName);
}
if (ee.Kind == ExpressionErrorKind.ExpectingClassName)
{
return(TriggerState.PropertyFunctionClassName);
}
break;
case ExpressionClassReference cr:
if (ee.Kind == ExpressionErrorKind.ExpectingBracketColonColon ||
((ee.Kind == ExpressionErrorKind.ExpectingRightParenOrValue || ee.Kind == ExpressionErrorKind.ExpectingRightParenOrComma) && parent is ExpressionArgumentList)
)
{
if (ShouldTriggerName(cr.Name))
{
triggerLength = cr.Name.Length;
return(parent is ExpressionArgumentList? TriggerState.BareFunctionArgumentValue : TriggerState.PropertyFunctionClassName);
}
return(TriggerState.None);
}
break;
case ExpressionMetadata m:
if (ee.Kind == ExpressionErrorKind.ExpectingMetadataName)
{
return(TriggerState.MetadataName);
}
if (ee.Kind == ExpressionErrorKind.ExpectingRightParenOrPeriod)
{
if (ShouldTriggerName(m.ItemName))
{
triggerLength = m.ItemName.Length;
return(TriggerState.MetadataOrItemName);
}
return(TriggerState.None);
}
if (ee.Kind == ExpressionErrorKind.ExpectingRightParen)
{
if (ShouldTriggerName(m.MetadataName))
{
triggerLength = m.MetadataName.Length;
return(TriggerState.MetadataName);
}
return(TriggerState.None);
}
break;
case ExpressionText expressionText: {
if (
(error.Kind == ExpressionErrorKind.IncompleteString &&
(parent is ExpressionArgumentList || parent is ExpressionItemTransform || parent is ExpressionConditionOperator || parent is QuotedExpression)) ||
(error.Kind == ExpressionErrorKind.ExpectingRightParenOrValue && parent is ExpressionArgumentList)
)
{
var s = GetTriggerState(
expressionText.Value, reason, typedChar, false,
out triggerLength, out triggerExpression, out triggerNode, out _);
if (error.Kind != ExpressionErrorKind.IncompleteString && s == TriggerState.Value)
{
return(TriggerState.BareFunctionArgumentValue);
}
return(s);
}
}
break;
case ExpressionArgumentList _: {
if (error.Kind == ExpressionErrorKind.ExpectingRightParenOrValue)
{
return(TriggerState.BareFunctionArgumentValue);
}
}
break;
}
}
if (error != null)
{
switch (error.Kind)
{
case ExpressionErrorKind.ExpectingPropertyName:
return(TriggerState.PropertyName);
case ExpressionErrorKind.ExpectingItemName:
return(TriggerState.ItemName);
case ExpressionErrorKind.ExpectingMetadataOrItemName:
return(TriggerState.MetadataOrItemName);
case ExpressionErrorKind.ExpectingClassName:
return(TriggerState.PropertyFunctionClassName);
}
return(TriggerState.None);
}
return(TriggerState.None);
bool IsPossiblePathSegmentStart(char c) => c == '_' || char.IsLetterOrDigit(c) || c == '.';
bool ShouldTriggerName(string n) =>
isExplicit ||
(isTypedChar && n.Length == 1) ||
(isBackspace && n.Length == 0);
bool IsConditionFunctionError(ExpressionError ee)
=> ee.Parent is ExpressionConditionOperator ||
ee is IncompleteExpressionError iee && iee.IncompleteNode is ExpressionConditionFunction;
}
private IEnumerable<ICharacter> GetGlobalList(ListKind listkind)
=> GetList(CharacterManager, listkind, !showOffline);
public abstract void OpenListWindow(ListKind listKind);
void IVimHost.OpenListWindow(ListKind listKind)
{
OpenListWindowFunc(listKind);
}
async Task <CompletionContext> GetExpressionCompletionsAsync(
IAsyncCompletionSession session,
ValueInfo info, TriggerState triggerState, ListKind listKind,
int triggerLength, ExpressionNode triggerExpression,
IReadOnlyList <ExpressionNode> comparandVariables,
MSBuildResolveResult rr, SnapshotPoint triggerLocation,
MSBuildRootDocument doc, CancellationToken token)
{
var kind = info.InferValueKindIfUnknown();
if (!ValidateListPermitted(listKind, kind))
{
return(CompletionContext.Empty);
}
bool allowExpressions = kind.AllowExpressions();
kind = kind.GetScalarType();
if (kind == MSBuildValueKind.Data || kind == MSBuildValueKind.Nothing)
{
return(CompletionContext.Empty);
}
bool isValue = triggerState == TriggerState.Value;
var items = new List <CompletionItem> ();
if (comparandVariables != null && isValue)
{
foreach (var ci in ExpressionCompletion.GetComparandCompletions(doc, comparandVariables))
{
items.Add(CreateCompletionItem(ci, XmlCompletionItemKind.AttributeValue));
}
}
if (isValue)
{
switch (kind)
{
case MSBuildValueKind.NuGetID:
if (triggerExpression is ExpressionText t)
{
var packageNameItems = await GetPackageNameCompletions(session, doc, t.Value, token);
if (packageNameItems != null)
{
items.AddRange(packageNameItems);
}
}
break;
case MSBuildValueKind.NuGetVersion: {
var packageVersionItems = await GetPackageVersionCompletions(doc, rr, token);
if (packageVersionItems != null)
{
items.AddRange(packageVersionItems);
}
break;
}
case MSBuildValueKind.Sdk:
case MSBuildValueKind.SdkWithVersion: {
var sdkItems = await GetSdkCompletions(doc, token);
if (sdkItems != null)
{
items.AddRange(sdkItems);
}
break;
}
case MSBuildValueKind.Guid:
items.Add(CreateSpecialItem("New GUID", "Inserts a new GUID", KnownImages.Add, MSBuildSpecialCommitKind.NewGuid));
break;
case MSBuildValueKind.Lcid:
items.AddRange(GetLcidCompletions());
break;
}
}
//TODO: better metadata support
IEnumerable <BaseInfo> cinfos;
if (info.CustomType != null && info.CustomType.Values.Count > 0 && isValue)
{
cinfos = info.CustomType.Values;
}
else
{
//FIXME: can we avoid awaiting this unless we actually need to resolve a function? need to propagate async downwards
await provider.FunctionTypeProvider.EnsureInitialized(token);
cinfos = ExpressionCompletion.GetCompletionInfos(rr, triggerState, kind, triggerExpression, triggerLength, doc, provider.FunctionTypeProvider);
}
if (cinfos != null)
{
foreach (var ci in cinfos)
{
items.Add(CreateCompletionItem(ci, XmlCompletionItemKind.AttributeValue));
}
}
if ((allowExpressions && isValue) || triggerState == TriggerState.BareFunctionArgumentValue)
{
items.Add(CreateSpecialItem("$(", "Property reference", KnownImages.MSBuildProperty, MSBuildSpecialCommitKind.PropertyReference));
}
if (allowExpressions && isValue)
{
items.Add(CreateSpecialItem("@(", "Item reference", KnownImages.MSBuildItem, MSBuildSpecialCommitKind.ItemReference));
if (IsMetadataAllowed(triggerExpression, rr))
{
items.Add(CreateSpecialItem("%(", "Metadata reference", KnownImages.MSBuildItem, MSBuildSpecialCommitKind.MetadataReference));
}
}
if (items.Count > 0)
{
return(CreateCompletionContext(items));
}
return(CompletionContext.Empty);
}
public abstract FSharpOption <ListItem> NavigateToListItem(ListKind listKind, NavigationKind navigationKind, FSharpOption <int> argument, bool hasBang);
