Пример #1
0
        public virtual void Drop(DropInfo dropInfo)
        {
            int insertIndex = dropInfo.InsertIndex;
            IList destinationList = GetList(dropInfo.TargetCollection);
            IEnumerable data = ExtractData(dropInfo.Data);

            if (dropInfo.DragInfo.VisualSource == dropInfo.VisualTarget)
            {
                IList sourceList = GetList(dropInfo.DragInfo.SourceCollection);

                foreach (object o in data)
                {
                    int index = sourceList.IndexOf(o);

                    if (index != -1)
                    {
                        sourceList.RemoveAt(index);
                        
                        if (sourceList == destinationList && index < insertIndex)
                        {
                            --insertIndex;
                        }
                    }
                }
            }

            foreach (object o in data)
            {
                destinationList.Insert(insertIndex++, o);
            }
        }
Пример #2
0
 public virtual void DragOver(DropInfo dropInfo)
 {
     if (CanAcceptData(dropInfo))
     {
         dropInfo.Effects = DragDropEffects.Copy;
         dropInfo.DropTargetAdorner = DropTargetAdorners.Insert;
     }
 }
		void IDropTarget.Drop(DropInfo dropInfo)
		{
			if (dropInfo.DragInfo == null)
				return;

			ListBox lbSource = dropInfo.DragInfo.VisualSource as ListBox;
			ListBox lbTarget = dropInfo.VisualTarget as ListBox;

			int insertIndex = dropInfo.InsertIndex;
			IList<CardViewModel> sourceList = null;
			IList<CardViewModel> destinationList = GetList(dropInfo.TargetCollection);
			IEnumerable<CardViewModel> data = ExtractData(dropInfo.Data);

			if (lbSource != null && lbTarget != null && lbSource.DataContext.GetType() == lbTarget.DataContext.GetType())
				sourceList = GetList(dropInfo.DragInfo.SourceCollection);

			if (this.PreserveSourceOrdering)
			{
				foreach (CardViewModel o in data)
				{
					sourceList.Remove(o);

					insertIndex = -1;
					if (destinationList.Count > 0)
						insertIndex = destinationList.Max(cvm => cvm.OriginalIndex < o.OriginalIndex ? destinationList.IndexOf(cvm) : -1);
					if (insertIndex == -1)
						destinationList.Insert(0, o);
					else if (insertIndex == destinationList.Count - 1)
						destinationList.Add(o);
					else
						destinationList.Insert(insertIndex + 1, o);
				}
			}
			else
			{
				if (sourceList != null)
				{
					foreach (CardViewModel o in data)
					{
						int index = sourceList.IndexOf(o);

						if (index != -1)
						{
							sourceList.RemoveAt(index);

							if (sourceList == destinationList && index < insertIndex)
							{
								--insertIndex;
							}
						}
					}
				}

				foreach (CardViewModel o in data)
					destinationList.Insert(insertIndex++, o);
			}
		}
Пример #4
0
 void IDropTarget.DragOver(DropInfo dropInfo)
 {
     if (dropInfo.Data is Class)
     {
         dropInfo.DropTargetAdorner = DropTargetAdorners.Insert;
         dropInfo.Effects = DragDropEffects.Move;
     }
     else if (dropInfo.Data is ClassContainer)
     {
         dropInfo.DropTargetAdorner = DropTargetAdorners.Insert;
         dropInfo.Effects = DragDropEffects.Copy;
     }
 }
		void IDropTarget.DragOver(DropInfo dropInfo)
		{
			CardViewModel sourceItem = dropInfo.Data as CardViewModel;
			CardViewModel targetItem = dropInfo.TargetItem as CardViewModel;

			if (sourceItem != null && (targetItem != null || dropInfo.TargetCollection != null))
			{
				dropInfo.Effects = DragDropEffects.Move;
				if (!this.PreserveSourceOrdering)
					dropInfo.DropTargetAdorner = DropTargetAdorners.Insert;
			}
			if (targetItem == null)
			{
			}
		}
Пример #6
0
 protected static bool CanAcceptData(DropInfo dropInfo)
 {
     if (dropInfo.DragInfo.SourceCollection == dropInfo.TargetCollection)
     {
         return GetList(dropInfo.TargetCollection) != null;
     }
     else if (dropInfo.DragInfo.SourceCollection is ItemCollection)
     {
         return false;
     }
     else
     {
         if (TestCompatibleTypes(dropInfo.TargetCollection, dropInfo.Data))
         {
             return !IsChildOf(dropInfo.VisualTargetItem, dropInfo.DragInfo.VisualSourceItem);
         }
         else
         {
             return false;
         }
     }
 }
Пример #7
0
        public void Drop(DropInfo dropInfo)
        {
            /*if (dropInfo.Data is MediaItemViewModel && dropInfo.TargetItem is MediaItemViewModel)
            {
                System.Windows.MessageBox.Show(dropInfo.DragInfo.
            }*/

            int insertIndex = dropInfo.InsertIndex;

            IList destinationList = GetList(dropInfo.TargetCollection);
            IEnumerable data = ExtractData(dropInfo.Data);

            if (dropInfo.DragInfo.VisualSource == dropInfo.VisualTarget)
            {
                IList sourceList = GetList(dropInfo.DragInfo.SourceCollection);

                foreach (object o in data)
                {
                    int index = sourceList.IndexOf(o);

                    if (index != -1)
                    {
                        sourceList.RemoveAt(index);

                        if (sourceList == destinationList && index < insertIndex)
                        {
                            --insertIndex;
                        }
                    }
                }
            }

            foreach (object o in data)
            {
                destinationList.Insert(insertIndex++, o);
            }
        }
