private void UpdateSuggestions(string words)
        {
            if (string.IsNullOrWhiteSpace(words))
            {
                Suggestions?.Clear();
                return;
            }

            string[] enteredWordList = words.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            var      lastWorld       = enteredWordList.LastOrDefault().Replace("\t", "");

            if (lastWorld.Length < 1)
            {
                Suggestions.Clear();
                return;
            }

            var suggestedWords = EnglishWords.Where(w => w.StartsWith(lastWorld)).Except(enteredWordList).Take(7);

            Suggestions.Clear();
            foreach (var suggestion in suggestedWords)
            {
                Suggestions.Add(new SuggestionViewModel(suggestion, OnAddWord));
            }
        }
        private void OnSearchTextChangerd()
        {
            if (string.IsNullOrEmpty(Search))
            {
                if (Suggestions != null && Suggestions.Count > 0)
                {
                    Suggestions.Clear();
                }

                _messagingService.Send <HideUnhideViewAnimationMessage>(new HideUnhideViewAnimationMessage(true));
                return;
            }

            if (Search.Length < 3)
            {
                if (Suggestions != null && Suggestions.Count > 0)
                {
                    Suggestions.Clear();
                }

                HasAnySuggestions = false;
                return;
            }

            // Add API Stuff here.
            Suggestions = new ObservableCollection <Suggestion>()
            {
                new Suggestion()
                {
                    Content = "French Cuisine Restaurants", TapCommand = SuggestionTapCommand, RemoveCommand = SuggestionRemoveCommand
                }
            };

            HasAnySuggestions = Suggestions.Count > 0;
        }
示例#3
0
        async Task AzureSuggestions(string text)
        {
            Suggestions.Clear();

            var parameters = new SuggestParameters()
            {
                UseFuzzyMatching = true,
                HighlightPreTag  = "[",
                HighlightPostTag = "]",
                MinimumCoverage  = 100,
                Top = 10
            };

            var suggestionResults = await indexClient.Documents.SuggestAsync <Monkey>(text, "nameSuggester", parameters);

            foreach (var result in suggestionResults.Results)
            {
                Suggestions.Add(new Monkey
                {
                    Name     = result.Text,
                    Location = result.Document.Location,
                    Details  = result.Document.Details,
                    ImageUrl = result.Document.ImageUrl
                });
            }
        }
示例#4
0
        private void UpdateAutocomplete()
        {
            // There's an strange reason which causes TextChanged to fire indefinitely, although the text has not changed really.
            // To avoid this, if the text we stored is the same, just return.
            if (_text == _textbox.Text)
            {
                return;
            }

            _text = _textbox.Text;

            if (ShouldStopAutocompleting())
            {
                IsAutocompleting = false;
                return;
            }

            written = GetTextWrittenByUser();

            Suggestions.Clear();

            foreach (var user in _provider.Usernames
                     .Where(x => x.IndexOf(written, StringComparison.InvariantCultureIgnoreCase) != -1)
                     .Take(20)
                     .OrderBy(x => x))
            {
                Suggestions.Add(user);
            }
        }
示例#5
0
 private void ClearCurrentQuery()
 {
     Query = string.Empty;
     SortBy.Clear();
     SpatialQuery.Clear();
     ClearQueryError();
     Suggestions.Clear();
     CollectionSource.Clear();
 }
示例#6
0
        private void OnTextChanged()
        {
            Suggestions.Clear();
            var text = Text.Trim();

            Suggestions.AddRange(
                allCountries
                .Where(c => c.Name.ContainsIgnoringCase(text))
                .Select(c => new SelectableCountryViewModel(c, c.Id == selectedCountryId))
                );
        }
        public async Task SelectSuggestionAsync(SearchSuggestion suggestion)
        {
            // TODO FAZER A BUSCA BASEADO NO ITEM SELECIONADO
            System.Diagnostics.Debug.WriteLine($"Item selecionado na viewmodel: {suggestion.Description}");
            Suggestions.Clear();

            var resultsApi = await _api.GetSearchResults();

            Results.Clear();
            Results.AddRange(resultsApi.ToSearchResultListApp());
        }
