private void Helper_GotFocus(object sender, RoutedEventArgs e)
        {
            var helper = (DataGrid)sender;

            helper.SelectedItems.Clear();

            RequirementsDataGrid.Focus();
        }
        private void ColumnHeader_RightClickEvent(object sender, MouseButtonEventArgs e)
        {
            var TC = (int)(sender as System.Windows.Controls.Primitives.DataGridColumnHeader).Content;

            RequirementsDataGrid.SelectedItems.Clear();
            RequirementsDataGrid.Items.Cast <RequirementSingleView>()
            .Where(x => x.TCIDsValue.Contains(TC))
            .ToList()
            .ForEach(x => RequirementsDataGrid.SelectedItems.Add(x));
            RequirementsDataGrid.Focus();
        }
        private void ColumnHeader_DoubleClickEvent(object sender, MouseButtonEventArgs e)
        {
            var header = (System.Windows.Controls.Primitives.DataGridColumnHeader)sender;

            var tcID = (int)header.Content;

            var firstOccurence = RequirementsDataGrid.Items.Cast <RequirementSingleView>()
                                 .TakeWhile(x => x.TCIDsValue.Contains(tcID) != true)
                                 .Count();

            var lastOccurence = RequirementsDataGrid.Items.Cast <RequirementSingleView>().Count() - RequirementsDataGrid.Items.Cast <RequirementSingleView>()
                                .Reverse()
                                .TakeWhile(x => x.TCIDsValue.Contains(tcID) != true)
                                .Count();

            RequirementsDataGrid.ScrollIntoView(RequirementsDataGrid.Items[lastOccurence]);

            RequirementsDataGrid.ScrollIntoView(RequirementsDataGrid.Items[firstOccurence]);
        }
        public async void ChapterSelectButton_Click(object sender, RoutedEventArgs e)
        {
            var chapterSelectionWindow = new ChapterSelectionWindow(reqsCollection);

            chapterSelectionWindow.ShowDialog();
            if (chapterSelectionWindow.DialogResult == true)
            {
                Mouse.OverrideCursor = Cursors.Wait;
                if (chapterSelectionWindow.ClearPreviousTCs)
                {
                    RefreshRequirementsDataGrid();
                    AllTCsListBox.SelectedItems.Clear();
                    RequirementsDataGrid.UpdateLayout();
                }

                var selectedChapter = chapterSelectionWindow.Answer;
                Console.WriteLine(selectedChapter.chapter);
                await ShowOneChapter(selectedChapter.id, chapterSelectionWindow.SelectTCs);

                ChapterNameTextBlock.Text = selectedChapter.chapter;
                Mouse.OverrideCursor      = Cursors.Arrow;
            }
        }
        private async Task RefreshHelpers(bool horizontalRefresh, bool verticalRefresh, double horizontalOffset, double verticalOffset, double verticalChange = 0)
        {
            if (horizontalRefresh)
            {
                new List <ScrollViewer>()
                {
                    GetScrollViewer(ReqHelperTop),
                    GetScrollViewer(ReqHelperBottom)
                }.ForEach(x => x.ScrollToHorizontalOffset(horizontalOffset));
            }

            if (verticalRefresh)
            {
                var datagridHeight = RequirementsDataGrid.ActualHeight;
                var rowHeight      = RequirementsDataGrid.RowHeight;
                var firstRow       = (int)verticalOffset;
                var lastRow        = firstRow + (int)(datagridHeight / rowHeight) - 1;

                if (reqsCollection.AsParallel().Any(x => x.IsVisible == false))
                {
                    var firstVisible = RequirementsDataGrid.Items
                                       .IndexOf(RequirementsDataGrid.Items.Cast <RequirementSingleView>()
                                                .First(x => x.IsVisible == true));
                    var lastVisible = RequirementsDataGrid.Items
                                      .IndexOf(RequirementsDataGrid.Items.Cast <RequirementSingleView>()
                                               .Last(x => x.IsVisible == true));

                    if (lastVisible < lastRow)
                    {
                        lastRow = lastVisible + 1;
                    }

                    if (verticalChange < 0 && firstRow < firstVisible)
                    {
                        var scrollViewer = GetScrollViewer(RequirementsDataGrid);
                        scrollViewer.ScrollToVerticalOffset(firstVisible);
                    }
                    else if (verticalChange > 0 && lastVisible < firstRow)
                    {
                        var scrollViewer = GetScrollViewer(RequirementsDataGrid);
                        scrollViewer.ScrollToVerticalOffset(lastVisible);
                    }
                }

                var selectedTCs = new List <int>();
                foreach (int TC in AllTCsListBox.SelectedItems)
                {
                    selectedTCs.Add(TC);
                }


                Parallel.ForEach(selectedTCs, TCSelected =>
                {
                    var TCSelectedString = TCSelected.ToString();
                    if (ReqTopHelperData[0].ContainsKey(TCSelectedString))
                    {
                        var firstOccurence = RequirementsDataGrid.Items.Cast <RequirementSingleView>()
                                             .TakeWhile(x => x.TCIDsValue.Contains(TCSelected) != true)
                                             .Count();

                        if (firstOccurence < firstRow)
                        {
                            ReqTopHelperData[0][TCSelectedString] = true;
                        }
                        else
                        {
                            ReqTopHelperData[0][TCSelectedString] = false;
                        }
                    }

                    if (ReqBottomHelperData[0].ContainsKey(TCSelectedString))
                    {
                        var lastOccurence = RequirementsDataGrid.Items.Cast <RequirementSingleView>().Count() - RequirementsDataGrid.Items.Cast <RequirementSingleView>()
                                            .Reverse()
                                            .TakeWhile(x => x.TCIDsValue.Contains(TCSelected) != true)
                                            .Count();

                        if (lastOccurence > lastRow)
                        {
                            ReqBottomHelperData[0][TCSelectedString] = true;
                        }
                        else
                        {
                            ReqBottomHelperData[0][TCSelectedString] = false;
                        }
                    }
                });
            }
            RequirementsDataGrid.UpdateLayout();
            ReqHelperTop.Items.Refresh();
            ReqHelperBottom.Items.Refresh();
        }
        private void Helper_LeftClickEvent(object sender, MouseButtonEventArgs e)
        {
            var gridCell = (DataGridCell)sender;
            var tc       = (int)gridCell.Column.Header;

            var senderDatagrid = VisualTreeHelper.GetParent(gridCell);

            while (senderDatagrid != null && senderDatagrid.GetType() != typeof(DataGrid))
            {
                senderDatagrid = VisualTreeHelper.GetParent(senderDatagrid);
            }

            var isGoingDown = ((DataGrid)senderDatagrid).Name == nameof(ReqHelperBottom);

            var selectedRows = RequirementsDataGrid.SelectedItems.Count;

            if (selectedRows >= 1)
            {
                var firstSelected = (RequirementSingleView)RequirementsDataGrid.SelectedItems[0];
                RequirementsDataGrid.SelectedItems.Clear();

                if (firstSelected.TCIDsValue.Contains(tc))
                {
                    RequirementsDataGrid.SelectedItems.Add(firstSelected);
                }
                else
                {
                    RequirementsDataGrid.SelectedItems.Add(RequirementsDataGrid.Items.Cast <RequirementSingleView>().First(x => x.TCIDsValue.Contains(tc) && x.IsVisible));
                    RequirementsDataGrid.ScrollIntoView(firstSelected);
                    return;
                }

                RequirementsDataGrid.ScrollIntoView(firstSelected);

                if (selectedRows > 1)
                {
                    return;
                }


                RequirementsDataGrid.SelectedItems.Clear();
                var reqs = RequirementsDataGrid.Items.Cast <RequirementSingleView>().AsEnumerable();
                if (isGoingDown == false)
                {
                    reqs = reqs.Reverse();
                }

                RequirementsDataGrid.SelectedItems
                .Add(reqs
                     .SkipWhile(x => x != firstSelected)
                     .Skip(1)
                     .FirstOrDefault(x => x.TCIDsValue.Contains(tc) && x.IsVisible));

                if (RequirementsDataGrid.SelectedItem == null)
                {
                    RequirementsDataGrid.SelectedItems.Add(firstSelected);
                }

                RequirementsDataGrid.ScrollIntoView(RequirementsDataGrid.SelectedItem);
            }
            else
            {
                RequirementsDataGrid.SelectedItems.Add(RequirementsDataGrid.Items.Cast <RequirementSingleView>().First(x => x.TCIDsValue.Contains(tc) && x.IsVisible));
                RequirementsDataGrid.ScrollIntoView((RequirementSingleView)RequirementsDataGrid.SelectedItems[0]);
            }
        }