Пример #8
0
        private static void DropTarget_PreviewDragOver(object sender, DragEventArgs e)
        {
            var dropInfo = new DropInfo(sender, e, m_DragInfo);
            var dropHandler = GetDropHandler((UIElement)sender);
            var itemsControl = sender as ItemsControl;

            if (dropHandler != null)
            {
                dropHandler.DragOver(dropInfo);
            }
            else
            {
                DefaultDropHandler.DragOver(dropInfo);
            }

            // Update the drag adorner.
            if (dropInfo.Effects != DragDropEffects.None)
            {
                if (DragAdorner == null && m_DragInfo != null)
                {
                    CreateDragAdorner();
                }

                if (DragAdorner != null)
                {
                    DragAdorner.MousePosition = e.GetPosition(DragAdorner.AdornedElement);
                    DragAdorner.InvalidateVisual();
                }
            }
            else
            {
                DragAdorner = null;
            }

            // If the target is an ItemsControl then update the drop target adorner.
            if (itemsControl != null)
            {
                // Display the adorner in the control's ItemsPresenter. If there is no
                // ItemsPresenter provided by the style, try getting hold of a
                // ScrollContentPresenter and using that.
                var adornedElement =
                    (UIElement)itemsControl.GetVisualDescendent<ItemsPresenter>() ??
                    (UIElement)itemsControl.GetVisualDescendent<ScrollContentPresenter>();

                if (adornedElement != null)
                {
                    if (dropInfo.DropTargetAdorner == null)
                    {
                        DropTargetAdorner = null;
                    }
                    else if (!dropInfo.DropTargetAdorner.IsInstanceOfType(DropTargetAdorner))
                    {
                        DropTargetAdorner = DropTargetAdorner.Create(dropInfo.DropTargetAdorner, adornedElement);
                    }

                    if (DropTargetAdorner != null)
                    {
                        DropTargetAdorner.DropInfo = dropInfo;
                        DropTargetAdorner.InvalidateVisual();
                    }
                }
            }

            e.Effects = dropInfo.Effects;
            e.Handled = true;

            Scroll((DependencyObject)sender, e);
        }
Пример #9
0
        public new void Drop(DropInfo dropInfo)
        {
            var from = paths.IndexOf(dropInfo.Data as string);
            var to = dropInfo.InsertIndex;

            SaveHistory();
            var dataObject = dropInfo.Data as DataObject;
            if (from < 0 && dataObject != null)
            {
                // External drag and drop
                var droppedFilePaths = dataObject.GetData(DataFormats.FileDrop, true) as string[];
                if (droppedFilePaths != null)
                {
                    var dirs = droppedFilePaths.Where(f => Directory.Exists(f));
                    foreach (var dir in dirs)
                    {
                        paths.Insert(to, dir);
                        to++;
                    }
                }
            }
            else
            {
                if (from < to)
                {
                    to--;
                }

                paths.Move(from, to);
            }
            SavePath();
        }
Пример #10
0
        void GongSolutions.Wpf.DragDrop.IDropTarget.Drop(DropInfo dropInfo)
        {
            PlaylistItemType itemType = PlaylistItemType.AnimeSeries;
            int objIDOld = -1;

            PlaylistItemVM pli = dropInfo.Data as PlaylistItemVM;
            if (pli == null) return;

            if (pli.ItemType == PlaylistItemType.Episode)
            {
                AnimeEpisodeVM ep = (AnimeEpisodeVM)pli.PlaylistItem;
                itemType = PlaylistItemType.Episode;
                objIDOld = ep.AnimeEpisodeID;
            }
            if (pli.ItemType == PlaylistItemType.AnimeSeries)
            {
                AnimeSeriesVM ep = (AnimeSeriesVM)pli.PlaylistItem;
                itemType = PlaylistItemType.AnimeSeries;
                objIDOld = ep.AnimeSeriesID.Value;
            }

            int iType = (int)itemType;

            // find where this item was previously

            if (string.IsNullOrEmpty(this.PlaylistItems)) return;

            string[] items = this.PlaylistItems.Split('|');

            // create a new list without the moved item
            string newItemList = "";
            foreach (string pitem in items)
            {
                string[] parms = pitem.Split(';');
                if (parms.Length != 2) continue;

                int objType = -1;
                int objID = -1;

                if (!int.TryParse(parms[0], out objType)) continue;
                if (!int.TryParse(parms[1], out objID)) continue;

                if (objType == iType && objID == objIDOld)
                {
                    // skip the old item
                }
                else
                {
                    if (newItemList.Length > 0) newItemList += "|";
                    newItemList += string.Format("{0};{1}", objType, objID);
                }
            }

            // insert the moved item into it's new position
            items = newItemList.Split('|');

            this.PlaylistItems = "";
            int curPos = 0;

            if (string.IsNullOrEmpty(newItemList))
            {
                // means there was only one item in list to begin with
                PlaylistItems += string.Format("{0};{1}", iType, objIDOld);
            }
            else
            {
                foreach (string pitem in items)
                {
                    string[] parms = pitem.Split(';');
                    if (parms.Length != 2) continue;

                    int objType = -1;
                    int objID = -1;

                    int.TryParse(parms[0], out objType);
                    int.TryParse(parms[1], out objID);

                    if (curPos == dropInfo.InsertIndex)
                    {
                        // insert moved item
                        if (PlaylistItems.Length > 0) PlaylistItems += "|";
                        PlaylistItems += string.Format("{0};{1}", iType, objIDOld);
                    }

                    if (PlaylistItems.Length > 0) PlaylistItems += "|";
                    PlaylistItems += string.Format("{0};{1}", objType, objID);

                    curPos++;
                }
            }

            // moved to the end of the list
            if (dropInfo.InsertIndex > items.Length)
            {
                if (PlaylistItems.Length > 0) PlaylistItems += "|";
                PlaylistItems += string.Format("{0};{1}", iType, objIDOld);
            }

            Save();
            PopulatePlaylistObjects();

            PlaylistHelperVM.Instance.OnPlaylistModified(new PlaylistModifiedEventArgs(PlaylistID));
        }