示例#8
0
 public void LocationAutoSuggestTextChanged()
 {
     if (this._autoSuggestionBoxText.Length > 1)
     {
         this.GetSuggestionsAsync(this._autoSuggestionBoxText);
     }
     else
     {
         Suggestions.Clear();
         Suggestions.Add("No suggestions...");
     }
 }
        private void OnSuggestionTapped(Suggestion suggestion)
        {
            Search = suggestion.Content;

            if (Suggestions != null && Suggestions.Count > 0)
            {
                Suggestions.Clear();
            }

            HasAnySuggestions = false;
            SearchRestaurantAsync();
        }
示例#10
0
        private void CompleteEnding(TagViewModel tag)
        {
            Suggestions.Clear();
            RefreshPopup();
            tag.SetSignalization();

            if (tag.Blank is Word)
            {
                var w = tag.Blank as Word;
                CreatedWordsManager.AfterCompleteTagWith(w);
            }

            AddLastTag();
        }
示例#11
0
        private void GetSuggestionsAsync(string text)
        {
            Task t = Task.Run(async() =>
            {
                locs = await HttpServiceSingleton.GetInstance.GetLocationAsync($"https://api.mapbox.com/geocoding/v5/mapbox.places/{text}.json?access_token=pk.eyJ1IjoiZGlldGVyZHMiLCJhIjoiY2tpMGRlMTVmMDBvMjMwa2JveWYwY3k3eSJ9.I9Y9bm0oMnQJyshyZTKMdQ&autocomplete=true&limit=5");
            });

            t.Wait();
            Suggestions.Clear();
            foreach (var item in locs)
            {
                Suggestions.Add(item.LocationNameLong);
            }
        }
        private void onSuggestions(IEnumerable <AutocompleteSuggestion> suggestions)
        {
            var firstSuggestion = suggestions.FirstOrDefault();

            IsSuggestingTags     = firstSuggestion is TagSuggestion;
            IsSuggestingProjects = firstSuggestion is ProjectSuggestion;

            Suggestions.Clear();

            var groupedSuggestions = groupSuggestions(suggestions).ToList();

            UseGrouping = groupedSuggestions.Count > 1;
            Suggestions.AddRange(groupedSuggestions);
        }
示例#13
0
        private void AdjustTextToEndOfScopeToTheLeft(Scope newScope)
        {
            bool textChanged = false;

            while (newScope.EndPosInRootScope >= StartPosInRootScope)
            {
                textChanged = true;
                Text        = Text.Substring(1);
                startPosInRootScope++;
            }
            if (textChanged)
            {
                Suggestions.Clear();
            }
        }
        private void fetchSuggestions(bool databaseIsEmpty)
        {
            Suggestions.Clear();

            if (databaseIsEmpty)
            {
                return;
            }

            suggestionProviders
            .Providers
            .Select(provider => provider.GetSuggestions())
            .Aggregate(Observable.Merge)
            .Subscribe(addSuggestion);
        }
 public SearchQueryViewModel(MessageBus messageBus)
 {
     MessageBus = messageBus ?? throw new ArgumentNullException("messageBus");
     MessageBus.Subscribe <ServerSettingsChangedMessage>(m =>
     {
         if (m.ServiceModel == null)
         {
             QueryText     = "";
             StatusMessage = "";
         }
     });
     MessageBus.Subscribe <BuildSearchMessage>(m =>
     {
         m.Query.QueryText = QueryText;
     });
     MessageBus.Subscribe <BeginSearchMessage>(m =>
     {
         if (m.ReturnOptions.HasFlag(ReturnOptions.Results) && !m.IsPaging)
         {
             StatusMessage = "Searching...";
             IsSearching   = true;
         }
         if (m.ReturnOptions.HasFlag(ReturnOptions.Suggest))
         {
             Suggestions.Clear();
         }
     });
     MessageBus.Subscribe <EndSearchMessage>(m =>
     {
         if (m.Results.ReturnOptions.HasFlag(ReturnOptions.Results) && !m.IsPaging)
         {
             StatusMessage = $"Matched {m.Results.Total,1:n0} documents and {m.Results.TotalObjects,1:n0} distinct objects.";
             IsSearching   = false;
         }
         if (m.Results.ReturnOptions.HasFlag(ReturnOptions.Suggest))
         {
             foreach (var suggestion in m.Results.QuerySuggestions)
             {
                 Suggestions.Add(suggestion);
             }
         }
     });
     MessageBus.Subscribe <SearchAbortedMessage>(m =>
     {
         IsSearching   = false;
         StatusMessage = "Search aborted.";
     });
 }
