Beispiel #1
0
        private void WordListsGrid_OnSelectionChanged(object sender, DataGridSelectionChangedEventArgs e)
        {
            var vm = (WordListsViewModel)DataContext;

            if (_selectMonitor.Busy)
            {
                return;
            }

            using (_selectMonitor.Enter())
            {
                if (WordListsGrid.SelectedCellRanges.Count == 1)
                {
                    SelectionCellRange cellRange = WordListsGrid.SelectedCellRanges[0];
                    int itemIndex   = cellRange.ItemRange.StartIndex;
                    var variety     = (WordListsVarietyViewModel)WordListsGrid.Items[itemIndex];
                    int columnIndex = cellRange.ColumnRange.StartIndex;
                    vm.SelectedVarietyMeaning = variety.Meanings[columnIndex - 1];
                }
                else
                {
                    vm.SelectedVarietyMeaning = null;
                }
            }
        }
        private void SegmentsDataGrid_OnSelectionChanged(object sender, DataGridSelectionChangedEventArgs e)
        {
            if (_selectMonitor.Busy)
            {
                return;
            }

            using (_selectMonitor.Enter())
            {
                var vm = (SegmentMappingsTableViewModel)DataContext;
                if (SegmentsDataGrid.SelectedCellRanges.Count == 1)
                {
                    SelectionCellRange cellRange = SegmentsDataGrid.SelectedCellRanges[0];
                    int itemIndex   = cellRange.ItemRange.StartIndex;
                    var segment     = (SegmentMappingsTableSegmentViewModel)SegmentsDataGrid.Items[itemIndex];
                    int columnIndex = cellRange.ColumnRange.StartIndex;
                    SegmentMappingsTableSegmentPairViewModel segmentPair = segment.SegmentPairs[columnIndex - 1];
                    vm.SelectedSegmentPair = segmentPair.IsEnabled ? segmentPair : null;
                }
                else
                {
                    vm.SelectedSegmentPair = null;
                }
            }
        }
            private HashSet <int> GetIntersectedRangesForIndex(
                DataGridContext dataGridContext,
                int itemIndex,
                int[] exportedVisiblePositions,
                int correctedExportedVisiblePositionsCount)
            {
                HashSet <int> intersectedIndexes = null;

                if (correctedExportedVisiblePositionsCount == 0)
                {
                    return(intersectedIndexes);
                }

                SelectionItemRangeCollection selectedRanges = dataGridContext.SelectedItemRanges as SelectionItemRangeCollection;

                if (selectedRanges.Contains(itemIndex))
                {
                    intersectedIndexes = new HashSet <int>(exportedVisiblePositions);
                }
                else
                {
                    intersectedIndexes = new HashSet <int>();

                    SelectionCellRange columnsRange = new SelectionCellRange(itemIndex,
                                                                             exportedVisiblePositions[0],
                                                                             itemIndex,
                                                                             exportedVisiblePositions[correctedExportedVisiblePositionsCount - 1]);

                    List <SelectionRange> intersectedRanges =
                        dataGridContext.SelectedCellsStore.GetIntersectedColumnRanges(columnsRange);

                    foreach (SelectionRange range in intersectedRanges)
                    {
                        int startIndex = range.StartIndex;
                        int endIndex   = range.EndIndex;

                        if (startIndex > endIndex)
                        {
                            startIndex = range.EndIndex;
                            endIndex   = range.StartIndex;
                        }

                        for (int i = startIndex; i <= endIndex; i++)
                        {
                            if (!intersectedIndexes.Contains(i))
                            {
                                intersectedIndexes.Add(i);
                            }
                        }
                    }
                }

                return(intersectedIndexes);
            }
        public static void SelectItem(this DataGridContext gridContext, object item)
        {
            var gridControl = gridContext.DataGridControl;

            if (gridControl.SelectionUnit == SelectionUnit.Row)
            {
            }
            else
            {
                gridContext.SelectedCellRanges.Clear();
                var index       = gridContext.Items.IndexOf(item);
                var columnCount = gridContext.VisibleColumns.Count;
                var range       = new SelectionCellRange(new SelectionRange(index), new SelectionRange(0, columnCount - 1));
                gridContext.SelectedCellRanges.Add(range);
            }
        }
        private void AlignmentGrid_OnSelectionChanged(object sender, DataGridSelectionChangedEventArgs e)
        {
            var vm = (MultipleWordAlignmentViewModel)DataContext;

            if (e.SelectionInfos.Count == 1 && e.SelectionInfos[0].AddedCellRanges.Count == 1)
            {
                SelectionCellRange range = e.SelectionInfos[0].AddedCellRanges[0];
                vm.SelectedColumn = range.ColumnRange.StartIndex - 2;
                vm.SelectedWord   = (MultipleWordAlignmentWordViewModel)AlignmentGrid.Items[range.ItemRange.StartIndex];
            }
            else
            {
                vm.SelectedColumn         = -1;
                vm.SelectedWord           = null;
                AlignmentGrid.CurrentItem = null;
            }
        }
      private HashSet<int> GetIntersectedRangesForIndex( DataGridContext dataGridContext, int itemIndex, int[] exportedVisiblePositions, int correctedExportedVisiblePositionsCount )
      {
        HashSet<int> intersectedIndexes = null;

        if( correctedExportedVisiblePositionsCount == 0 )
          return intersectedIndexes;

        SelectionItemRangeCollection selectedRanges = dataGridContext.SelectedItemRanges as SelectionItemRangeCollection;

        if( selectedRanges.Contains( itemIndex ) )
        {
          intersectedIndexes = new HashSet<int>( exportedVisiblePositions );
        }
        else
        {
          intersectedIndexes = new HashSet<int>();

          SelectionCellRange columnsRange = new SelectionCellRange( itemIndex, exportedVisiblePositions[ 0 ], itemIndex,
                                                                    exportedVisiblePositions[ correctedExportedVisiblePositionsCount - 1 ] );

          IEnumerable<SelectionRange> intersectedRanges = dataGridContext.SelectedCellsStore.GetIntersectedColumnRanges( columnsRange );

          foreach( SelectionRange range in intersectedRanges )
          {
            int startIndex = range.StartIndex;
            int endIndex = range.EndIndex;

            if( startIndex > endIndex )
            {
              startIndex = range.EndIndex;
              endIndex = range.StartIndex;
            }

            for( int i = startIndex; i <= endIndex; i++ )
            {
              if( !intersectedIndexes.Contains( i ) )
              {
                intersectedIndexes.Add( i );
              }
            }
          }
        }

        return intersectedIndexes;
      }