Пример #11
0
        static void DropTarget_PreviewDragOver(object sender, DragEventArgs e)
        {
            DropInfo dropInfo = new DropInfo(sender, e, m_DragInfo, m_Format.Name);
            IDropTarget dropHandler = GetDropHandler((UIElement)sender);

            if (dropHandler != null)
            {
                dropHandler.DragOver(dropInfo);
            }
            else
            {
                DefaultDropHandler.DragOver(dropInfo);
            }

            // Update the drag adorner.
            if (dropInfo.Effects != DragDropEffects.None)
            {
                if (DragAdorner == null && m_DragInfo != null)
                {
                    CreateDragAdorner();
                }

                if (DragAdorner != null)
                {
                    DragAdorner.MousePosition = e.GetPosition(DragAdorner.AdornedElement);
                    DragAdorner.InvalidateVisual();
                }
            }
            else
            {
                DragAdorner = null;
            }

            // If the target is an ItemsControl then update the drop target adorner.
            if (sender is ItemsControl)
            {
                UIElement adornedElement = ((ItemsControl)sender).GetVisualDescendent<ItemsPresenter>();

                if (dropInfo.DropTargetAdorner == null)
                {
                    DropTargetAdorner = null;
                }
                else if (!dropInfo.DropTargetAdorner.IsInstanceOfType(DropTargetAdorner))
                {
                    DropTargetAdorner = DropTargetAdorner.Create(dropInfo.DropTargetAdorner, adornedElement);
                }

                if (DropTargetAdorner != null)
                {
                    DropTargetAdorner.DropInfo = dropInfo;
                    DropTargetAdorner.InvalidateVisual();
                }
            }

            e.Effects = dropInfo.Effects;
            e.Handled = true;

            Scroll((DependencyObject)sender, e);
        }
Пример #12
0
		/// <summary>
		/// Gets the drop handler from the drop info or from the sender, if the drop info is null
		/// </summary>
		/// <param name="dropInfo">the drop info object</param>
		/// <param name="sender">the sender from an event, e.g. drag over</param>
		/// <returns></returns>
		private static IDropTarget TryGetDropHandler(DropInfo dropInfo, UIElement sender)
		{
			IDropTarget dropHandler = null;
			if (dropInfo != null && dropInfo.VisualTarget != null)
			{
				dropHandler = GetDropHandler(dropInfo.VisualTarget);
			}
			if (dropHandler == null && sender != null)
			{
				dropHandler = GetDropHandler(sender);
			}
			return dropHandler ?? DefaultDropHandler;
		}
Пример #13
0
        private static void DropTarget_PreviewDragOver(object sender, DragEventArgs e)
        {
            var elementPosition = e.GetPosition((IInputElement)sender);

            if (HitTestUtilities.HitTest4Type <ScrollBar>(sender, elementPosition) ||
                HitTestUtilities.HitTest4GridViewColumnHeader(sender, elementPosition) ||
                HitTestUtilities.HitTest4DataGridTypesOnDragOver(sender, elementPosition))
            {
                e.Effects = DragDropEffects.None;
                e.Handled = true;
                return;
            }

            var dropInfo     = new DropInfo(sender, e, m_DragInfo);
            var dropHandler  = TryGetDropHandler(dropInfo, sender as UIElement);
            var itemsControl = dropInfo.VisualTarget;

            dropHandler.DragOver(dropInfo);

            if (DragAdorner == null && m_DragInfo != null)
            {
                CreateDragAdorner();
            }

            if (DragAdorner != null)
            {
                var tempAdornerPos = e.GetPosition(DragAdorner.AdornedElement);

                if (tempAdornerPos.X >= 0 && tempAdornerPos.Y >= 0)
                {
                    _adornerPos = tempAdornerPos;
                }

                // Fixed the flickering adorner - Size changes to zero 'randomly'...?
                if (DragAdorner.RenderSize.Width > 0 && DragAdorner.RenderSize.Height > 0)
                {
                    _adornerSize = DragAdorner.RenderSize;
                }

                if (m_DragInfo != null)
                {
                    // move the adorner
                    var offsetX = _adornerSize.Width * -GetDragMouseAnchorPoint(m_DragInfo.VisualSource).X;
                    var offsetY = _adornerSize.Height * -GetDragMouseAnchorPoint(m_DragInfo.VisualSource).Y;
                    _adornerPos.Offset(offsetX, offsetY);
                    var maxAdornerPosX   = DragAdorner.AdornedElement.RenderSize.Width;
                    var adornerPosRightX = (_adornerPos.X + _adornerSize.Width);
                    if (adornerPosRightX > maxAdornerPosX)
                    {
                        _adornerPos.Offset(-adornerPosRightX + maxAdornerPosX, 0);
                    }
                    if (_adornerPos.Y < 0)
                    {
                        _adornerPos.Y = 0;
                    }
                }

                DragAdorner.MousePosition = _adornerPos;
                DragAdorner.InvalidateVisual();
            }

            // If the target is an ItemsControl then update the drop target adorner.
            if (itemsControl != null)
            {
                // Display the adorner in the control's ItemsPresenter. If there is no
                // ItemsPresenter provided by the style, try getting hold of a
                // ScrollContentPresenter and using that.
                var adornedElement =
                    itemsControl is TabControl
            ? itemsControl.GetVisualDescendent <TabPanel>()
            : (itemsControl.GetVisualDescendent <ItemsPresenter>() ?? itemsControl.GetVisualDescendent <ScrollContentPresenter>() as UIElement ?? itemsControl);

                if (adornedElement != null)
                {
                    if (dropInfo.DropTargetAdorner == null)
                    {
                        DropTargetAdorner = null;
                    }
                    else if (!dropInfo.DropTargetAdorner.IsInstanceOfType(DropTargetAdorner))
                    {
                        DropTargetAdorner = DropTargetAdorner.Create(dropInfo.DropTargetAdorner, adornedElement);
                    }

                    if (DropTargetAdorner != null)
                    {
                        DropTargetAdorner.DropInfo = dropInfo;
                        DropTargetAdorner.InvalidateVisual();
                    }
                }
            }

            // Set the drag effect adorner if there is one
            if (m_DragInfo != null && (EffectAdorner == null || EffectAdorner.Effects != dropInfo.Effects))
            {
                CreateEffectAdorner(dropInfo);
            }

            if (EffectAdorner != null)
            {
                var adornerPos = e.GetPosition(EffectAdorner.AdornedElement);
                adornerPos.Offset(20, 20);
                EffectAdorner.MousePosition = adornerPos;
                EffectAdorner.InvalidateVisual();
            }

            e.Effects = dropInfo.Effects;
            e.Handled = !dropInfo.NotHandled;

            if (!dropInfo.IsSameDragDropContextAsSource)
            {
                e.Effects = DragDropEffects.None;
            }


            if (_canScroll)
            {
                _canScroll = false;
                Scroll(dropInfo.VisualTarget, e);
                var interval = GetScrollDelay(m_DragInfo.VisualSource);
                if (interval > 0)
                {
                    _canScrollDelayTimer.Interval = interval;
                    _canScrollDelayTimer.Start();
                }
                else
                {
                    _canScroll = true;
                }
            }
        }
