예제 #1
0
        protected override void OnManipulationCompleted(ManipulationCompletedRoutedEventArgs e)
        {
            LoopItemsPickerPanel itemsPanel = e.Container as LoopItemsPickerPanel;

            if (itemsPanel == null)
            {
                return;
            }

            PickerSelectorItem selectorItem = itemsPanel.GetMiddleItem();

            if (selectorItem == null)
            {
                return;
            }

            DateTimeWrapper dateTimeWrapper = selectorItem.DataContext as DateTimeWrapper;

            if (dateTimeWrapper == null)
            {
                return;
            }

            this.Value = dateTimeWrapper.DateTime;
        }
예제 #2
0
        /// <summary>
        /// Scroll to a selected index (with animation or not)
        /// </summary>
        internal void ScrollToSelectedIndex(PickerSelectorItem selectedItem, TimeSpan duration)
        {
            if (!templateApplied)
            {
                return;
            }

            var centerTopOffset = (this.ActualHeight / 2d) - (itemHeight) / 2d;

            var deltaOffset = centerTopOffset - selectedItem.GetVerticalPosition();

            if (Double.IsInfinity(deltaOffset) || Double.IsNaN(deltaOffset))
            {
                return;
            }

            if (duration == TimeSpan.Zero)
            {
                this.sliderVertical.Value += deltaOffset;
            }
            else
            {
                this.UpdatePositionsWithAnimationAsync(selectedItem, deltaOffset, duration);
            }
        }
예제 #3
0
        /// <summary>
        /// Maybe this method is Obsolet : TODO : Test obsoletence
        /// </summary>
        /// <param name="e"></param>
        protected override void OnManipulationCompleted(ManipulationCompletedRoutedEventArgs e)
        {
            PickerSelectorItem middleItem = this.itemsPanel.GetMiddleItem();

            if (middleItem == null)
            {
                return;
            }

            this.SelectedItem = middleItem.DataContext as DateTimeWrapper;

            base.OnManipulationCompleted(e);
        }
예제 #4
0
        /// <summary>
        /// When manipulation is completed, go to the closest item
        /// </summary>
        private void OnManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e)
        {
            PickerSelectorItem middleItem = GetMiddleItem();

            // get rect
            if (middleItem == null)
            {
                return;
            }

            // animate and scroll to
            this.ScrollToSelectedIndex(middleItem, animationDuration);
        }
예제 #5
0
        /// <summary>
        /// Translate items to a new offset
        /// </summary>
        private void UpdatePosition(Int32 startIndex, Int32 endIndex, Double offset)
        {
            for (Int32 i = startIndex; i < endIndex; i++)
            {
                PickerSelectorItem loopListItem = this.Children[i] as PickerSelectorItem;
                if (loopListItem == null)
                {
                    continue;
                }

                TranslateTransform translateTransform = loopListItem.GetTranslateTransform();

                translateTransform.Y = offset;
            }
        }
예제 #6
0
        /// <summary>
        /// Updating with an animation (after a tap)
        /// </summary>
        private void UpdatePositionsWithAnimationAsync(PickerSelectorItem selectedItem, Double delta, TimeSpan duration)
        {
            animationSnap.From           = selectedItem.GetTranslateTransform().Y;
            animationSnap.To             = selectedItem.GetTranslateTransform().Y + delta;
            animationSnap.Duration       = duration;
            animationSnap.EasingFunction = new ExponentialEase {
                EasingMode = EasingMode.EaseInOut
            };

            sliderVertical.ValueChanged -= OnVerticalOffsetChanged;
            sliderVertical.Value         = selectedItem.GetTranslateTransform().Y;
            sliderVertical.ValueChanged += OnVerticalOffsetChanged;

            this.storyboard.Completed += (sender, o) =>
            {
                if (SelectedItemChanged != null)
                {
                    SelectedItemChanged(this, selectedItem);
                }
            };

            this.storyboard.RunAsync();
        }
예제 #7
0
        /// <summary>
        /// Prepares the specified element to display the specified item.
        /// </summary>
        protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
        {
            if (DesignMode.DesignModeEnabled)
            {
                return;
            }

            itemsPanel = this.GetVisualDescendent <LoopItemsPickerPanel>();

            // get the item
            PickerSelectorItem loopListItem    = element as PickerSelectorItem;
            DateTimeWrapper    dateTimeWrapper = item as DateTimeWrapper;

            if (loopListItem == null || dateTimeWrapper == null)
            {
                return;
            }

            if (this.ItemTemplate == null)
            {
                return;
            }

            // load data templated
            var contentElement = this.ItemTemplate.LoadContent() as FrameworkElement;

            if (contentElement == null)
            {
                return;
            }
            // attach DataContext and Context to the item
            loopListItem.Style       = ItemContainerStyle;
            loopListItem.DataContext = item;
            loopListItem.Content     = contentElement;
            loopListItem.IsSelected  = dateTimeWrapper == this.SelectedItem;
            loopListItem.IsFocused   = this.IsFocused;
        }
