Exemple #1
0
        private bool ChangeCurrentCore(object newCurrent, ItemInfo?info, bool cancelable, bool scrollToCurrent)
        {
            // Raise CurrentChanging first
            bool cancel = this.PreviewCancelCurrentChanging(cancelable);

            if (cancel || this.Owner.animationSurvice.IsAnimating(info))
            {
                // the change is canceled
                return(false);
            }

            var oldCurrent = this.currentItem;

            this.updatingCurrent = true;

            this.currentItem     = newCurrent;
            this.currentItemInfo = info;
            this.Owner.ChangePropertyInternally(RadListView.CurrentItemProperty, this.currentItem);

            if (this.isSynchronizedWithCurrent)
            {
                this.Owner.SelectedItem = this.currentItem;
            }

            this.UpdateState(scrollToCurrent);

            if (!object.ReferenceEquals(oldCurrent, this.currentItem))
            {
                this.OnCurrentChanged(EventArgs.Empty);
            }

            this.updatingCurrent = false;

            return(true);
        }
Exemple #2
0
        internal ItemInfo?FindDataItemFromIndex(int index, object dataItem = null)
        {
            var enumerator = this.layoutController.strategy.Layout.GetLines(index, true).GetEnumerator();

            ItemInfo?info = null;

            while (enumerator.MoveNext())
            {
                foreach (var item in enumerator.Current)
                {
                    if (item.ItemType == GroupType.BottomLevel)
                    {
                        if (dataItem == null || object.Equals(item.Item, dataItem))
                        {
                            info = item;
                            break;
                        }
                    }
                }

                if (info != null)
                {
                    break;
                }
            }

            return(info);
        }
        /// <summary>
        /// Retrieves a UI Automation provider for each child element that is selected.
        /// </summary>
        public IRawElementProviderSimple[] GetSelection()
        {
            List <IRawElementProviderSimple> providerSamples = new List <IRawElementProviderSimple>();

            foreach (object selected in this.ListViewOwner.SelectedItems)
            {
                ItemInfo?info = this.ListViewOwner.Model.FindItemInfo(selected);
                if (!info.HasValue)
                {
                    continue;
                }

                GeneratedItemModel generatedModel = this.ListViewOwner.Model.GetDisplayedElement(info.Value.Slot, info.Value.Id);
                RadListViewItem    container      = null;
                if (generatedModel != null)
                {
                    container = generatedModel.Container as RadListViewItem;
                }
                if (container == null)
                {
                    continue;
                }

                AutomationPeer itemPeer = (RadListViewItemAutomationPeer)FrameworkElementAutomationPeer.CreatePeerForElement(container);
                if (itemPeer != null)
                {
                    providerSamples.Add(this.ProviderFromPeer(itemPeer));
                }
            }

            return(providerSamples.ToArray());
        }
Exemple #4
0
 internal bool IsAnimating(ItemInfo?info)
 {
     return(this.runningAnimations.Values.Any(tuple =>
     {
         var model = tuple.Item1 as GeneratedItemModel;
         return model != null && model.ItemInfo.Equals(info);
     }));
 }
        internal bool MoveCurrentToLast()
        {
            ItemInfo?lastItem = this.Owner.Model.FindLastDataItemInView();

            if (lastItem == null)
            {
                return(false);
            }

            this.ChangeCurrentItem(lastItem, true, true);
            return(object.ReferenceEquals(this.currentItem, lastItem.Value.Item));
        }
Exemple #6
0
        private bool MoveCurrentToLastOrFirst(bool isLast)
        {
            int      index    = isLast ? this.Owner.Model.ItemsCount - 1 : 0;
            ItemInfo?nextInfo = this.Owner.Model.FindDataItemFromIndex(index, null);

            if (nextInfo.HasValue)
            {
                return(this.MoveCurrentTo(nextInfo.Value.Item));
            }

            return(false);
        }
        internal bool ChangeCurrentItem(ItemInfo?info, bool cancelable, bool scrollToCurrent)
        {
            if (this.updatingCurrent)
            {
                return(false);
            }

            var newCurrent = info == null ? null : info.Value.Item;

            if (object.ReferenceEquals(this.currentItem, newCurrent))
            {
                return(true);
            }

            return(this.ChangeCurrentCore(newCurrent, info, cancelable, scrollToCurrent));
        }
        internal void OnDataViewChanged(ViewChangedEventArgs args)
        {
            if (this.currentItem == null)
            {
                return;
            }

            this.currentItemInfo = null;

            // TODO: Update the CurrentItem
            switch (args.Action)
            {
            case CollectionChange.ItemRemoved:
                break;
            }
        }