Пример #14
0
        public void Drop(DropInfo dropInfo)
        {
            MultiTouchInkCanvas target = dropInfo.VisualTarget as MultiTouchInkCanvas;
            DataObject data = dropInfo.Data as DataObject;
            TablectionSketch.Slide.Slide silde = this.SelectedSlide as TablectionSketch.Slide.Slide;
            if (target != null && data != null && silde != null)
            {
                System.Collections.Specialized.StringCollection fileNames = data.GetFileDropList();
                foreach (var item in fileNames)
                {
                    BitmapImage bmp = new BitmapImage(new Uri(item));
                    bmp.CacheOption = BitmapCacheOption.OnDemand;

                    Image img = new Image() { Source = bmp };

                    Point pt = System.Windows.Input.Mouse.GetPosition(target);
                    TablectionSketch.Data.TouchableItem tobj = new TablectionSketch.Data.TouchableItem(this.SelectedSlide) { X = pt.X - (bmp.PixelWidth >> 1), Y = pt.Y - (bmp.PixelHeight >> 1),  Width = bmp.PixelWidth, Height = bmp.PixelHeight, Child = img };
                    silde.Objects.Add(tobj);
                }
            }
        }
Пример #15
0
 public void DragOut(DropInfo dropInfo)
 {
     throw new NotImplementedException();
 }
Пример #16
0
 public void PauseOver(DropInfo dropInfo)
 {
     throw new NotImplementedException();
 }
Пример #17
0
 public WndPopup(DropInfo dropInfo, TreeViewDropHandler dropTarget)
 {
     InitializeComponent();
     this.dropInfo = dropInfo;
     this.dropHandler = dropTarget;
 }
Пример #18
0
        private static void DropTargetOnDragOver(object sender, DragEventArgs e, EventType eventType)
        {
            var elementPosition = e.GetPosition((IInputElement)sender);

            var dragInfo     = m_DragInfo;
            var dropInfo     = new DropInfo(sender, e, dragInfo, eventType);
            var dropHandler  = TryGetDropHandler(dropInfo, sender as UIElement);
            var itemsControl = dropInfo.VisualTarget;

            dropHandler.DragOver(dropInfo);

            if (DragAdorner == null && dragInfo != null)
            {
                CreateDragAdorner(dropInfo);
            }

            DragAdorner?.Move(e.GetPosition(DragAdorner.AdornedElement), dragInfo != null ? GetDragMouseAnchorPoint(dragInfo.VisualSource) : default(Point), ref _adornerMousePosition, ref _adornerSize);

            Scroll(dropInfo, e);

            if (HitTestUtilities.HitTest4Type <ScrollBar>(sender, elementPosition) ||
                HitTestUtilities.HitTest4GridViewColumnHeader(sender, elementPosition) ||
                HitTestUtilities.HitTest4DataGridTypesOnDragOver(sender, elementPosition))
            {
                e.Effects = DragDropEffects.None;
                e.Handled = true;
                return;
            }

            // If the target is an ItemsControl then update the drop target adorner.
            if (itemsControl != null)
            {
                // Display the adorner in the control's ItemsPresenter. If there is no
                // ItemsPresenter provided by the style, try getting hold of a
                // ScrollContentPresenter and using that.
                UIElement adornedElement = null;
                if (itemsControl is TabControl)
                {
                    adornedElement = itemsControl.GetVisualDescendent <TabPanel>();
                }
                else if (itemsControl is DataGrid || (itemsControl as ListView)?.View is GridView)
                {
                    adornedElement = itemsControl.GetVisualDescendent <ScrollContentPresenter>() as UIElement ?? itemsControl.GetVisualDescendent <ItemsPresenter>() as UIElement ?? itemsControl;
                }
                else
                {
                    adornedElement = itemsControl.GetVisualDescendent <ItemsPresenter>() as UIElement ?? itemsControl.GetVisualDescendent <ScrollContentPresenter>() as UIElement ?? itemsControl;
                }

                if (adornedElement != null)
                {
                    if (dropInfo.DropTargetAdorner == null)
                    {
                        DropTargetAdorner = null;
                    }
                    else if (!dropInfo.DropTargetAdorner.IsInstanceOfType(DropTargetAdorner))
                    {
                        DropTargetAdorner = DropTargetAdorner.Create(dropInfo.DropTargetAdorner, adornedElement, dropInfo);
                    }

                    var adorner = DropTargetAdorner;
                    if (adorner != null)
                    {
                        var adornerBrush = GetDropTargetAdornerBrush(dropInfo.VisualTarget);
                        if (adornerBrush != null)
                        {
                            adorner.Pen.Brush = adornerBrush;
                        }
                        adorner.DropInfo = dropInfo;
                        adorner.InvalidateVisual();
                    }
                }
            }

            // Set the drag effect adorner if there is one
            if (dragInfo != null && (EffectAdorner == null || EffectAdorner.Effects != dropInfo.Effects))
            {
                CreateEffectAdorner(dropInfo);
            }

            EffectAdorner?.Move(e.GetPosition(EffectAdorner.AdornedElement), default(Point), ref _effectAdornerMousePosition, ref _effectAdornerSize);

            e.Effects = dropInfo.Effects;
            e.Handled = !dropInfo.NotHandled;

            if (!dropInfo.IsSameDragDropContextAsSource)
            {
                e.Effects = DragDropEffects.None;
            }
        }
