void _visualisation_ItemActivated(object item)
 {
     if (ItemActivated != null)
     {
         _currentCluster = (item as TreeData).Tag as SearchCluster;
         ItemActivated(_currentCluster);
     }
 }
        /// <summary>
        /// Populate the document viewer
        /// </summary>
        /// <param name="cluster">The cluster</param>
        /// <param name="searchResultDictionary">The document from the search results</param>
        /// <param name="displayMode">The display mode for the document viewer</param>
        /// <param name="kindFilters">Kind filter to decide which results to include</param>
        /// <param name="providerFilters">Provider filter to decide which results to include</param>
        public void Populate(SearchCluster cluster, Dictionary <Guid, SearchAggregateItem> searchResultDictionary, DocumentViewerDisplayMode displayMode, List <string> kindFilters, List <string> providerFilters)
        {
            carousel.HookHidEvents(false);
            carousel.HookHidEvents(true);

            Action openDocumentViewer = delegate()
            {
                listBoxSearchItems.ItemsSource = null;
                carousel.ItemsSource           = null;

                documentViewerTitle.Text = cluster.Title;

                ShumbiDiscover.Controls.Converters.SearchAggregateItemRankConverter.ProviderFilters      = providerFilters;
                ShumbiDiscover.Controls.Converters.SearchAggregateItemProvidersConverter.ProviderFilters = providerFilters;

                List <SearchAggregateItem> items = new List <SearchAggregateItem>();

                PopulateDocumentViewerFromCluster(cluster, searchResultDictionary, items, kindFilters, providerFilters);

                items.Sort(new SearchAggregateItemComparer(providerFilters));

                carousel.ItemsSource           = items;
                listBoxSearchItems.ItemsSource = items;

                scrollNavigator.Minimum = 0;
                scrollNavigator.Maximum = items.Count - 1;

                if (listBoxSearchItems.Items.Count > 0)
                {
                    listBoxSearchItems.SelectedIndex = 0;
                }

                _displayMode             = displayMode;
                buttonCarousel.IsChecked = _displayMode == DocumentViewerDisplayMode.Carousel;
                buttonList.IsChecked     = _displayMode == DocumentViewerDisplayMode.List;
                gridCarousel.Visibility  = _displayMode == DocumentViewerDisplayMode.Carousel ? Visibility.Visible : Visibility.Collapsed;
                gridList.Visibility      = _displayMode == DocumentViewerDisplayMode.List ? Visibility.Visible : Visibility.Collapsed;

                List <SearchAggregateItem> missingThumbs = new List <SearchAggregateItem>();

                foreach (SearchAggregateItem searchAggregateItem in items)
                {
                    if (string.IsNullOrEmpty(searchAggregateItem.ThumbnailUrl))
                    {
                        missingThumbs.Add(searchAggregateItem);
                        ThumbnailManager.Instance.GetThumbnail(searchAggregateItem.OpenUrl, 300, 300, true, searchAggregateItem, new ThumbnailCompletedEventHandler(ThumbnailCompleted));
                    }
                }
                foreach (SearchAggregateItem searchAggregateItem in missingThumbs)
                {
                    ThumbnailManager.Instance.GetThumbnail(searchAggregateItem.OpenUrl, 300, 300, false, searchAggregateItem, new ThumbnailCompletedEventHandler(ThumbnailCompleted));
                }
            };

            Dispatcher.BeginInvoke(openDocumentViewer);
        }
        private TreeData CreateTree()
        {
            SearchCluster rootCluster = new SearchCluster();

            rootCluster.Title          = _searchResultSet.SearchDescription.Query;
            rootCluster.SearchClusters = _searchResultSet.SearchClusters;
            rootCluster.Score          = 1;

            TreeData root = new TreeData(rootCluster.Title, rootCluster.Score, rootCluster);

            BuildTree(root, rootCluster.SearchClusters);

            return(root);
        }
        private void ConvertClusters(IList <ICluster> resultClusters, List <SearchCluster> clusters)
        {
            foreach (ICluster resultCluster in resultClusters)
            {
                SearchCluster searchCluster = new SearchCluster();
                searchCluster.Title           = resultCluster.Title;
                searchCluster.Score           = resultCluster.Score;
                searchCluster.SearchResultIds = new List <System.Guid>();
                foreach (ISnippet snippet in resultCluster.Snippets)
                {
                    searchCluster.SearchResultIds.Add((snippet as ClustererSnippet).Id);
                }
                searchCluster.SearchClusters = new List <SearchCluster>();
                clusters.Add(searchCluster);

                ConvertClusters(resultCluster.SubClusters, searchCluster.SearchClusters);
            }
        }
        private void PopulateDocumentViewerFromCluster(SearchCluster cluster, Dictionary <Guid, SearchAggregateItem> searchResultDictionary, List <SearchAggregateItem> items, List <string> kindFilters, List <string> providerFilters)
        {
            if (cluster.SearchClusters != null)
            {
                foreach (SearchCluster subCluster in cluster.SearchClusters)
                {
                    PopulateDocumentViewerFromCluster(subCluster, searchResultDictionary, items, kindFilters, providerFilters);
                }
            }

            if (cluster.SearchResultIds != null)
            {
                foreach (Guid searchResultId in cluster.SearchResultIds)
                {
                    if (searchResultDictionary.ContainsKey(searchResultId))
                    {
                        SearchAggregateItem searchResultItem = searchResultDictionary[searchResultId];

                        // First skip any duplicates
                        if (!items.Contains(searchResultItem))
                        {
                            if (kindFilters.Contains(searchResultItem.Kind))
                            {
                                bool found = false;

                                for (int i = 0; i < searchResultItem.ProviderRanks.Count && !found; i++)
                                {
                                    if (providerFilters.Contains(searchResultItem.ProviderRanks[i].Provider))
                                    {
                                        items.Add(searchResultItem);
                                        found = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
 void SearchVisualisation_ItemSelected(SearchCluster selectedItem)
 {
     InformationPanelRefresh();
     ActionButtonsRefresh();
 }
 void SearchVisualisation_ItemActivated(SearchCluster activatedItem)
 {
     OpenDocumentViewer();
 }
        private void GetClusterInformation(SearchCluster cluster, Dictionary<string, int> searchProviders, Dictionary<string, int> searchResultKinds, Collection<Guid> alreadyAdded)
        {
            if (cluster.SearchResultIds != null)
            {
                foreach (Guid searchResultId in cluster.SearchResultIds)
                {
                    if (!alreadyAdded.Contains(searchResultId))
                    {
                        alreadyAdded.Add(searchResultId);

                        SearchAggregateItem searchAggregateItem = _currentSearchVisualisation.SearchResultsDictionary[searchResultId];

                        foreach (SearchProviderRank searchProviderRank in searchAggregateItem.ProviderRanks)
                        {
                            if (!searchProviders.ContainsKey(searchProviderRank.Provider))
                            {
                                searchProviders.Add(searchProviderRank.Provider, 1);
                            }
                            else
                            {
                                searchProviders[searchProviderRank.Provider]++;
                            }
                        }

                        if (!searchResultKinds.ContainsKey(searchAggregateItem.Kind))
                        {
                            searchResultKinds.Add(searchAggregateItem.Kind, 1);
                        }
                        else
                        {
                            searchResultKinds[searchAggregateItem.Kind]++;
                        }
                    }
                }
            }
            if (cluster.SearchClusters != null)
            {
                foreach (SearchCluster subCluster in cluster.SearchClusters)
                {
                    GetClusterInformation(subCluster, searchProviders, searchResultKinds, alreadyAdded);
                }
            }
        }