示例#16
0
 private void AutoSuggestBoxTo_TextChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args)
 {
     if (args.Reason == AutoSuggestionBoxTextChangeReason.UserInput)
     {
         var suggestions = new ObservableCollection <string>(Suggestions.ToList());
         Suggestions.Clear();
         foreach (var place in suggestions)
         {
             if (place.Contains(sender.Text))
             {
                 Suggestions.Add(place);
             }
         }
         sender.ItemsSource = Suggestions;
     }
 }
        public void OnAddWord(string word)
        {
            string[] words = MnemonicWords.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (words.Length == 0)
            {
                MnemonicWords = word + " ";
            }
            else
            {
                words[words.Length - 1] = word;
                MnemonicWords           = string.Join(' ', words) + " ";
            }

            CaretIndex = MnemonicWords.Length;

            Suggestions.Clear();
        }
示例#18
0
        public async Task GetPlacesByName(string placeText)
        {
            var places = await _googleMapsApi.GetPlaces(placeText);

            var placeResult = places?.AutoCompletePlaces;

            if (placeResult != null && placeResult.Count > 0)
            {
                Places = new ObservableCollection <GooglePlaceAutoCompletePrediction>(placeResult);
            }

            Suggestions?.Clear();
            foreach (var place in Places)
            {
                Suggestions?.Add($"{place.StructuredFormatting.MainText} - {place.StructuredFormatting.SecondaryText}");
            }
        }
示例#19
0
        private void SearchForPatientCandidates(string inputText)
        {
            Suggestions.Clear();
            var candidates = _summaries.Select(s => new
            {
                s,
                IdDistance       = Levenshtein.ComputeDistance(s.Id.ToUpper(), inputText.ToUpper()),
                LastNameDistance = Levenshtein.ComputeDistance(s.LastName.ToUpper(), inputText.ToUpper()),
                FullNameDistance = Levenshtein.ComputeDistance($"{s.LastName.ToUpper()}, {s.FirstName.ToUpper()}", inputText.ToUpper()),
            })
                             .Select(s => new { s.s, Distance = Math.Min(Math.Min(s.IdDistance, s.FullNameDistance), s.LastNameDistance) })
                             .OrderBy(s => s.Distance)
                             .Where(s => s.Distance < 5)
                             .OrderBy(s => s.Distance)
                             .Take(5).ToList();

            candidates.ForEach(c => Suggestions.Add(c.s));
        }
示例#20
0
        private void AdjustTextToEndOfScopeToTheRight(Scope newScope)
        {
            bool textChanged = false;

            while (newScope.StartPosInRootScope <= EndPosInRootScope)
            {
                textChanged = true;

                Text = Text.Substring(0, Text.Length - 1);
                if (textChanged)
                {
                    Suggestions.Clear();
                }
            }
            if (textChanged)
            {
                Suggestions.Clear();
            }
        }
示例#21
0
        private void onSuggestions(IEnumerable <AutocompleteSuggestion> suggestions)
        {
            var firstQuerySymbolIndex = TextFieldInfo.Text.IndexOfAny(new char[] { QuerySymbols.Tags, QuerySymbols.Projects });

            if (firstQuerySymbolIndex >= 0)
            {
                var firstQuerySymbol = TextFieldInfo.Text[firstQuerySymbolIndex];
                IsSuggestingTags     = firstQuerySymbol == QuerySymbols.Tags;
                IsSuggestingProjects = !TextFieldInfo.ProjectId.HasValue && firstQuerySymbol == QuerySymbols.Projects;
            }
            else
            {
                IsSuggestingTags = IsSuggestingProjects = false;
            }

            Suggestions.Clear();

            var groupedSuggestions = groupSuggestions(suggestions).ToList();

            UseGrouping = groupedSuggestions.Count > 1;
            Suggestions.AddRange(groupedSuggestions);
        }