Пример #19
0
 static void DropTarget_PreviewDragLeave(object sender, DragEventArgs e)
 {
     IDropTarget dropHandler = GetDropHandler((UIElement)sender);
      DropInfo dropInfo = new DropInfo(sender, e, m_DragInfo, m_Format.Name);
     if (dropHandler != null)
     {
         dropHandler.DragOut(dropInfo);
     }
     DragAdorner = null;
     DropTargetAdorner = null;
 }
Пример #20
0
        static void DropTarget_PreviewDragOver(object sender, DragEventArgs e)
        {
            DropInfo     dropInfo       = new DropInfo(sender, e, m_DragInfo);
            IDropTarget  dropHandler    = GetDropHandler((UIElement)sender);
            double       adornerOpacity = GetAdornerOpacity((UIElement)sender);
            ItemsControl itemsControl   = sender as ItemsControl;

            if (dropHandler != null)
            {
                dropHandler.DragOver(dropInfo);
            }
            else
            {
                DefaultDropHandler.DragOver(dropInfo);
            }

            // Update the drag adorner.
            //if (dropInfo.Effects != DragDropEffects.None)
            //{
            //    if (DragAdorner == null && m_DragInfo != null)
            //    {
            //        CreateDragAdorner();
            //    }

            //    if (DragAdorner != null)
            //    {
            //        DragAdorner.MousePosition = e.GetPosition(DragAdorner.AdornedElement);
            //        DragAdorner.InvalidateVisual();
            //    }
            //}
            //else
            //{
            //    DragAdorner = null;
            //}

            if (DragAdorner == null && m_DragInfo != null)
            {
                CreateDragAdorner(adornerOpacity);
            }

            if (DragAdorner != null)
            {
                DragAdorner.MousePosition = e.GetPosition(DragAdorner.AdornedElement);
                DragAdorner.InvalidateVisual();
            }

            // If the target is an ItemsControl then update the drop target adorner.
            if (itemsControl != null)
            {
                // Display the adorner in the control's ItemsPresenter. If there is no
                // ItemsPresenter provided by the style, try getting hold of a
                // ScrollContentPresenter and using that.
                UIElement adornedElement =
                    (UIElement)itemsControl.GetVisualDescendent <ItemsPresenter>() ??
                    (UIElement)itemsControl.GetVisualDescendent <ScrollContentPresenter>();

                if (adornedElement != null)
                {
                    if (dropInfo.DropTargetAdorner == null)
                    {
                        DropTargetAdorner = null;
                    }
                    else if (!dropInfo.DropTargetAdorner.IsInstanceOfType(DropTargetAdorner))
                    {
                        DropTargetAdorner = DropTargetAdorner.Create(dropInfo.DropTargetAdorner, adornedElement);
                    }

                    if (DropTargetAdorner != null)
                    {
                        DropTargetAdorner.DropInfo = dropInfo;
                        DropTargetAdorner.InvalidateVisual();
                    }
                }
            }

            e.Effects = dropInfo.Effects;
            e.Handled = true;

            Scroll((DependencyObject)sender, e);
        }
Пример #21
0
        void GongSolutions.Wpf.DragDrop.IDropTarget.DragOver(DropInfo dropInfo)
        {
            PlaylistItemVM sourceItem = dropInfo.Data as PlaylistItemVM;
            PlaylistItemVM targetItem = dropInfo.TargetItem as PlaylistItemVM;

            if (sourceItem != null && targetItem != null)
            {
                dropInfo.DropTargetAdorner = DropTargetAdorners.Insert;
                dropInfo.Effects = DragDropEffects.Copy;
            }
        }
Пример #22
0
        private static void DropTarget_PreviewDrop(object sender, DragEventArgs e)
        {
            var dropInfo = new DropInfo(sender, e, m_DragInfo);
            var dropHandler = GetDropHandler((UIElement)sender) ?? DefaultDropHandler;
            var dragHandler = GetDragHandler((UIElement)sender) ?? DefaultDragHandler;

            DragAdorner = null;
            DropTargetAdorner = null;
            dropHandler.Drop(dropInfo);
            dragHandler.Dropped(dropInfo);
            e.Handled = true;
        }
Пример #23
0
 public void DragOut(DropInfo dropInfo)
 {
     throw new NotImplementedException();
 }
Пример #24
0
    private static void CreateEffectAdorner(DropInfo dropInfo)
    {
      var template = GetEffectAdornerTemplate(m_DragInfo.VisualSource, dropInfo.Effects, dropInfo.DestinationText);

      if (template != null) {
        var rootElement = RootElementFinder.FindRoot(m_DragInfo.VisualSource);
        UIElement adornment = null;

        var contentPresenter = new ContentPresenter();
        contentPresenter.Content = m_DragInfo.Data;
        contentPresenter.ContentTemplate = template;

        adornment = contentPresenter;

        EffectAdorner = new DragAdorner(rootElement, adornment, dropInfo.Effects);
      }
    }
 void IDropTarget.Drop(DropInfo dropInfo)
 {
         if (dropInfo.Data is Class)
         {
             var daydrop = (Class)dropInfo.Data;
             var source = ((IList)dropInfo.DragInfo.SourceCollection);
             var target = ((IList)dropInfo.TargetCollection);
             int indexmodifier = 0;
             if ((source.IndexOf(daydrop) < dropInfo.InsertIndex) && (dropInfo.TargetCollection == dropInfo.DragInfo.SourceCollection)) indexmodifier = -1;
             source.Remove(daydrop);
             if (target.Count > 0)
             {
                 target.Insert(dropInfo.InsertIndex + indexmodifier, daydrop);
             }
             else
             {
                 target.Add((Class)daydrop);
             }
         }
         else if (dropInfo.Data is ClassContainer)
         {
             var daydrop = (ClassContainer)dropInfo.Data;
             var target = ((IList)dropInfo.TargetCollection);
             if (target.Count > 0)
             {
                 target.Insert(dropInfo.InsertIndex, daydrop.GetClass());
             }
             else
             {
                 target.Add(daydrop.GetClass());
             }
         }
         EvaluateConstraints();
 }
Пример #26
0
 public DataContainer(MainWindow wnd, string btnidentifier, DropInfo dropInfo)
 {
     MainWindow = wnd;
     btnId = btnidentifier;
     DropInfo = dropInfo;
 }