예제 #8
0
        /// <summary>
        /// Update Items. Used for days
        /// </summary>
        internal void CreateOrUpdateItems(DateTime dateTime)
        {
            if (this.Items == null)
            {
                return;
            }

            DateTimeWrapper selectedDateTimeWrapper = null;
            int             newMax;
            DateTime        firstAvailableDate = GetFirstAvailable(dateTime, out newMax);

            // Make a copy without any minutes / seconds ...
            DateTimeWrapper newData =
                new DateTimeWrapper(new DateTime(firstAvailableDate.Year,
                                                 firstAvailableDate.Month,
                                                 firstAvailableDate.Day));

            // One item is deleted but was selected..
            // Don't forget to reactivate a selected item
            Boolean oneItemMustBeDeletedAndIsSelected = false;

            // If new month have less day than last month
            if (newMax < this.Items.Count)
            {
                int numberOfLastDaysToDelete = this.Items.Count - newMax;
                for (int cpt = 0; cpt < numberOfLastDaysToDelete; cpt++)
                {
                    PickerSelectorItem item =
                        this.ItemContainerGenerator.ContainerFromItem(this.Items[this.Items.Count - 1]) as PickerSelectorItem;

                    if (item == null)
                    {
                        continue;
                    }

                    if (item.IsSelected)
                    {
                        oneItemMustBeDeletedAndIsSelected = true;
                    }

                    this.Items.RemoveAt(this.Items.Count - 1);
                }
            }


            for (int i = 0; i < newMax; i++)
            {
                // -----------------------------------------------------------------------------
                // Add or Update Items
                // -----------------------------------------------------------------------------
                if (this.Items.Count <= i)
                {
                    this.Items.Add(newData);
                }
                else
                {
                    // Verify the item already exists
                    var itemDate = ((DateTimeWrapper)this.Items[i]).DateTime;

                    if (itemDate != newData.DateTime)
                    {
                        this.Items[i] = newData;
                    }
                }

                // -----------------------------------------------------------------------------
                // Get the good selected itm
                // -----------------------------------------------------------------------------
                if (newData.DateTime == dateTime)
                {
                    selectedDateTimeWrapper = newData;
                }

                // -----------------------------------------------------------------------------
                // Get the next data, relative to original wrapper, then relative to firstWrapper
                // -----------------------------------------------------------------------------
                DateTime?nextData = null;

                // Get nex date
                switch (this.DataSourceType)
                {
                case DataSourceType.Year:
                    nextData = this.YearDataSource.GetNext(dateTime, firstAvailableDate, i + 1);
                    break;

                case DataSourceType.Month:
                    nextData = this.MonthDataSource.GetNext(dateTime, firstAvailableDate, i + 1);
                    break;

                case DataSourceType.Day:
                    nextData = this.DayDataSource.GetNext(dateTime, firstAvailableDate, i + 1);
                    break;
                }
                if (nextData == null)
                {
                    break;
                }

                newData = nextData.Value.ToDateTimeWrapper();
            }

            // Set the correct Selected Item
            if (selectedDateTimeWrapper != null)
            {
                this.SelectedItem = selectedDateTimeWrapper;
            }
            else if (oneItemMustBeDeletedAndIsSelected) // When 31 was selected and we are on a Month < 31 days (February, April ...)
            {
                this.SelectedItem = (DateTimeWrapper)this.Items[this.Items.Count - 1];
            }
            else
            {
                this.SelectedItem = (DateTimeWrapper)this.Items[0];
            }
        }
예제 #9
0
        /// <summary>
        /// Arrange all items
        /// </summary>
        protected override Size ArrangeOverride(Size finalSize)
        {
            // Clip to ensure items dont override container
            this.Clip = new RectangleGeometry {
                Rect = new Rect(0, 0, finalSize.Width, finalSize.Height)
            };

            if (this.Children == null || this.Children.Count == 0)
            {
                var size   = base.ArrangeOverride(finalSize);
                var width  = double.IsInfinity(size.Width) ? 400 : size.Width;
                var height = double.IsInfinity(size.Height) ? 800 : size.Height;

                return(new Size(width, height));
            }

            Double             positionTop  = 0d;
            Double             positionLeft = 0d;
            PickerSelectorItem selectedItem = null;

            // Must Create looping items count
            foreach (PickerSelectorItem item in this.Children)
            {
                if (item == null)
                {
                    continue;
                }

                Size desiredSize = item.DesiredSize;

                if (double.IsNaN(desiredSize.Width) || double.IsNaN(desiredSize.Height))
                {
                    continue;
                }

                item.RectPosition = new Rect(positionLeft, positionTop, desiredSize.Width, desiredSize.Height);

                item.Arrange(item.RectPosition);

                if (item.IsSelected)
                {
                    selectedItem = item;
                }

                positionTop += desiredSize.Height;
            }

            templateApplied = true;

            if (selectedItem != null)
            {
                this.UpdatePositions(sliderVertical.Value);
                this.ScrollToSelectedIndex(selectedItem, TimeSpan.Zero);
                //if (!isFirstLayoutPassed)
                //{
                //    this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
                //                             () => this.ScrollToSelectedIndex(selectedItem, TimeSpan.Zero));
                //}
                //else
                //{
                //}
            }

            return(finalSize);
        }
        private static void IsSelectedChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
        {
            PickerSelectorItem pickerSelectorItem = (PickerSelectorItem)dependencyObject;

            pickerSelectorItem.ManageVisualStates();
        }