示例#22
0
        private object MakeSuggestions(TagViewModel tag)
        {
            Contract.Requires(tag != null);

            var tagIndex = Tags.IndexOf(tag);

            // все сущности кроме сущности редактируемого тега
            var tagBlanksExceptEditing = Tags.Select((t, i) => i != tagIndex ? t.Blank : null);

            var results = sugMaker.SearchForSuggesstions(
                query: tag.Query,
                prevEntityBlank: tagIndex > 0 ? Tags[tagIndex - 1].Blank : null,
                exclude: null);

            Suggestions.Clear();
            foreach (var item in results)
            {
                Suggestions.Add(new SuggestionViewModel(item, ShowAltSuggestion, item.IsTransient));
            }

            SelectedSuggestion = Suggestions.FirstOrDefault();
            return(Suggestions.FirstOrDefault());
        }
        private void UpdateSuggestions()
        {
            if (_selectedSuggestionChanged)
            {
                return;
            }

            Suggestions.Clear();

            if (QueueManagerProvided || QueueManager != null)
            {
                App.ShellService.WithGlobalBusy(() =>
                {
                    try
                    {
                        var filter    = QueueManager.NewObjectNameFilter(QueueName);
                        var provider  = QueueManager.NewObjectProvider(filter);
                        var sysFilter = QueueManager.NewSystemObjectNameFilter();
                        var list      = provider.GetQueueNames();
                        foreach (var s in list)
                        {
                            if (!IncludeSystemQueues && sysFilter.IsMatch(s))
                            {
                                continue;
                            }

                            Suggestions.Add(s);
                        }
                    }
                    catch (MqException)
                    { }
                });
            }

            CommandManager.InvalidateRequerySuggested();
        }
        void SetSuggestions()
        {
            if (!IsDropDownOpen)
            {
                return;
            }

            Suggestions.Clear();

            var find   = SelectedText == Text ? "" : SelectedText.CoalesceNullOrEmpty(Text) ?? "";
            var ucFind = Regex.Replace(find, "[^A-Z]", "");

            foreach (var suggestion in SuggestionList.Where(x => HasStr(x.Text, find)))
            {
                Suggestions.Add(suggestion);
            }

            if (!Suggestions.Any())
            {
                Suggestions.Add(null);
            }

            SuggestedIndex = find == "" ? 0 : Suggestions.Indexes(str => str?.Text.StartsWith(Text, StringComparison.InvariantCultureIgnoreCase) ?? false).FirstOrDefault();
        }
示例#25
0
        /// <summary>
        ///     Populates the <see cref="Suggestions"/> property with word suggestions
        ///     for the <see cref="CurrentWord"/>
        /// </summary>
        /// <remarks>
        ///     <see cref="TestWord()"/> or <see cref="TestWord(string)"/> must have been called before calling this method
        /// </remarks>
        /// <seealso cref="CurrentWord"/>
        /// <seealso cref="Suggestions"/>
        /// <seealso cref="TestWord()"/>
        /// <seealso cref="TestWord(string)"/>
        public void Suggest()
        {
            // can't generate suggestions with out current word
            if (CurrentWord.Length == 0)
            {
                TraceWriter.TraceWarning("No current word");
                return;
            }

            Initialize();

            var tempSuggestion = new List <Word>();

            if ((SuggestionMode == SuggestionEnum.PhoneticNearMiss ||
                 SuggestionMode == SuggestionEnum.Phonetic) &&
                _dictionary.PhoneticRules.Count > 0)
            {
                // generate phonetic code for possible root word
                Dictionary <string, string> codes = new Dictionary <string, string>();
                foreach (string tempWord in _dictionary.PossibleBaseWords)
                {
                    string tempCode = _dictionary.PhoneticCode(tempWord);
                    if (tempCode.Length > 0 && !codes.ContainsKey(tempCode))
                    {
                        codes.Add(tempCode, tempCode);
                    }
                }

                if (codes.Count > 0)
                {
                    // search root words for phonetic codes
                    foreach (Word word in _dictionary.BaseWords.Values)
                    {
                        if (codes.ContainsKey(word.PhoneticCode))
                        {
                            List <string> words = _dictionary.ExpandWord(word);

                            // add expanded words
                            foreach (string expandedWord in words)
                            {
                                SuggestWord(expandedWord, tempSuggestion);
                            }
                        }
                    }
                }

                TraceWriter.TraceVerbose("Suggestions Found with Phonetic Strategy: {0}", tempSuggestion.Count);
            }

            if (SuggestionMode == SuggestionEnum.PhoneticNearMiss ||
                SuggestionMode == SuggestionEnum.NearMiss)
            {
                // suggestions for a typical fault of spelling, that
                // differs with more, than 1 letter from the right form.
                ReplaceChars(tempSuggestion);

                // swap out each char one by one and try all the tryme
                // chars in its place to see if that makes a good word
                BadChar(tempSuggestion);

                // try omitting one char of word at a time
                ExtraChar(tempSuggestion);

                // try inserting a tryme character before every letter
                ForgotChar(tempSuggestion);

                // split the string into two pieces after every char
                // if both pieces are good words make them a suggestion
                TwoWords(tempSuggestion);

                // try swapping adjacent chars one by one
                SwapChar(tempSuggestion);
            }

            TraceWriter.TraceVerbose("Total Suggestions Found: {0}", tempSuggestion.Count);

            tempSuggestion.Sort();  // sorts by edit score
            Suggestions.Clear();

            foreach (var suggestion in tempSuggestion)
            {
                string word = suggestion.Text;

                // looking for duplicates
                if (!Suggestions.Contains(word))
                {
                    // populating the suggestion list
                    Suggestions.Add(word);
                }

                if (Suggestions.Count >= MaxSuggestions && MaxSuggestions > 0)
                {
                    break;
                }
            }
        }
