protected override void OnQueryContinueDrag(QueryContinueDragEventArgs e)
        {
            base.OnQueryContinueDrag(e);

            e.Action = DragAction.Cancel;
            e.Handled = true;
        }

 private static void triggerElement_QueryContinueDrag(object sender, QueryContinueDragEventArgs e)
 {
     e.Action = DragAction.Drop;
     if ((e.KeyStates & DragDropKeyStates.LeftMouseButton) != DragDropKeyStates.None)
         e.Action = DragAction.Continue;
     if (e.Action == DragAction.Drop)
         _contentPresenter = null;
 }

        protected override void OnPreviewQueryContinueDrag(QueryContinueDragEventArgs args)
        {
            base.OnPreviewQueryContinueDrag(args);

            if (args.Action == DragAction.Cancel || args.Action == DragAction.Drop) {
                CancelDrag();
            } else if (args.Action == DragAction.Continue) {
                Point p = MouseUtilities.GetMousePosition(this);
                if ((p.Y < DRAG_MARGIN) || (p.Y > RenderSize.Height - DRAG_MARGIN)) {
                    if (_dragScrollTimer == null) {
                        _dragVelocity = DRAG_INITIAL_VELOCITY;
                        _dragScrollTimer = new DispatcherTimer();
                        _dragScrollTimer.Tick += TickDragScroll;
                        _dragScrollTimer.Interval = new TimeSpan(0, 0, 0, 0, (int)DRAG_INTERVAL);
                        _dragScrollTimer.Start();
                    }
                }
            }
        }

        protected override void OnPreviewQueryContinueDrag(QueryContinueDragEventArgs args)
        {
            base.OnPreviewQueryContinueDrag(args);

            if (args.Action == DragAction.Cancel || args.Action == DragAction.Drop)
            {
                CancelDrag();
            }
            else if (args.Action == DragAction.Continue)
            {
                Point p = MouseUtilities.GetMousePosition(this);
                if ((p.Y < s_dragMargin) || (p.Y > RenderSize.Height - s_dragMargin))
                {
                    if (_dragScrollTimer == null)
                    {
                        _dragVelocity = s_dragInitialVelocity;
                        _dragScrollTimer = new DispatcherTimer();
                        _dragScrollTimer.Tick += TickDragScroll;
                        _dragScrollTimer.Interval = new TimeSpan(0, 0, 0, 0, (int)s_dragInterval);
                        _dragScrollTimer.Start();
                    }
                }
            }
        }

		void textArea_QueryContinueDrag(object sender, QueryContinueDragEventArgs e)
		{
			try {
				if (e.EscapePressed) {
					e.Action = DragAction.Cancel;
				} else if ((e.KeyStates & DragDropKeyStates.LeftMouseButton) != DragDropKeyStates.LeftMouseButton) {
					e.Action = DragAction.Drop;
				} else {
					e.Action = DragAction.Continue;
				}
				e.Handled = true;
			} catch (Exception ex) {
				OnDragException(ex);
			}
		}

 public static void DefaultQueryContinueDragHandler(object sender, QueryContinueDragEventArgs e)
 {
     DataObjectExtensions.DefaultQueryContinueDrag(e);
 }

 void DragScope_QueryContinueDrag(object sender, QueryContinueDragEventArgs e)
 {
     if (this._dragHasLeftScope)
     {
         e.Action = DragAction.Cancel;
         e.Handled = true;
     }
 }

 /// <summary>
 ///     Virtual method reporting the query continue drag is going to happen
 /// </summary>
 protected internal virtual void OnQueryContinueDrag(QueryContinueDragEventArgs e) {}

        private static void OnQueryContinueDragThunk(object sender, QueryContinueDragEventArgs e)
        {
            Invariant.Assert(!e.Handled, "Unexpected: Event has already been handled.");

            UIElement uie = sender as UIElement;

            if (uie != null)
            {
                uie.OnQueryContinueDrag(e);
            }
            else
            {
                ContentElement ce = sender as ContentElement;

                if (ce != null)
                {
                    ce.OnQueryContinueDrag(e);
                }
                else
                {
                    ((UIElement3D)sender).OnQueryContinueDrag(e);
                }
            }
        }

		void MouseElement_QueryContinueDrag(object sender, QueryContinueDragEventArgs e) {
			foreach (var m in mouseProcessors) {
				if (e.Handled)
					break;
				m.PreprocessQueryContinueDrag(e);
			}
			if (!e.Handled)
				defaultMouseProcessor.OnQueryContinueDrag(sender, e);
			foreach (var m in mouseProcessors)
				m.PostprocessQueryContinueDrag(e);
		}

 private void DragSourceQueryContinueDrag(object sender, QueryContinueDragEventArgs e)
 {
     UpdateWindowLocation();
 }

 private void DragScopeQueryContinueDrag(object sender, QueryContinueDragEventArgs e)
 {
     if (!_dragHasLeftScope) return;
     e.Action = DragAction.Cancel;
     e.Handled = true;
 }

        private void PictureToAssign_OnQueryContinueDrag (object Sender, QueryContinueDragEventArgs E)
		    {
		    if (E.Action != DragAction.Continue)
			    {
			    DragStartPosition = new Point (0, 0);
			    IsDragging = false;
			    }
		    }

        /// <summary>
        /// Default query continue drag during drag-and-drop operation.
        /// </summary>
        /// <remarks>
        ///     At this stage we do not know application's intended mouse
        ///     button combination for dragging. For default purposes we assume
        ///     that the DragDrop happens due to single mouse button press.
        ///     Hence if any two mouse buttons are pressed at any point of time,
        ///     then we cancel the drapdrop. Also if no mouse buttons are pressed at
        ///     any point of time, then we complete the drop. If an application intends
        ///     to privide multi-button press dragging (like dragging by pressing 
        ///     both left and right buttons of mouse) applications will have
        ///     to handle (Preview)QueryContiueDragEvent to the allow 
        ///     such valid combinations explicitly.
        /// </remarks>
        private void OnDefaultQueryContinueDrag(QueryContinueDragEventArgs e)
        {
            int mouseButtonDownCount = 0;
            
            if ((e.KeyStates & DragDropKeyStates.LeftMouseButton) == DragDropKeyStates.LeftMouseButton)
            {
                mouseButtonDownCount++;
            }
            if ((e.KeyStates & DragDropKeyStates.MiddleMouseButton) == DragDropKeyStates.MiddleMouseButton)
            {
                mouseButtonDownCount++;
            }
            if ((e.KeyStates & DragDropKeyStates.RightMouseButton) == DragDropKeyStates.RightMouseButton)
            {
                mouseButtonDownCount++;
            }

            e.Action = DragAction.Continue;

            if (e.EscapePressed ||
                mouseButtonDownCount >= 2)
            {
                e.Action = DragAction.Cancel;
            }
            else if (mouseButtonDownCount == 0)
            {
                e.Action = DragAction.Drop;
            }
        }

        /// <summary>
        /// Raise QueryContinueDrag event for Tunel and Bubble.
        /// </summary>
        private void RaiseQueryContinueDragEvent(QueryContinueDragEventArgs args)
        {
            // Set PreviewQueryContinueDrag(Tunnel) first.
            args.RoutedEvent=DragDrop.PreviewQueryContinueDragEvent;

            // Raise the preview QueryContinueDrag event(Tunnel).
            if (_dragSource is UIElement)
            {
                ((UIElement)_dragSource).RaiseEvent(args);
            }
            else if (_dragSource is ContentElement)
            {
                ((ContentElement)_dragSource).RaiseEvent(args);
            }
            else if (_dragSource is UIElement3D)
            {
                ((UIElement3D)_dragSource).RaiseEvent(args);
            }
            else
            {
                throw new ArgumentException(SR.Get(SRID.ScopeMustBeUIElementOrContent), "scope");
            }

            // Set QueryContinueDrag(Bubble).
            args.RoutedEvent = DragDrop.QueryContinueDragEvent;

            // Raise QueryContinueDrag event(Bubble).
            if (!args.Handled)
            {
                if (_dragSource is UIElement)
                {
                    ((UIElement)_dragSource).RaiseEvent(args);
                }
                else if (_dragSource is ContentElement)
                {
                    ((ContentElement)_dragSource).RaiseEvent(args);
                }
                else if (_dragSource is UIElement3D)
                {
                    ((UIElement3D)_dragSource).RaiseEvent(args);
                }
                else
                {
                    throw new ArgumentException(SR.Get(SRID.ScopeMustBeUIElementOrContent), "scope");
                }
            }

            // Call the default event handling method internally if no one handle the drag source events.
            if (!args.Handled)
            {
                OnDefaultQueryContinueDrag(args);
            }
        }

 void OnQueryContinueDrag(object sender, QueryContinueDragEventArgs e)
 {
     if ((e.KeyStates & DragDropKeyStates.LeftMouseButton) != DragDropKeyStates.LeftMouseButton)
     {
         e.Action = DragAction.Cancel;
     }
 }

		void IMouseProcessor.PostprocessQueryContinueDrag(QueryContinueDragEventArgs e) { }

 public void PreprocessQueryContinueDrag(QueryContinueDragEventArgs e) {
     IMouseProcessor processor = Content as IMouseProcessor;
     if (processor != null) {
         processor.PreprocessQueryContinueDrag(e);
     }
 }

 private static void DragSource_QueryContinueDrag(object sender, QueryContinueDragEventArgs e)
 {
     if (e.Action == DragAction.Cancel || e.EscapePressed) {
     DragAdorner = null;
     EffectAdorner = null;
     DropTargetAdorner = null;
       }
 }

		protected virtual void OnQueryContinueDrag (QueryContinueDragEventArgs e)
		{
			throw new NotImplementedException ();
		}