Пример #27
0
        private static void DropTarget_PreviewDragOver(object sender, DragEventArgs e)
        {
            var elementPosition = e.GetPosition((IInputElement)sender);
              if (HitTestUtilities.HitTest4Type<ScrollBar>(sender, elementPosition)
              || HitTestUtilities.HitTest4GridViewColumnHeader(sender, elementPosition)
              || HitTestUtilities.HitTest4DataGridTypesOnDragOver(sender, elementPosition)) {
            e.Effects = DragDropEffects.None;
            e.Handled = true;
            return;
              }

              var dropInfo = new DropInfo(sender, e, m_DragInfo);
              var dropHandler = GetDropHandler((UIElement)sender) ?? DefaultDropHandler;
              var itemsControl = dropInfo.VisualTarget;

              dropHandler.DragOver(dropInfo);

              if (DragAdorner == null && m_DragInfo != null) {
            CreateDragAdorner();
              }

              if (DragAdorner != null) {
            var tempAdornerPos = e.GetPosition(DragAdorner.AdornedElement);

            if (tempAdornerPos.X > 0 && tempAdornerPos.Y > 0) {
              _adornerPos = tempAdornerPos;
            }

            // Fixed the flickering adorner - Size changes to zero 'randomly'...?
            if (DragAdorner.RenderSize.Width > 0 && DragAdorner.RenderSize.Height > 0) {
              _adornerSize = DragAdorner.RenderSize;
            }

            if (m_DragInfo != null) {
              // move the adorner
              var offsetX = _adornerSize.Width * -GetDragMouseAnchorPoint(m_DragInfo.VisualSource).X;
              var offsetY = _adornerSize.Height * -GetDragMouseAnchorPoint(m_DragInfo.VisualSource).Y;
              _adornerPos.Offset(offsetX, offsetY);
              var maxAdornerPosX = DragAdorner.AdornedElement.RenderSize.Width;
              var adornerPosRightX = (_adornerPos.X + _adornerSize.Width);
              if (adornerPosRightX > maxAdornerPosX) {
            _adornerPos.Offset(-adornerPosRightX + maxAdornerPosX, 0);
              }
            }

            DragAdorner.MousePosition = _adornerPos;
            DragAdorner.InvalidateVisual();
              }

              // If the target is an ItemsControl then update the drop target adorner.
              if (itemsControl != null) {
            // Display the adorner in the control's ItemsPresenter. If there is no
            // ItemsPresenter provided by the style, try getting hold of a
            // ScrollContentPresenter and using that.
            var adornedElement =
              (UIElement)itemsControl.GetVisualDescendent<ItemsPresenter>() ??
              (UIElement)itemsControl.GetVisualDescendent<ScrollContentPresenter>();

            if (adornedElement != null) {
              if (dropInfo.DropTargetAdorner == null) {
            DropTargetAdorner = null;
              } else if (!dropInfo.DropTargetAdorner.IsInstanceOfType(DropTargetAdorner)) {
            DropTargetAdorner = DropTargetAdorner.Create(dropInfo.DropTargetAdorner, adornedElement);
              }

              if (DropTargetAdorner != null) {
            DropTargetAdorner.DropInfo = dropInfo;
            DropTargetAdorner.InvalidateVisual();
              }
            }
              }

              // Set the drag effect adorner if there is one
              if (EffectAdorner == null && m_DragInfo != null) {
            CreateEffectAdorner(dropInfo);
              }

              if (EffectAdorner != null) {
            var adornerPos = e.GetPosition(EffectAdorner.AdornedElement);
            adornerPos.Offset(20, 20);
            EffectAdorner.MousePosition = adornerPos;
            EffectAdorner.InvalidateVisual();
              }

              e.Effects = dropInfo.Effects;
              e.Handled = !dropInfo.NotHandled;

              Scroll((DependencyObject)dropInfo.VisualTarget, e);
        }
Пример #28
0
 public void DragOver(DropInfo dropInfo)
 {
     MultiTouchInkCanvas element = dropInfo.VisualTarget as MultiTouchInkCanvas;
     DataObject data = dropInfo.Data as DataObject;
     if (element != null && data != null && this.SelectedSlide != null)
     {
         dropInfo.Effects = DragDropEffects.Move | DragDropEffects.Copy;
     }
 }
Пример #29
0
 public new void DragOver(DropInfo dropInfo)
 {
     dropInfo.DropTargetAdorner = DropTargetAdorners.Insert;
     dropInfo.Effects = DragDropEffects.Move;
 }
Пример #30
0
        static void DropTarget_PreviewDrop(object sender, DragEventArgs e)
        {
            DropInfo dropInfo = new DropInfo(sender, e, m_DragInfo, m_Format.Name);
            IDropTarget dropHandler = GetDropHandler((UIElement)sender);

            DragAdorner = null;
            DropTargetAdorner = null;

            if (dropHandler != null)
            {
                dropHandler.Drop(dropInfo);
            }
            else
            {
                DefaultDropHandler.Drop(dropInfo);
            }

            e.Handled = true;
        }
