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);