private void OnContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
 {
     if (args.InRecycleQueue)
     {
         ListViewItem lvi = (args.ItemContainer as ListViewItem);
         if (lvi != null)
         {
             UIElement element = VisualTreeHelper.GetChild(lvi, 0) as UIElement;
             if (element != null)
             {
                 element.PointerPressed -= OnPointerPressed;
                 element.PointerReleased -= OnPointerReleased;
                 element.PointerCaptureLost -= OnPointerCaptureLost;
                 element.PointerExited -= OnPointerExited;
             }
         }
     }
     else if (args.Phase == 0)
     {
         ListViewItem lvi = (args.ItemContainer as ListViewItem);
         if (null != lvi)
         {
             UIElement element = VisualTreeHelper.GetChild(lvi, 0) as UIElement;
             if (null != element)
             {
                 element.PointerPressed += OnPointerPressed;
                 element.PointerReleased += OnPointerReleased;
                 element.PointerCaptureLost += OnPointerCaptureLost;
                 element.PointerExited += OnPointerExited;
             }
         }
     }
 }

        public static void ScrollItem(ListViewBase control, int indexDelta)
        {
            if (control == null || control.Items == null)
                return;

            var scrollViewer = VisualTreeUtilities.GetVisualChild<ScrollViewer>(control);

            var p = new Point(Window.Current.Bounds.Width/2, 10);
            var transform = control.TransformToVisual(Window.Current.Content);
            var checkPoint = transform.TransformPoint(p);

            var q = from lvi in VisualTreeHelper.FindElementsInHostCoordinates(checkPoint, scrollViewer).OfType<ListViewItem>()
                where lvi.Content != null
                select lvi.Content;

            var item = q.FirstOrDefault();

            if (item == null)
                return;

            var index = control.Items.IndexOf(item);
            var nextItemIndex = index + indexDelta;
            if (index != -1 && nextItemIndex >= 0 && nextItemIndex < control.Items.Count)
            {
                var nextItem = control.Items[nextItemIndex];
                control.ScrollIntoView(nextItem, ScrollIntoViewAlignment.Leading);
            }
        }

        //SignoffStatus Grid Select Event : Load WorkFlowBar 
        private async void lvListSelectionChanged_Changed(object sender, ListViewBase e)
        {
            try
            {
                ucWorkFlowBanner.GridClear();
                IWPWorkflowStatusdto = (IWPWorkflowStatusBypersonnelid_type_term)e.SelectedItem;
                List<WorkflowDetailByIWPID> workflowbannerdto = new List<WorkflowDetailByIWPID>();
                await _Workflow.GetWorkflowDetailByProcessID(IWPWorkflowStatusdto.ProcessId);
                workflowbannerdto = _Workflow.GetWorkflowDetail();
                ucWorkFlowBanner.LoadWorkFlow(workflowbannerdto);

                Lib.WorkFlowDataSource.PackageTypeCode = IWPWorkflowStatusdto.PackageTypeCode;

                Lib.WorkFlowDataSource.selectedTypeName = IWPWorkflowStatusdto.PackageTypeName;
                Lib.WorkFlowDataSource.selectedDocumentID = IWPWorkflowStatusdto.TargetId;
                Lib.WorkFlowDataSource.selectedIwpID = IWPWorkflowStatusdto.IwpId;
                
                if (btnsentstatus != "")
                    Lib.WorkFlowDataSource.sentyn = btnsentstatus;
            }
            catch (Exception ex)
            {

            }
        }

 internal bool Phase0Load(ListViewBase sender, ContainerContentChangingEventArgs args)
 {
     if (!args.InRecycleQueue)
     {
         if (((CommentViewModel)args.Item).IsEditing)
         {
             var editContent = (Resources["editingTemplate"] as DataTemplate).LoadContent() as FrameworkElement;
             editContent.DataContext = ((CommentViewModel)DataContext).ReplyViewModel;
             contentControl.Content = editContent;
             contentControl.MinHeight = 0;
             return false;
         }
         else
         {
             contentControl.ContentTemplate = null;
             contentControl.Content = null;
             var body = ((CommentViewModel)args.Item).Body ?? "";
             contentControl.MinHeight = Math.Max(25, body.Length / 2);
             args.Handled = true;
             LoadPhase = 1;
             return true;
         }
     }
     return false;
 }

        /// <summary>
        /// We will visualize the data item in asynchronously in multiple phases for improved panning user experience 
        /// of large lists.  In this sample scneario, we will visualize different parts of the data item
        /// in the following order:
        /// 
        ///     1) Title and placeholder for Image (visualized synchronously - Phase 0)
        ///     2) Subtilte (visualized asynchronously - Phase 1)
        ///     3) Image (visualized asynchronously - Phase 2)
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        void ItemListView_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
        {
            Scenario2ItemViewer iv = args.ItemContainer.ContentTemplateRoot as Scenario2ItemViewer;

            if (args.InRecycleQueue == true)
            {
                iv.ClearData();
            }
            else if (args.Phase == 0)
            {
                iv.ShowTitle(args.Item as Item);

                // Register for async callback to visualize Title asynchronously
                args.RegisterUpdateCallback(ContainerContentChangingDelegate);
            }
            else if (args.Phase == 1)
            {
                iv.ShowSubtitle();
                args.RegisterUpdateCallback(ContainerContentChangingDelegate);
            }
            else if (args.Phase == 2)
            {
                iv.ShowImage();
            }

            // For imporved performance, set Handled to true since app is visualizing the data item
            args.Handled = true;
        }

        void ItemGridView_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
        {
            //ItemViewer iv = args.ItemContainer.ContentTemplateRoot as ItemViewer;

            //if (args.InRecycleQueue == true)
            //{
            //    iv.ClearData();
            //}
            //else if (args.Phase == 0)
            //{
            //    iv.ShowPlaceholder(args.Item as Item);

            //    // Register for async callback to visualize Title asynchronously
            //    args.RegisterUpdateCallback(ContainerContentChangingDelegate);
            //}
            //else if (args.Phase == 1)
            //{
            //    iv.ShowTitle();
            //    args.RegisterUpdateCallback(ContainerContentChangingDelegate);
            //}
            //else if (args.Phase == 2)
            //{
            //    iv.ShowCategory();
            //    iv.ShowImage();
            //}

            //// For imporved performance, set Handled to true since app is visualizing the data item
            //args.Handled = true;
        }

        /// <summary>
        /// We will visualize the data item in asynchronously in multiple phases for improved panning user experience 
        /// of large lists.  In this sample scneario, we will visualize different parts of the data item
        /// in the following order:
        /// 
        ///     1) Placeholders (visualized synchronously - Phase 0)
        ///     2) Labels (visualized asynchronously - Phase 1)
        ///     3) Values (visualized asynchronously - Phase 2)
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        void Items_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
        {
            TeamsDrillDownItem iv = args.ItemContainer.ContentTemplateRoot as TeamsDrillDownItem;

            if (args.InRecycleQueue == true)
            {
                iv.ClearData();
            }
            else if (args.Phase == 0)
            {
                iv.ShowPlaceholder(args.Item as TeamsDrillDownViewModel);

                // Register for async callback to visualize Title asynchronously
                args.RegisterUpdateCallback(ContainerContentChangingDelegate);
            }
            else if (args.Phase == 1)
            {
                iv.ShowLabels();
                args.RegisterUpdateCallback(ContainerContentChangingDelegate);
            }
            else if (args.Phase == 2)
            {
                iv.ShowValues();
                args.RegisterUpdateCallback(ContainerContentChangingDelegate);
            }

            // For improved performance, set Handled to true since app is visualizing the data item
            args.Handled = true;
        }

        private void ListView_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
        {
            CompositionImage image = args.ItemContainer.ContentTemplateRoot.GetFirstDescendantOfType<CompositionImage>();
            Thumbnail thumbnail = args.Item as Thumbnail;

            // Update the image URI
            image.Source = new Uri(thumbnail.ImageUrl);
        }

        private void OnContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
        {
            var visual = ElementCompositionPreview.GetElementVisual(args.ItemContainer);

            visual.ImplicitAnimations = args.InRecycleQueue
                ? null
                : animations;
        }

 private void messageList_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
 {
     if (args.ItemContainer.ContentTemplateRoot is MessageControl)
     {
         var message = args.ItemContainer.ContentTemplateRoot as MessageControl;
         message.DataContext = args.Item;
         message.PhaseLoad(sender, args);
     }
 }

		private static void ClearPreviousEvents(ListViewBase listView)
		{
			ItemClickEventHandler eventHandler;
			if (_eventHandlers.TryGetValue(listView, out eventHandler))
			{
				listView.ItemClick -= eventHandler;
				_eventHandlers.Remove(listView);
			}
		}

 private bool TrySelectItem(ListViewBase listView, Func<object, bool> predicator)
 {
     var item = listView.Items.FirstOrDefault(predicator);
     if (item != null)
     {
         listView.SelectedItem = item;
         return true;
     }
     return false;
 }

		private static void HandleItemClick(ListViewBase listView, object item)
		{
			var command = GetCommand(listView);

			if (command == null || !command.CanExecute(item))
			{
				return;
			}
			command.Execute(item);
		}

		/// <summary>
		/// Enable accessibility on each nav menu item by setting the AutomationProperties.Name on each container
		/// using the associated Label of each item.
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="args"></param>
		private void NavMenuItemContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
		{
			if (!args.InRecycleQueue && args.Item != null && args.Item is NavMenuItem)
			{
				args.ItemContainer.SetValue(AutomationProperties.NameProperty, ((NavMenuItem)args.Item).Label);
			}
			else
			{
				args.ItemContainer.ClearValue(AutomationProperties.NameProperty);
			}
		}

 private void OnContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
 {
     if (args.InRecycleQueue)
     {
         if (_index > _associatedObject.Items.Count - 1)
         {
             _index = _associatedObject.Items.Count - 1;
         }
         _associatedObject.SelectedIndex = _index;
     }
 }

        private static void ListViewContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
        {
            // We need to leave this as false, otherwise data binding will not work
            args.Handled = false;

            bool hasMore = PerformNextPhase(args);
            if (hasMore)
            {
                args.RegisterUpdateCallback(ListViewContainerContentChanging);
            }
        }

 private void Grid1_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
 {
     if (!args.InRecycleQueue)
     {
         FrameworkElement ctr = (FrameworkElement)args.ItemContainer.ContentTemplateRoot;
         if (ctr != null)
         {
             TextBlock t = (TextBlock)ctr.FindName("idx");
             t.Text = args.ItemIndex.ToString();
         }
     }
 }

 private void SampleTreeView_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
 {
     var node = args.Item as TreeNode;
     if (node != null)
     {
         var data = node.Data as FileSystemData;
         if (data != null)
         {
             args.ItemContainer.AllowDrop = data.IsFolder;
         }
     }
 }

 private void gridView_ContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
 {
     var elementVisual = ElementCompositionPreview.GetElementVisual(args.ItemContainer);
     if (args.InRecycleQueue)
     {
         elementVisual.ImplicitAnimations = null;
     }
     else
     {
         //Add implicit animation to each visual 
         elementVisual.ImplicitAnimations = _elementImplicitAnimation;
     }
 }

        private void Attach(ListViewBase listView, ObservableCollection<object> boundSelection)
        {
            _listView = listView;
            _listView.SelectionChanged += OnListViewSelectionChanged;
            _boundSelection = boundSelection;

            foreach (var item in _boundSelection.Where(item => !_listView.SelectedItems.Contains(item)))
            {
                _listView.SelectedItems.Add(item);
            }

            _boundSelection.CollectionChanged += OnBoundSelectionChanged;
        }