示例#26
0
 /// <summary>
 ///     Resets the public properties
 /// </summary>
 private void Reset()
 {
     WordIndex        = 0; // reset word index
     _replacementWord = "";
     Suggestions.Clear();
 }
示例#27
0
        /// <summary>
        /// Создает тег.
        /// </summary>
        private TagViewModel CreateTag(object content = null)
        {
            Contract.Requires(content == null || content is string || content is ConfWithHio || content is IHrItemObject);

            TagViewModel tag;
            var          itemObject = content as IHrItemObject;
            var          chio       = content as ConfWithHio;
            var          str        = content as string;

            if (itemObject != null)
            {
                tag = new TagViewModel(this, itemObject);
            }
            else if (chio != null)
            {
                tag            = new TagViewModel(this, chio.HIO);
                tag.Confidence = chio.Confidence;
            }
            else if (str != null)
            {
                tag = new TagViewModel(this, str);
            }
            else
            {
                tag = new TagViewModel(this);
            }

            tag.Deleted += (s, e) =>
            {
                Contract.Requires(!tag.IsLast);
                tagsWritable.Remove(tag);
                StartEdit(LastTag);
            };
            tag.Converting      += CompleteOnConvert;
            tag.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == "Query")
                {
                    if (EditingTag == null) // non user change
                    {
                        return;
                    }
                    MakeSuggestions(EditingTag);
                    RefreshPopup();
                    OnPropertyChanged(() => IsEmpty);
                }
                else if (e.PropertyName == "IsTextBoxFocused")
                {
                    if (tag.IsTextBoxFocused)
                    {
                        if (tag.Signalization == null || tag.Signalization == Signalizations.None)
                        {
                            Suggestions.Clear();
                        }
                        else
                        {
                            MakeSuggestions(SelectedTag); // предположения для тегов с сигнализацией
                        }

                        CanCompleteOnLostFocus = true;

                        SelectedTags.Except(tag.ToEnumerable()).ForAll(t => t.IsSelected = false);
                        SelectedTag = tag;
                    }
                    else
                    {
                        // выход из редактирования
                        Suggestions.Clear();

                        // потерялся фокус после перехода не в предположения → завершение введенного текста
                        if (CanCompleteOnLostFocus)
                        {
                            CompleteOnLostFocus(tag);
                        }
                    }

                    RefreshPopup();
                }
                else if (e.PropertyName == "State")
                {
                    if (tag.State == State.Completed)
                    {
                        OnTagCompleted(tag);
                        OnEntitiesChanged();
                    }
                }
            };
            return(tag);
        }
 private void ShowSuggestions(IList <SearchSuggestion> suggestions)
 {
     Suggestions.Clear();
     Suggestions.AddRange(suggestions);
 }