Пример #31
0
        private static void CreateDragAdorner(DropInfo dropInfo)
        {
            var template         = GetDragAdornerTemplate(m_DragInfo.VisualSource);
            var templateSelector = GetDragAdornerTemplateSelector(m_DragInfo.VisualSource);

            UIElement adornment = null;

            var useDefaultDragAdorner = GetUseDefaultDragAdorner(m_DragInfo.VisualSource);
            var useVisualSourceItemSizeForDragAdorner = GetUseVisualSourceItemSizeForDragAdorner(m_DragInfo.VisualSource);

            if (template == null && templateSelector == null && useDefaultDragAdorner)
            {
                var bs = CaptureScreen(m_DragInfo.VisualSourceItem, m_DragInfo.VisualSourceFlowDirection);
                if (bs != null)
                {
                    var factory = new FrameworkElementFactory(typeof(Image));
                    factory.SetValue(Image.SourceProperty, bs);
                    factory.SetValue(RenderOptions.EdgeModeProperty, EdgeMode.Aliased);
                    factory.SetValue(RenderOptions.BitmapScalingModeProperty, BitmapScalingMode.HighQuality);
                    factory.SetValue(FrameworkElement.WidthProperty, bs.Width);
                    factory.SetValue(FrameworkElement.HeightProperty, bs.Height);
                    factory.SetValue(FrameworkElement.HorizontalAlignmentProperty, HorizontalAlignment.Left);
                    factory.SetValue(FrameworkElement.VerticalAlignmentProperty, VerticalAlignment.Top);
                    template = new DataTemplate {
                        VisualTree = factory
                    };
                }
            }

            if (template != null || templateSelector != null)
            {
                if (m_DragInfo.Data is IEnumerable && !(m_DragInfo.Data is string))
                {
                    if (!useDefaultDragAdorner && ((IEnumerable)m_DragInfo.Data).Cast <object>().Count() <= 10)
                    {
                        var itemsControl = new ItemsControl();
                        itemsControl.ItemsSource          = (IEnumerable)m_DragInfo.Data;
                        itemsControl.ItemTemplate         = template;
                        itemsControl.ItemTemplateSelector = templateSelector;

                        if (useVisualSourceItemSizeForDragAdorner)
                        {
                            var bounds = VisualTreeHelper.GetDescendantBounds(m_DragInfo.VisualSourceItem);
                            itemsControl.SetValue(FrameworkElement.MinWidthProperty, bounds.Width);
                        }

                        // The ItemsControl doesn't display unless we create a grid to contain it.
                        // Not quite sure why we need this...
                        var grid = new Grid();
                        grid.Children.Add(itemsControl);
                        adornment = grid;
                    }
                }
                else
                {
                    var contentPresenter = new ContentPresenter();
                    contentPresenter.Content                 = m_DragInfo.Data;
                    contentPresenter.ContentTemplate         = template;
                    contentPresenter.ContentTemplateSelector = templateSelector;

                    if (useVisualSourceItemSizeForDragAdorner)
                    {
                        var bounds = VisualTreeHelper.GetDescendantBounds(m_DragInfo.VisualSourceItem);
                        contentPresenter.SetValue(FrameworkElement.MinWidthProperty, bounds.Width);
                        contentPresenter.SetValue(FrameworkElement.MinHeightProperty, bounds.Height);
                    }

                    adornment = contentPresenter;
                }
            }

            if (adornment != null)
            {
                if (useDefaultDragAdorner)
                {
                    adornment.Opacity = GetDefaultDragAdornerOpacity(m_DragInfo.VisualSource);
                }

                var rootElement = RootElementFinder.FindRoot(dropInfo.VisualTarget ?? m_DragInfo.VisualSource);
                DragAdorner = new DragAdorner(rootElement, adornment);
            }
        }
Пример #32
0
		private static void DropTarget_PreviewDrop(object sender, DragEventArgs e)
		{
			var dropInfo = new DropInfo(sender, e, m_DragInfo);
			var dropHandler = TryGetDropHandler(dropInfo, sender as UIElement);
			var dragHandler = TryGetDragHandler(m_DragInfo, sender as UIElement);

			DragAdorner = null;
			EffectAdorner = null;
			DropTargetAdorner = null;

			dropHandler.Drop(dropInfo);
			m_DropInfo = dropInfo; //ModifiedByLellid to delay the call to dragHandler.Dropped, but store the DropInfo
			// dragHandler.Dropped(dropInfo); // ModifiedByLellid

			Mouse.OverrideCursor = null;
			e.Handled = !dropInfo.NotHandled;
			if (e.Handled) // ModifiedByLellid --> this is in order that DoDragDrop returns the final drop effect
				e.Effects = dropInfo.Effects;
		}
 public DropTargetInsertionAdorner(UIElement adornedElement, DropInfo dropInfo)
     : base(adornedElement, dropInfo)
 {
 }
Пример #34
0
 public void PauseOver(DropInfo dropInfo)
 {
     throw new NotImplementedException();
 }
 public DropTargetHighlightAdorner(UIElement adornedElement, DropInfo dropInfo)
     : base(adornedElement, dropInfo)
 {
 }
Пример #36
0
        private static void CreateEffectAdorner(DropInfo dropInfo)
        {
            var template = GetEffectAdornerTemplate(m_DragInfo.VisualSource, dropInfo.Effects, dropInfo.DestinationText);

              if (template != null) {
            var rootElement = (UIElement)Application.Current.MainWindow.Content;
            UIElement adornment = null;

            var contentPresenter = new ContentPresenter();
            contentPresenter.Content = m_DragInfo.Data;
            contentPresenter.ContentTemplate = template;

            adornment = contentPresenter;

            EffectAdorner = new DragAdorner(rootElement, adornment);
              }
        }