Exemple #9
0
        internal bool IsAnimating(ItemInfo?info)
        {
            var models = this.runningAnimations.Values.Where((tuple) =>
            {
                var model = tuple.Item1 as GeneratedItemModel;
                if (model != null && model.ItemInfo.Equals(info))
                {
                    return(true);
                }
                return(false);
            });

            if (models.Count() > 0)
            {
                return(true);
            }
            return(false);
        }
        private void RaiseCellPeerFocusChangedEvent(ItemInfo?info)
        {
            var dataGridPeer = FrameworkElementAutomationPeer.FromElement(this) as RadDataGridAutomationPeer;

            if (dataGridPeer != null && dataGridPeer.childrenCache != null)
            {
                if (dataGridPeer.childrenCache.Count == 0)
                {
                    dataGridPeer.GetChildren();
                }

                var cellPeer = dataGridPeer.childrenCache.FirstOrDefault(a => a.Row == info.Value.Slot && a.Column == 0) as DataGridCellInfoAutomationPeer;
                if (cellPeer != null && cellPeer.ChildTextBlockPeer != null)
                {
                    cellPeer.RaiseAutomationEvent(AutomationEvents.AutomationFocusChanged);
                }
            }
        }
        internal ItemInfo?FindPageUpOrDownDataItem(object pivotItem, bool pageDown)
        {
            if (!this.IsDataReady)
            {
                return(null);
            }

            int index             = 0;
            int viewportItemCount = this.RowPool.ViewportItemCount;
            var info = this.FindItemInfo(pivotItem);

            if (info != null)
            {
                index              = info.Value.LayoutInfo.Line;
                viewportItemCount -= this.rowLayout.GetCollapsedSlotsCount(0, index);
            }
            else
            {
                index = this.GetItemGroupIndex(pivotItem);
            }

            int      itemCount  = 0;
            var      enumerator = this.rowLayout.GetLines(index, pageDown).GetEnumerator();
            ItemInfo?result     = null;

            while (enumerator.MoveNext())
            {
                var lastItem = enumerator.Current.LastOrDefault();
                if (lastItem.ItemType == GroupType.BottomLevel)
                {
                    result = lastItem;
                }

                itemCount++;
                if (itemCount == viewportItemCount)
                {
                    break;
                }
            }

            return(result);
        }
        private ItemInfo?FindDataItemFromIndex(int index, bool next, object dataItem = null)
        {
            var      enumerator = this.rowLayout.GetLines(index, next).GetEnumerator();
            ItemInfo?info       = null;

            while (enumerator.MoveNext())
            {
                var lastItem = enumerator.Current.LastOrDefault();
                if (lastItem.ItemType == GroupType.BottomLevel)
                {
                    if (dataItem == null || object.ReferenceEquals(lastItem.Item, dataItem))
                    {
                        info = lastItem;
                        break;
                    }
                }
            }

            return(info);
        }
        private bool ChangeCurrentCore(object newCurrent, ItemInfo?info, bool cancelable, bool scrollToCurrent)
        {
            // Raise CurrentChanging first
            bool cancel = this.PreviewCancelCurrentChanging(cancelable);

            if (cancel)
            {
                // the change is canceled
                return(false);
            }

            var oldCurrent = this.currentItem;

            this.updatingCurrent = true;

            this.currentItem     = newCurrent;
            this.currentItemInfo = info;
            this.Owner.ChangePropertyInternally(RadDataGrid.CurrentItemProperty, this.currentItem);

            if (this.isSynchronizedWithCurrent)
            {
                this.Owner.SelectedItem = this.currentItem;
                if (this.itemsSourceAsCollectionView != null)
                {
                    this.itemsSourceAsCollectionView.MoveCurrentTo(this.currentItem);
                }
            }

            this.UpdateState(scrollToCurrent);

            if (!object.ReferenceEquals(oldCurrent, this.currentItem))
            {
                this.OnCurrentChanged(EventArgs.Empty);
            }

            this.updatingCurrent = false;

            return(true);
        }
        private void UpdateState(bool scrollToCurrent)
        {
            if (this.currentItem == null)
            {
                this.isCurrentInView = false;
                this.Owner.visualStateService.UpdateCurrentDecoration(-1);

                return;
            }

            this.Owner.updateService.RegisterUpdate(new DelegateUpdate <UpdateFlags>(() =>
            {
                if (this.currentItemInfo == null)
                {
                    this.currentItemInfo = this.Owner.Model.FindItemInfo(this.currentItem);
                }

                if (this.currentItemInfo == null)
                {
                    this.isCurrentInView = false;
                    this.Owner.visualStateService.UpdateCurrentDecoration(-1);
                }
                else
                {
                    this.Owner.Model.UpdateEditRow(this.currentItemInfo.Value.LayoutInfo.Line);
                    this.isCurrentInView = true;

                    if (scrollToCurrent)
                    {
                        this.ScrollToCurrent();
                    }
                    else
                    {
                        this.Owner.visualStateService.UpdateCurrentDecoration(this.currentItemInfo.Value.Slot);
                    }
                }
            }));
        }
