/// <summary>
        /// Initiate a search and return all search items matching the search context. Other items can be found later using the asynchronous searches.
        /// </summary>
        /// <param name="context">The current search context</param>
        /// <returns>A list of search items matching the search query.</returns>
        public static List <SearchItem> GetItems(SearchContext context, SearchFlags options = SearchFlags.Default)
        {
            // Stop all search sessions every time there is a new search.
            context.sessions.StopAllAsyncSearchSessions();

            if (context.actionId == null && string.IsNullOrEmpty(context.searchText) && !context.wantsMore)
            {
                return(new List <SearchItem>(0));
            }

            var allItems = new List <SearchItem>(3);

            #if QUICKSEARCH_DEBUG
            var debugProviderList = context.providers.ToList();
            using (new DebugTimer($"Search get items {String.Join(", ", debugProviderList.Select(p=>p.name.id))} -> {context.searchQuery}"));
            #endif
            foreach (var provider in context.providers)
            {
                using (var fetchTimer = new DebugTimer(null))
                {
                    try
                    {
                        var iterator = provider.fetchItems(context, allItems, provider);
                        if (iterator != null)
                        {
                            if (options.HasFlag(SearchFlags.Synchronous))
                            {
                                var stackedEnumerator = new StackedEnumerator <SearchItem>(iterator);
                                while (stackedEnumerator.MoveNext())
                                {
                                    if (stackedEnumerator.Current != null)
                                    {
                                        allItems.Add(stackedEnumerator.Current);
                                    }
                                }
                            }
                            else
                            {
                                var session = context.sessions.GetProviderSession(provider.name.id);
                                session.Reset(iterator, k_MaxFetchTimeMs);
                                if (!session.FetchSome(allItems, k_MaxFetchTimeMs))
                                {
                                    session.Stop();
                                }
                            }
                        }
                        provider.RecordFetchTime(fetchTimer.timeMs);
                    }
                    catch (Exception ex)
                    {
                        UnityEngine.Debug.LogException(new Exception($"Failed to get fetch {provider.name.displayName} provider items.", ex));
                    }
                }
            }

            if (!options.HasFlag(SearchFlags.Sorted))
            {
                return(allItems);
            }

            allItems.Sort(SortItemComparer);
            return(allItems.GroupBy(i => i.id).Select(i => i.First()).ToList());
        }