Пример #37
0
        private static void CreateDragAdorner(DropInfo dropInfo)
        {
            var dragInfo         = dropInfo.DragInfo;
            var template         = GetDropAdornerTemplate(dropInfo.VisualTarget) ?? GetDragAdornerTemplate(dragInfo.VisualSource);
            var templateSelector = GetDropAdornerTemplateSelector(dropInfo.VisualTarget) ?? GetDragAdornerTemplateSelector(dragInfo.VisualSource);

            UIElement adornment = null;

            var useDefaultDragAdorner = template == null && templateSelector == null && GetUseDefaultDragAdorner(dragInfo.VisualSource);
            var useVisualSourceItemSizeForDragAdorner = GetUseVisualSourceItemSizeForDragAdorner(dragInfo.VisualSource);

            if (useDefaultDragAdorner)
            {
                template = dragInfo.VisualSourceItem.GetCaptureScreenDataTemplate(dragInfo.VisualSourceFlowDirection);
            }

            if (template != null || templateSelector != null)
            {
                if (dragInfo.Data is IEnumerable && !(dragInfo.Data is string))
                {
                    if (!useDefaultDragAdorner && ((IEnumerable)dragInfo.Data).Cast <object>().Count() <= 10)
                    {
                        var itemsControl = new ItemsControl();
                        itemsControl.ItemsSource          = (IEnumerable)dragInfo.Data;
                        itemsControl.ItemTemplate         = template;
                        itemsControl.ItemTemplateSelector = templateSelector;
                        itemsControl.Tag = dragInfo;

                        if (useVisualSourceItemSizeForDragAdorner)
                        {
                            var bounds = VisualTreeHelper.GetDescendantBounds(dragInfo.VisualSourceItem);
                            itemsControl.SetValue(FrameworkElement.MinWidthProperty, bounds.Width);
                        }

                        // The ItemsControl doesn't display unless we create a grid to contain it.
                        // Not quite sure why we need this...
                        var grid = new Grid();
                        grid.Children.Add(itemsControl);
                        adornment = grid;
                    }
                }
                else
                {
                    var contentPresenter = new ContentPresenter();
                    contentPresenter.Content                 = dragInfo.Data;
                    contentPresenter.ContentTemplate         = template;
                    contentPresenter.ContentTemplateSelector = templateSelector;
                    contentPresenter.Tag = dragInfo;

                    if (useVisualSourceItemSizeForDragAdorner)
                    {
                        var bounds = VisualTreeHelper.GetDescendantBounds(dragInfo.VisualSourceItem);
                        contentPresenter.SetValue(FrameworkElement.MinWidthProperty, bounds.Width);
                        contentPresenter.SetValue(FrameworkElement.MinHeightProperty, bounds.Height);
                    }

                    adornment = contentPresenter;
                }
            }

            if (adornment != null)
            {
                if (useDefaultDragAdorner)
                {
                    adornment.Opacity = GetDefaultDragAdornerOpacity(dragInfo.VisualSource);
                }

                var rootElement = RootElementFinder.FindRoot(dropInfo.VisualTarget ?? dragInfo.VisualSource);
                DragAdorner = new DragAdorner(rootElement, adornment, GetDragAdornerTranslation(dragInfo.VisualSource));
            }
        }
Пример #38
0
        private static void DropTarget_PreviewDrop(object sender, DragEventArgs e)
        {
            var dropInfo = new DropInfo(sender, e, m_DragInfo);
              var dropHandler = GetDropHandler((UIElement)sender) ?? DefaultDropHandler;
              var dragHandler = TryGetDragHandler(m_DragInfo, sender as UIElement);

              DragAdorner = null;
              EffectAdorner = null;
              DropTargetAdorner = null;

              dropHandler.Drop(dropInfo);
              dragHandler.Dropped(dropInfo);

              Mouse.OverrideCursor = null;
              e.Handled = true;
        }
Пример #39
0
    private static void CreateDragAdorner(DropInfo dropInfo)
    {
      var template = GetDragAdornerTemplate(m_DragInfo.VisualSource);
      var templateSelector = GetDragAdornerTemplateSelector(m_DragInfo.VisualSource);

      UIElement adornment = null;

      var useDefaultDragAdorner = GetUseDefaultDragAdorner(m_DragInfo.VisualSource);
      var useVisualSourceItemSizeForDragAdorner = GetUseVisualSourceItemSizeForDragAdorner(m_DragInfo.VisualSource);

      if (template == null && templateSelector == null && useDefaultDragAdorner) {
        var bs = CaptureScreen(m_DragInfo.VisualSourceItem, m_DragInfo.VisualSourceFlowDirection);
        if (bs != null) {
          var factory = new FrameworkElementFactory(typeof(Image));
          factory.SetValue(Image.SourceProperty, bs);
          factory.SetValue(RenderOptions.EdgeModeProperty, EdgeMode.Aliased);
          factory.SetValue(RenderOptions.BitmapScalingModeProperty, BitmapScalingMode.HighQuality);
          factory.SetValue(FrameworkElement.WidthProperty, bs.Width);
          factory.SetValue(FrameworkElement.HeightProperty, bs.Height);
          factory.SetValue(FrameworkElement.HorizontalAlignmentProperty, HorizontalAlignment.Left);
          factory.SetValue(FrameworkElement.VerticalAlignmentProperty, VerticalAlignment.Top);
          template = new DataTemplate { VisualTree = factory };
        }
      }

      if (template != null || templateSelector != null) {
        if (m_DragInfo.Data is IEnumerable && !(m_DragInfo.Data is string)) {
          if (!useDefaultDragAdorner && ((IEnumerable)m_DragInfo.Data).Cast<object>().Count() <= 10) {
            var itemsControl = new ItemsControl();
            itemsControl.ItemsSource = (IEnumerable)m_DragInfo.Data;
            itemsControl.ItemTemplate = template;
            itemsControl.ItemTemplateSelector = templateSelector;

            if (useVisualSourceItemSizeForDragAdorner)
            {
              var bounds = VisualTreeHelper.GetDescendantBounds(m_DragInfo.VisualSourceItem);
              itemsControl.SetValue(FrameworkElement.MinWidthProperty, bounds.Width);
            }

            // The ItemsControl doesn't display unless we create a grid to contain it.
            // Not quite sure why we need this...
            var grid = new Grid();
            grid.Children.Add(itemsControl);
            adornment = grid;
          }
        } else {
          var contentPresenter = new ContentPresenter();
          contentPresenter.Content = m_DragInfo.Data;
          contentPresenter.ContentTemplate = template;
          contentPresenter.ContentTemplateSelector = templateSelector;

          if (useVisualSourceItemSizeForDragAdorner)
          {
            var bounds = VisualTreeHelper.GetDescendantBounds(m_DragInfo.VisualSourceItem);
            contentPresenter.SetValue(FrameworkElement.MinWidthProperty, bounds.Width);
            contentPresenter.SetValue(FrameworkElement.MinHeightProperty, bounds.Height);
          }

          adornment = contentPresenter;
        }
      }

      if (adornment != null) {
        if (useDefaultDragAdorner) {
          adornment.Opacity = GetDefaultDragAdornerOpacity(m_DragInfo.VisualSource);
        }

        var rootElement = RootElementFinder.FindRoot(dropInfo.VisualTarget ?? m_DragInfo.VisualSource);
        DragAdorner = new DragAdorner(rootElement, adornment);
      }
    }