Exemple #15
0
        private bool MoveCurrentToNextOrPrev(bool isNext)
        {
            int index;

            if (this.CurrentItemInfo == null)
            {
                // Current is set the item after (before) the focused one like in MS ListView.
                index = this.Owner.currentLogicalIndex;
            }
            else
            {
                index = this.CurrentItemInfo.Value.Slot;
            }

            int      increment = isNext ? 1 : -1;
            ItemInfo?nextInfo  = this.Owner.Model.FindDataItemFromIndex(index + increment, null);

            if (nextInfo.HasValue)
            {
                return(this.MoveCurrentTo(nextInfo.Value.Item));
            }

            return(false);
        }
Exemple #16
0
 private static bool DefaultBlockRightClickedHandler(World world, Coordinates3D coordinates, BlockInfo block, BlockFace face, ItemInfo?item)
 {
     return(true);
 }
Exemple #17
0
 public static bool RightClickBlock(this World world, Coordinates3D coordinates, BlockFace face, Coordinates3D cursor, ItemInfo?item)
 {
     return(Block.OnBlockRightClicked(world, coordinates, face, cursor, item));
 }
 internal void OnDataBindingComplete(bool scrollToCurrent)
 {
     // TODO:
     this.currentItemInfo = null;
     this.UpdateState(scrollToCurrent);
 }
        internal void HandleKeyDown(KeyRoutedEventArgs e)
        {
            if (e == null || e.Handled)
            {
                return;
            }

            // HACK: Workaround for WinRT issue with KeyDown raised twice for VirtualKey.Enter
            if (e.Key == VirtualKey.Enter && e.KeyStatus.RepeatCount > 0)
            {
                return;
            }

            ItemInfo?info = null;

            switch (e.Key)
            {
            case VirtualKey.Escape:
                if (this.editService.IsEditing)
                {
                    e.Handled = true;
                    this.CancelEdit(ActionTrigger.Keyboard, e.Key);
                }
                break;

            case VirtualKey.F2:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    this.BeginEdit(this.CurrentItem, ActionTrigger.Keyboard, e.Key);
                }
                break;

            case VirtualKey.Tab:
                break;

            case VirtualKey.Down:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPreviousOrNextDataItem(this.CurrentItem, true);
                }
                break;

            case VirtualKey.Up:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPreviousOrNextDataItem(this.CurrentItem, false);
                }
                break;

            case VirtualKey.PageDown:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPageUpOrDownDataItem(this.CurrentItem, true);
                }
                break;

            case VirtualKey.PageUp:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPageUpOrDownDataItem(this.CurrentItem, false);
                }
                break;

            case VirtualKey.Home:
                if (!this.editService.IsEditing && KeyboardHelper.IsModifierKeyDown(VirtualKey.Control))
                {
                    e.Handled = true;
                    info      = this.model.FindFirstDataItemInView();
                }
                break;

            case VirtualKey.End:
                if (!this.editService.IsEditing && KeyboardHelper.IsModifierKeyDown(VirtualKey.Control))
                {
                    e.Handled = true;
                    info      = this.model.FindLastDataItemInView();
                }
                break;

            case VirtualKey.Enter:
                e.Handled = true;
                if (this.editService.IsEditing)
                {
                    this.CommitEdit(new DataGridCellInfo(this.CurrentItem, null), ActionTrigger.Keyboard, e.Key);
                }
                else
                {
                    bool shiftPressed = KeyboardHelper.IsModifierKeyDown(VirtualKey.Shift);
                    info = this.model.FindPreviousOrNextDataItem(this.CurrentItem, !shiftPressed);
                }
                break;
            }

            if (info != null)
            {
                this.CurrencyService.ChangeCurrentItem(info.Value.Item, true, true);
            }
        }
        internal void HandleKeyDown(KeyRoutedEventArgs e)
        {
            if (e == null || e.Handled)
            {
                return;
            }

            ItemInfo?info = null;

            switch (e.Key)
            {
            case VirtualKey.Escape:
                if (this.editService.IsEditing)
                {
                    e.Handled = true;
                    this.CancelEdit(ActionTrigger.Keyboard, e.Key);
                }
                break;

            case VirtualKey.F2:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    this.BeginEdit(this.CurrentItem, ActionTrigger.Keyboard, e.Key);
                }
                break;

            case VirtualKey.Tab:
                if (e.OriginalSource is RadDataGrid)
                {
                    if (!this.editService.IsEditing)
                    {
                        e.Handled = true;
                        info      = this.CurrencyService.CurrentItemInfo == null?
                                    this.model.FindFirstDataItemInView()
                                        : this.CurrencyService.CurrentItemInfo;

#pragma warning disable CS4014
                        Dispatcher.RunAsync(
                            Windows.UI.Core.CoreDispatcherPriority.Low,
                            () =>
                        {
                            var xamlVisualStateLayer = this.visualStateLayerCache as XamlVisualStateLayer;
                            if (xamlVisualStateLayer != null)
                            {
                                var currencyVisual = xamlVisualStateLayer.CurrencyVisual as DataGridCurrencyControl;
                                if (currencyVisual != null && currencyVisual.Visibility == Visibility.Visible)
                                {
                                    currencyVisual.Focus(FocusState.Keyboard);
                                    this.RaiseCellPeerFocusChangedEvent(info);
                                }
                            }
                        });
#pragma warning restore CS4014
                    }
                }
                break;

            case VirtualKey.Down:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPreviousOrNextDataItem(this.CurrentItem, true);
                }
                break;

            case VirtualKey.Up:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPreviousOrNextDataItem(this.CurrentItem, false);
                }
                break;

            case VirtualKey.PageDown:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPageUpOrDownDataItem(this.CurrentItem, true);
                }
                break;

            case VirtualKey.PageUp:
                if (!this.editService.IsEditing)
                {
                    e.Handled = true;
                    info      = this.model.FindPageUpOrDownDataItem(this.CurrentItem, false);
                }
                break;

            case VirtualKey.Home:
                if (!this.editService.IsEditing && KeyboardHelper.IsModifierKeyDown(VirtualKey.Control))
                {
                    e.Handled = true;
                    info      = this.model.FindFirstDataItemInView();
                }
                break;

            case VirtualKey.End:
                if (!this.editService.IsEditing && KeyboardHelper.IsModifierKeyDown(VirtualKey.Control))
                {
                    e.Handled = true;
                    info      = this.model.FindLastDataItemInView();
                }
                break;

            case VirtualKey.Enter:
                e.Handled = true;
                if (this.editService.IsEditing)
                {
                    this.CommitEdit(new DataGridCellInfo(this.CurrentItem, null), ActionTrigger.Keyboard, e.Key);
                }
                else
                {
                    bool shiftPressed = KeyboardHelper.IsModifierKeyDown(VirtualKey.Shift);
                    info = this.model.FindPreviousOrNextDataItem(this.CurrentItem, !shiftPressed);
                }
                break;

            case VirtualKey.Space:
                if (e.OriginalSource is RadDataGrid)
                {
                    if (this.SelectionUnit == DataGridSelectionUnit.Row)
                    {
                        info = this.model.FindItemInfo(this.CurrentItem);
                        if (info != null)
                        {
                            var cell = this.model.CellsController.GetCellsForRow(info.Value.Slot).First();
                            if (cell != null)
                            {
                                this.OnCellTap(new DataGridCellInfo(cell));
                            }
                        }
                    }
                }
                break;
            }

            if (info != null)
            {
                this.CurrencyService.ChangeCurrentItem(info.Value.Item, true, true);

                if (e.Key != VirtualKey.Tab)
                {
                    this.RaiseCellPeerFocusChangedEvent(info);
                }
            }
        }
Exemple #21
0
        internal static bool OnBlockRightClicked(World world, Coordinates3D coordinates, BlockFace face, Coordinates3D cursor, ItemInfo?item)
        {
            var info = world.GetBlockInfo(coordinates);

            if (BlockRightClickedHandlers.ContainsKey(info.BlockId))
            {
                return(BlockRightClickedHandlers[info.BlockId](world, coordinates, info, face, cursor, item));
            }
            else
            {
                return(DefaultBlockRightClickedHandler(world, coordinates, info, face, item));
            }
        }