Beispiel #2
0
        private void DrawItems(SearchContext context)
        {
            UpdateScrollAreaOffset();

            context.totalItemCount = m_FilteredItems.Count;

            using (var scrollViewScope = new EditorGUILayout.ScrollViewScope(m_ScrollPosition))
            {
                m_ScrollPosition = scrollViewScope.scrollPosition;

                var itemCount        = m_FilteredItems.Count;
                var availableHeight  = position.height - m_ScrollViewOffset.yMax;
                var itemSkipCount    = Math.Max(0, (int)(m_ScrollPosition.y / Styles.itemRowHeight));
                var itemDisplayCount = Math.Max(0, Math.Min(itemCount, (int)(availableHeight / Styles.itemRowHeight) + 2));
                var topSpaceSkipped  = itemSkipCount * Styles.itemRowHeight;

                int rowIndex   = itemSkipCount;
                var limitCount = Math.Max(0, Math.Min(itemDisplayCount, itemCount - itemSkipCount));
                if (limitCount > 0)
                {
                    if (topSpaceSkipped > 0)
                    {
                        GUILayout.Space(topSpaceSkipped);
                    }

                    foreach (var item in m_FilteredItems.GetRange(itemSkipCount, limitCount))
                    {
                        try
                        {
                            DrawItem(item, context, rowIndex++);
                        }
                        #if QUICKSEARCH_DEBUG
                        catch (Exception ex)
                        {
                            Debug.LogError($"m_FilteredItems.Count={m_FilteredItems.Count}, itemSkipCount={itemSkipCount}, limitCount={limitCount}, m_SelectedIndex={m_SelectedIndex}");
                            Debug.LogException(ex);
                        }
                        #else
                        catch
                        {
                            // ignored
                        }
                        #endif
                    }

                    var bottomSpaceSkipped = (itemCount - rowIndex) * Styles.itemRowHeight;
                    if (bottomSpaceSkipped > 0)
                    {
                        GUILayout.Space(bottomSpaceSkipped);
                    }

                    HandleItemEvents(itemCount, context);

                    // Fix selected index display if out of virtual scrolling area
                    if (Event.current.type == EventType.Repaint && m_FocusSelectedItem && m_SelectedIndex >= 0)
                    {
                        ScrollToItem(itemSkipCount + 1, itemSkipCount + itemDisplayCount - 2, m_SelectedIndex);
                        m_FocusSelectedItem = false;
                    }
                }
                else
                {
                    if (String.IsNullOrEmpty(m_Context.searchBoxText.Trim()))
                    {
                        GUILayout.Box("What are you looking for?\nJust start typing...",
                                      Styles.noResult, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
                    }
                    else
                    {
                        GUILayout.Box("No result for query \"" + m_Context.searchBoxText + "\"\n" + "Try something else?",
                                      Styles.noResult, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
                    }
                }
            }
        }
Beispiel #3
0
 private void OnSearchItemsReceived(SearchContext context, IEnumerable <SearchItem> items)
 {
     ProcessItems(context, items);
 }
Beispiel #4
0
 /// <summary>
 /// Helper function to match a string against the SearchContext. This will try to match the search query against each tokens of content (similar to the AddComponent menu workflow)
 /// </summary>
 /// <param name="context">Search context containing the searchQuery that we try to match.</param>
 /// <param name="content">String content that will be tokenized and use to match the search query.</param>
 /// <param name="ignoreCase">Perform matching ignoring casing.</param>
 /// <returns>Has a match occurred.</returns>
 public static bool MatchSearchGroups(SearchContext context, string content, bool ignoreCase = false)
 {
     return(MatchSearchGroups(context.searchQuery, context.searchWords, content, out _, out _,
                              ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
 }
Beispiel #5
0
        private void DrawToolbar(SearchContext context)
        {
            if (context == null)
            {
                return;
            }

            GUILayout.BeginHorizontal(Styles.toolbar);
            {
                var rightRect = EditorGUILayout.GetControlRect(GUILayout.MaxWidth(32f), GUILayout.ExpandHeight(true));
                if (EditorGUI.DropdownButton(rightRect, Styles.filterButtonContent, FocusType.Passive, Styles.filterButton) || m_ShowFilterWindow)
                {
                    if (FilterWindow.canShow)
                    {
                        rightRect.x += 12f; rightRect.y -= 3f;
                        if (m_ShowFilterWindow)
                        {
                            rightRect.y += 30f;
                        }

                        m_ShowFilterWindow = false;
                        if (FilterWindow.ShowAtPosition(this, rightRect))
                        {
                            GUIUtility.ExitGUI();
                        }
                    }
                }

                EditorGUI.BeginChangeCheck();

                using (new BlinkCursorScope(m_CursorBlinking, new Color(0, 0, 0, 0.01f)))
                {
                    var userSearchQuery = context.searchBoxText;
                    if (!String.IsNullOrEmpty(m_CycledSearch) && (Event.current.type == EventType.Repaint || Event.current.type == EventType.Layout))
                    {
                        userSearchQuery  = m_CycledSearch;
                        m_CycledSearch   = null;
                        m_SearchBoxFocus = true;
                        GUI.changed      = true;
                    }

                    GUI.SetNextControlName(k_QuickSearchBoxName);
                    context.searchBoxText = EditorGUILayout.TextField(userSearchQuery, Styles.searchField, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
                }

                if (String.IsNullOrEmpty(context.searchBoxText))
                {
                    EditorGUI.BeginDisabledGroup(true);
                    EditorGUI.TextArea(GUILayoutUtility.GetLastRect(), "search anything...", Styles.placeholderTextStyle);
                    EditorGUI.EndDisabledGroup();
                }
                if (!String.IsNullOrEmpty(context.searchBoxText))
                {
                    if (GUILayout.Button(Icons.clear, Styles.searchFieldClear, GUILayout.Width(24), GUILayout.Height(24)))
                    {
                        context.searchBoxText = "";
                        GUI.changed           = true;
                        GUI.FocusControl(null);
                    }
                }

                if (EditorGUI.EndChangeCheck() || m_FilteredItems == null)
                {
                    m_SelectedIndex    = -1;
                    m_ScrollPosition.y = 0;
                    SearchService.SearchTextChanged(context);
                    m_FilteredItems = SearchService.GetItems(context);
                    UpdateWindowTitle();
                }

                #if QUICKSEARCH_DEBUG
                DrawDebugTools();
                #endif
            }
            GUILayout.EndHorizontal();
        }
Beispiel #6
0
 /// <summary>
 /// Helper function to create a new search item for the current provider.
 /// </summary>
 /// <param name="context">Search context from the query that generates this item.</param>
 /// <param name="id">Unique id of the search item. This is used to remove duplicates to the user view.</param>
 /// <returns>The newly created search item attached to the current search provider.</returns>
 public SearchItem CreateItem(SearchContext context, string id)
 {
     return(CreateItem(context, id, 0, null, null, null, null));
 }
Beispiel #7
0
 public SearchApiSession(SearchProvider provider)
 {
     context = new SearchContext(new [] { provider });
 }
Beispiel #8
0
        private static void DrawDescription(SearchContext context, SearchItem item)
        {
            var description = SearchContent.FormatDescription(item, context, 2048);

            GUILayout.Label(description, Styles.previewDescription);
        }
Beispiel #9
0
        public void Draw(SearchContext context, float width)
        {
            var selection      = context.searchView.selection;
            var selectionCount = selection.Count;

            if (selectionCount == 0)
            {
                return;
            }

            var lastItem = selection.Last();

            using (var scrollView = new EditorGUILayout.ScrollViewScope(m_ScrollPosition, GUILayout.Width(width), GUILayout.ExpandHeight(true)))
            {
                var showOptions = lastItem.provider.showDetailsOptions;

                if (showOptions.HasFlag(ShowDetailsOptions.Inspector) && Event.current.type == EventType.Layout)
                {
                    SetupEditors(selection);
                }

                if (selectionCount > 1)
                {
                    GUILayout.Label($"Selected {selectionCount} items", Styles.previewDescription);
                }
                else
                {
                    if (showOptions.HasFlag(ShowDetailsOptions.Preview))
                    {
                        if (showOptions.HasFlag(ShowDetailsOptions.Inspector))
                        {
                            if (m_Editors != null && m_Editors.Length == 1 && m_Editors[0].HasPreviewGUI())
                            {
                                var e           = m_Editors[0];
                                var previewRect = EditorGUILayout.GetControlRect(GUILayout.MaxWidth(width), GUILayout.MaxHeight(width));
                                if (previewRect.width > 0 && previewRect.height > 0)
                                {
                                    e.OnPreviewGUI(previewRect, Styles.largePreview);
                                }
                            }
                            else
                            {
                                DrawPreview(context, lastItem, width);
                            }
                        }
                        else
                        {
                            DrawPreview(context, lastItem, width);
                        }
                    }

                    if (showOptions.HasFlag(ShowDetailsOptions.Description))
                    {
                        DrawDescription(context, lastItem);
                    }
                }

                if (showOptions.HasFlag(ShowDetailsOptions.Inspector))
                {
                    DrawInspector(selection, width);
                }

                if (showOptions.HasFlag(ShowDetailsOptions.Actions))
                {
                    DrawActions(context);
                }

                m_ScrollPosition = scrollView.scrollPosition;
            }
        }
 public void ShowItemContextualMenu(SearchItem item, SearchContext context, Rect contextualActionPosition)
 {
     // Nothing to do.
 }
Beispiel #11
0
 public SearchRequest(ExpressionType type, SearchContext searchContext)
     : this(type)
 {
     pendingQueries.Enqueue(searchContext);
 }
 public void ExecuteAction(SearchAction action, SearchItem[] items, SearchContext context, bool endSearch = true)
 {
     selectCallback?.Invoke(items.FirstOrDefault(), false);
 }
Beispiel #13
0
        public SearchContext CreateContext()
        {
            var context = new SearchContext(providers, searchQuery);

            return(context);
        }
 /// <summary>
 /// Helper function to match a string against the SearchContext. This will try to match the search query against each tokens of content (similar to the AddComponent menu workflow)
 /// </summary>
 /// <param name="context">Search context containing the searchQuery that we try to match.</param>
 /// <param name="content">String content that will be tokenized and use to match the search query.</param>
 /// <param name="useLowerTokens">Perform matching ignoring casing.</param>
 /// <returns>Has a match occurred.</returns>
 public static bool MatchSearchGroups(SearchContext context, string content, bool useLowerTokens = false)
 {
     return(MatchSearchGroups(context.searchQuery,
                              useLowerTokens ? context.tokenizedSearchQueryLower : context.tokenizedSearchQuery, content, out _, out _,
                              useLowerTokens ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase));
 }
Beispiel #15
0
 public static SearchQuery Create(SearchContext context, string description = null, Texture2D icon = null)
 {
     return(Create(context.searchText, context.providers.Select(p => p.name.id), description, icon));
 }
 public SortedSearchList(SearchContext searchContext) : base(searchContext)
 {
     Clear();
 }
Beispiel #17
0
        public static GUIContent FormatDescription(SearchItem item, SearchContext context, float availableSpace, bool useColor = true)
        {
            var desc = item.GetDescription(context);

            if (String.IsNullOrEmpty(desc))
            {
                return(Styles.emptyContent);
            }
            var content = Take(desc);

            if (item.options == SearchItemOptions.None || Event.current.type != EventType.Repaint)
            {
                return(content);
            }

            var truncatedDesc = desc;
            var truncated     = false;

            if (useColor)
            {
                if (item.options.HasFlag(SearchItemOptions.Ellipsis))
                {
                    int maxCharLength = Utils.GetNumCharactersThatFitWithinWidth(Styles.itemDescription, truncatedDesc + "...", availableSpace);
                    if (maxCharLength < 0)
                    {
                        maxCharLength = truncatedDesc.Length;
                    }
                    truncated = desc.Length > maxCharLength;
                    if (truncated)
                    {
                        if (item.options.HasFlag(SearchItemOptions.RightToLeft))
                        {
                            truncatedDesc = "..." + desc.Replace("<b>", "").Replace("</b>", "");
                            truncatedDesc = truncatedDesc.Substring(Math.Max(0, truncatedDesc.Length - maxCharLength));
                        }
                        else
                        {
                            truncatedDesc = desc.Substring(0, Math.Min(maxCharLength, desc.Length)) + "...";
                        }
                    }
                }

                if (context != null)
                {
                    if (item.options.HasFlag(SearchItemOptions.Highlight))
                    {
                        var parts = context.searchQuery.Split('*', ' ', '.').Where(p => p.Length > 2);
                        foreach (var p in parts)
                        {
                            truncatedDesc = Regex.Replace(truncatedDesc, Regex.Escape(p), string.Format(Styles.highlightedTextColorFormat, "$0"), RegexOptions.IgnoreCase);
                        }
                    }
                    else if (item.options.HasFlag(SearchItemOptions.FuzzyHighlight))
                    {
                        long score   = 1;
                        var  matches = new List <int>();
                        var  sq      = Utils.CleanString(context.searchQuery.ToLowerInvariant());
                        if (FuzzySearch.FuzzyMatch(sq, Utils.CleanString(truncatedDesc), ref score, matches))
                        {
                            truncatedDesc = RichTextFormatter.FormatSuggestionTitle(truncatedDesc, matches);
                        }
                    }
                }
            }

            content.text = truncatedDesc;
            if (truncated)
            {
                content.tooltip = Utils.StripHTML(desc);
            }

            return(content);
        }
 public AsyncSearchList(SearchContext searchContext) : base(searchContext)
 {
     m_UnorderedItems = new List <SearchItem>();
 }
Beispiel #19
0
 /// <summary>
 /// Create a Search item that will be bound to the SeaechProvider.
 /// </summary>
 /// <param name="context">Search context from the query that generates this item.</param>
 /// <param name="id">Unique id of the search item. This is used to remove duplicates to the user view.</param>
 /// <param name="label">The search item label is displayed on the first line of the search item UI widget.</param>
 /// <param name="description">The search item description is displayed on the second line of the search item UI widget.</param>
 /// <param name="thumbnail">The search item thumbnail is displayed left to the item label and description as a preview.</param>
 /// <param name="data">User data used to recover more information about a search item. Generally used in fetchLabel, fetchDescription, etc.</param>
 /// <returns>New SearchItem</returns>
 public SearchItem CreateItem(SearchContext context, string id, string label, string description, Texture2D thumbnail, object data)
 {
     return(CreateItem(context, id, 0, label, description, thumbnail, data));
 }
 public BaseSearchList(SearchContext searchContext)
 {
     context = searchContext;
     context.asyncItemReceived += OnAsyncItemsReceived;
 }
Beispiel #21
0
 private void OnAsyncItemsReceived(SearchContext context, IEnumerable <SearchItem> items)
 {
     onAsyncItemsReceived?.Invoke(items.Select(item => item.id));
 }
Beispiel #22
0
 public static string[] GetKeywords(SearchContext context, string lastToken)
 {
     throw new NotSupportedException();
 }
Beispiel #23
0
        public static void AutoCompletion(Rect rect, SearchContext context, ISearchView view)
        {
            if (s_DiscardAutoComplete || controlID <= 0)
            {
                return;
            }

            if (s_AutoCompleting && Event.current.type == EventType.MouseDown && !s_AutoCompleteRect.Contains(Event.current.mousePosition))
            {
                s_DiscardAutoComplete = true;
                s_AutoCompleting      = false;
                return;
            }

            var te             = GetTextEditor();
            var cursorPosition = te.cursorIndex;

            if (cursorPosition == 0)
            {
                return;
            }

            var searchText        = context.searchText;
            var lastTokenStartPos = searchText.LastIndexOf(' ', Math.Max(0, te.cursorIndex - 1));
            var lastToken         = lastTokenStartPos == -1 ? searchText : searchText.Substring(lastTokenStartPos + 1);
            var keywords          = SearchService.GetKeywords(context, lastToken).Where(k => !k.Equals(lastToken, StringComparison.OrdinalIgnoreCase)).ToArray();

            if (keywords.Length > 0)
            {
                const int maxAutoCompleteCount = 16;
                s_AutoCompleteMaxIndex = Math.Min(keywords.Length, maxAutoCompleteCount);
                if (!s_AutoCompleting)
                {
                    s_AutoCompleteIndex = 0;
                }

                if (Event.current.type == EventType.Repaint)
                {
                    var content = new GUIContent(context.searchText.Substring(0, context.searchText.Length - lastToken.Length));
                    var offset  = Styles.searchField.CalcSize(content).x;
                    s_AutoCompleteRect       = rect;
                    s_AutoCompleteRect.x    += offset;
                    s_AutoCompleteRect.y     = rect.yMax;
                    s_AutoCompleteRect.width = 250;
                    s_AutoCompleteRect.x     = Math.Min(rect.width - s_AutoCompleteRect.width - 25, s_AutoCompleteRect.x);
                }

                var lt = lastToken;

                var autoFill = DoAutoComplete(lastToken, keywords, maxAutoCompleteCount, 0.1f);
                if (autoFill == null)
                {
                    // No more results
                    s_AutoCompleting    = false;
                    s_AutoCompleteIndex = -1;
                }
                else if (autoFill != lastToken)
                {
                    var regex = new Regex(Regex.Escape(lastToken), RegexOptions.IgnoreCase);
                    autoFill = regex.Replace(autoFill, "");
                    view.SetSearchText(context.searchText.Insert(cursorPosition, autoFill));
                }
                else
                {
                    s_AutoCompleting = true;
                }
            }
            else
            {
                s_AutoCompleting    = false;
                s_AutoCompleteIndex = -1;
            }
        }
Beispiel #24
0
        /// <summary>
        /// Initiate a search and return all search items matching the search context. Other items can be found later using the asynchronous searches.
        /// </summary>
        /// <param name="context">The current search context</param>
        /// <param name="options">Options defining how the query will be performed</param>
        /// <returns>A list of search items matching the search query.</returns>
        public static List <SearchItem> GetItems(SearchContext context, SearchFlags options = SearchFlags.Default)
        {
            DebugInfo.gcFetch = GC.GetTotalMemory(false);

            // Stop all search sessions every time there is a new search.
            context.sessions.StopAllAsyncSearchSessions();
            context.searchFinishTime = context.searchStartTime = EditorApplication.timeSinceStartup;
            context.sessionEnded    -= OnSearchEnded;
            context.sessionEnded    += OnSearchEnded;

            #if SHOW_SEARCH_PROGRESS
            if (Progress.Exists(context.progressId))
            {
                Progress.Finish(context.progressId, Progress.Status.Succeeded);
            }
            context.progressId = Progress.Start($"Searching...", options: Progress.Options.Indefinite);
            #endif

            if (options.HasFlag(SearchFlags.WantsMore))
            {
                context.wantsMore = true;
            }

            if (options.HasFlag(SearchFlags.Synchronous))
            {
                context.options |= SearchFlags.Synchronous;
            }

            int fetchProviderCount = 0;
            var allItems           = new List <SearchItem>(3);
            #if QUICKSEARCH_DEBUG
            var debugProviderList = context.providers.ToList();
            using (new DebugTimer($"Search get items {String.Join(", ", debugProviderList.Select(p=>p.name.id))} -> {context.searchQuery}"));
            #endif
            foreach (var provider in context.providers)
            {
                try
                {
                    var watch = new System.Diagnostics.Stopwatch();
                    watch.Start();
                    fetchProviderCount++;
                    var iterator = provider.fetchItems(context, allItems, provider);
                    if (iterator != null && options.HasFlag(SearchFlags.Synchronous))
                    {
                        var stackedEnumerator = new StackedEnumerator <SearchItem>(iterator);
                        while (stackedEnumerator.MoveNext())
                        {
                            if (stackedEnumerator.Current != null)
                            {
                                allItems.Add(stackedEnumerator.Current);
                            }
                        }
                    }
                    else
                    {
                        var session = context.sessions.GetProviderSession(context, provider.name.id);
                        session.Reset(context, iterator, k_MaxFetchTimeMs);
                        session.Start();
                        var sessionEnded = !session.FetchSome(allItems, k_MaxFetchTimeMs);
                        if (options.HasFlag(SearchFlags.FirstBatchAsync))
                        {
                            session.SendItems(allItems);
                        }
                        if (sessionEnded)
                        {
                            session.Stop();
                        }
                    }
                    provider.RecordFetchTime(watch.Elapsed.TotalMilliseconds);
                }
                catch (Exception ex)
                {
                    UnityEngine.Debug.LogException(new Exception($"Failed to get fetch {provider.name.displayName} provider items.", ex));
                }
            }

            if (fetchProviderCount == 0)
            {
                OnSearchEnded(context);
                context.sessions.StopAllAsyncSearchSessions();
            }

            DebugInfo.gcFetch = GC.GetTotalMemory(false) - DebugInfo.gcFetch;

            if (!options.HasFlag(SearchFlags.Sorted))
            {
                return(allItems);
            }

            allItems.Sort(SortItemComparer);
            return(allItems.GroupBy(i => i.id).Select(i => i.First()).ToList());
        }
Beispiel #25
0
        private void HandleKeyboardNavigation(SearchContext context)
        {
            // TODO: support page down and page up

            var evt = Event.current;

            if (evt.type == EventType.KeyDown)
            {
                var prev = m_SelectedIndex;
                if (evt.keyCode == KeyCode.DownArrow)
                {
                    if (m_SelectedIndex == -1 && evt.modifiers.HasFlag(EventModifiers.Alt))
                    {
                        m_CycledSearch = SearchService.CyclePreviousSearch(-1);
                        GUI.FocusControl(null);
                    }
                    else
                    {
                        m_SelectedIndex = Math.Min(m_SelectedIndex + 1, m_FilteredItems.Count - 1);
                        Event.current.Use();
                    }
                }
                else if (evt.keyCode == KeyCode.UpArrow)
                {
                    if (m_SelectedIndex >= 0)
                    {
                        m_SelectedIndex = Math.Max(-1, m_SelectedIndex - 1);
                        if (m_SelectedIndex == -1)
                        {
                            m_SearchBoxFocus = true;
                        }
                        Event.current.Use();
                    }
                    else if (evt.modifiers.HasFlag(EventModifiers.Alt))
                    {
                        m_CycledSearch = SearchService.CyclePreviousSearch(+1);
                        GUI.FocusControl(null);
                    }
                }
                else if (evt.keyCode == KeyCode.PageDown)
                {
                    m_SelectedIndex = Math.Min(m_SelectedIndex + GetDisplayItemCount() - 1, m_FilteredItems.Count - 1);
                    Event.current.Use();
                }
                else if (evt.keyCode == KeyCode.PageUp)
                {
                    m_SelectedIndex = Math.Max(0, m_SelectedIndex - GetDisplayItemCount());
                    Event.current.Use();
                }
                else if (evt.keyCode == KeyCode.RightArrow && evt.modifiers.HasFlag(EventModifiers.Alt))
                {
                    if (m_SelectedIndex != -1)
                    {
                        var item          = m_FilteredItems.ElementAt(m_SelectedIndex);
                        var menuPositionY = (m_SelectedIndex + 1) * Styles.itemRowHeight - m_ScrollPosition.y + Styles.itemRowHeight / 2.0f;
                        ShowItemContextualMenu(item, context, new Rect(position.width - Styles.actionButtonSize, menuPositionY, 1, 1));
                        Event.current.Use();
                    }
                }
                else if (evt.keyCode == KeyCode.LeftArrow && evt.modifiers.HasFlag(EventModifiers.Alt))
                {
                    m_ShowFilterWindow = true;
                    Event.current.Use();
                }
                else if (evt.keyCode == KeyCode.KeypadEnter || evt.keyCode == KeyCode.Return)
                {
                    var selectedIndex = m_SelectedIndex;
                    if (selectedIndex == -1 && m_FilteredItems != null && m_FilteredItems.Count > 0)
                    {
                        selectedIndex = 0;
                    }

                    if (selectedIndex != -1 && m_FilteredItems != null)
                    {
                        int actionIndex = 0;
                        if (evt.modifiers.HasFlag(EventModifiers.Alt))
                        {
                            actionIndex = 1;
                            if (evt.modifiers.HasFlag(EventModifiers.Control))
                            {
                                actionIndex = 2;
                                if (evt.modifiers.HasFlag(EventModifiers.Shift))
                                {
                                    actionIndex = 3;
                                }
                            }
                        }
                        var item = m_FilteredItems.ElementAt(selectedIndex);
                        if (item.provider.actions.Any())
                        {
                            Event.current.Use();
                            actionIndex = Math.Max(0, Math.Min(actionIndex, item.provider.actions.Count - 1));

                            ExecuteAction(item.provider.actions[actionIndex], item, context);
                            GUIUtility.ExitGUI();
                        }
                    }
                }
                else if (evt.keyCode == KeyCode.Escape)
                {
                    CloseSearchWindow();
                    Event.current.Use();
                }
                else
                {
                    GUI.FocusControl(k_QuickSearchBoxName);
                }

                if (prev != m_SelectedIndex)
                {
                    m_FocusSelectedItem = true;
                    Repaint();
                }
            }

            if (m_FilteredItems == null || m_FilteredItems.Count == 0)
            {
                m_SearchBoxFocus = true;
            }
        }
Beispiel #26
0
 public virtual void BeginSession(UnityEditor.SearchService.ISearchContext context)
 {
     provider     = SearchService.Providers.First(p => p.name.id == providerId);
     this.context = new SearchContext(new [] { provider });
 }
Beispiel #27
0
 private void ExecuteAction(SearchAction action, SearchItem item, SearchContext context)
 {
     SearchService.LastSearch = context.searchBoxText;
     action.handler(item, context);
     CloseSearchWindow();
 }
Beispiel #28
0
 public virtual void EndSession(UnityEditor.SearchService.ISearchContext context)
 {
     StopAsyncResults();
     this.context = null;
 }
Beispiel #29
0
 public SearchRequest(ExpressionType type, SearchContext searchContext, Action <SearchRequest> finishedHandler = null)
     : this(type, finishedHandler)
 {
     pendingQueries.Enqueue(searchContext);
 }
Beispiel #30
0
 public AsyncSearchSession(SearchContext context)
 {
     m_Context = context;
 }