/// <inheritdoc/>
		protected internal override void OnQueryCursor(QueryCursorEventArgs e)
		{
			if (LinkIsClickable()) {
				e.Handled = true;
				e.Cursor = Cursors.Hand;
			}
		}

        //------------------------------------------------------------------- 
        //
        // Private Methods 
        // 
        //----------------------------------------------------------------------
 
        #region Private Methods

        // QueryCursorEvent callback.
        // If this Hyperlink is editable, use the editor cursor unless 
        // the control key is down.
        private static void OnQueryCursor(object sender, QueryCursorEventArgs e) 
        { 
            Hyperlink link = (Hyperlink)sender;
 
            if (link.IsEnabled && link.IsEditable)
            {
                if ((Keyboard.Modifiers & ModifierKeys.Control) == 0)
                { 
                    e.Cursor = link.TextContainer.TextSelection.TextEditor._cursor;
                    e.Handled = true; 
                } 
            }
        } 

 protected override void OnQueryCursor(QueryCursorEventArgs e)
 {
     base.OnQueryCursor(e);
     if (_context != null) {
         Cursor cursor = _context.Services.Tool.CurrentTool.Cursor;
         if (cursor != null) {
             e.Cursor = cursor;
             e.Handled = true;
         }
     }
 }

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

            UIElement uie = sender as UIElement;

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

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

		void textArea_QueryCursor(object sender, QueryCursorEventArgs e)
		{
			throw new NotImplementedException();
		}

		protected override void OnQueryCursor(QueryCursorEventArgs e)
		{
			if (FindNextInsertionPoint(e.GetPosition(this)) >= 0)
				e.Cursor = Cursors.UpArrow;
			else
				e.Cursor = Cursors.Arrow;
			e.Handled = true;
		}

        // QueryCursorEvent handler
        internal static void OnQueryCursor(object sender, QueryCursorEventArgs e)
        {
            TextEditor This = TextEditor._GetTextEditor(sender);

            if (This == null)
            {
                return;
            }

            if (This.TextView == null)
            {
                return;
            }

            // Determine whether the cursor is over our render scope.  In particular, we want to distinguish between
            // being directly over our RenderScope (including content of that scope), and being over visual chrome
            // between our UiScope and our RenderScope (such as scroll bars)
            if (IsPointWithinInteractiveArea(This, Mouse.GetPosition(This.UiScope)))
            {
                // Mouse is moving over our render scope, so we apply one of
                // editing cursors - IBeam when outside of selection, Arrow when within selection,
                // Resize - when over table borders, etc.

                // Otherwise (when we are not over the render scope) we do not
                // respond to QueryCursor request, thus leaving it for other
                // elements to decide.
                e.Cursor = This._cursor;
                e.Handled = true;
            }
        }

    protected virtual void NotifyDragOutsideQueryCursor( object sender, QueryCursorEventArgs e )
    {
      e.Cursor = ( this.DropOutsideCursor != null )
        ? this.DropOutsideCursor
        : Cursors.No;

      if( this.DragOutsideQueryCursor != null )
      {
        this.DragOutsideQueryCursor( sender, e );
      }

      e.Handled = true;
    }

 private void OnDraggedElement_QueryCursor( object sender, QueryCursorEventArgs e )
 {
   if( this.IsDragging )
   {
     if( ( this.CurrentDropTarget == null ) || ( !this.CurrentDropTarget.CanDropElement( this.DraggedElement ) ) )
     {
       this.NotifyDragOutsideQueryCursor( sender, e );
     }
   }
 }

		/// <inheritdoc/>
		protected override void OnQueryCursor(QueryCursorEventArgs e) {
			if (!CanClick)
				return;

			e.Handled = true;
			e.Cursor = referenceSegment.IsLocal ? Cursors.Arrow : Cursors.Hand;
		}

 private bool UpdateCursorPrivate()
 {
     int timeStamp = Environment.TickCount;
     QueryCursorEventArgs queryCursor = new QueryCursorEventArgs(this, timeStamp);
     queryCursor.Cursor = Cursors.Arrow;
     queryCursor.RoutedEvent=Mouse.QueryCursorEvent;
     //ProcessInput has a linkdemand
     _inputManager.Value.ProcessInput(queryCursor);
     return queryCursor.Handled;
 }

    private void m_rowResizerThumb_QueryCursor( object sender, QueryCursorEventArgs e )
    {
      FrameworkElement rowItem = ( FrameworkElement )this.DataContext;

      if( rowItem == null )
        return;

      if( this.CanBeResized( this.Orientation ) )
      {
        DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );

        if( dataGridContext != null )
        {
          TableView tableView = dataGridContext.DataGridControl.GetView() as TableView;

          e.Cursor = ( ( tableView != null ) && ( this.Orientation == Orientation.Vertical ) )
            ? tableView.RowSelectorResizeNorthSouthCursor
            : tableView.RowSelectorResizeWestEastCursor;
        }

        if( e.Cursor == null )
        {
          e.Cursor = ( this.Orientation == Orientation.Vertical )
            ? TableView.DefaultRowSelectorResizeNorthSouthCursor
            : TableView.DefaultRowSelectorResizeWestEastCursor;
        }
      }

      e.Handled = true;
    }

 protected override void OnQueryCursor(QueryCursorEventArgs e)
 {
     e.Handled = true;
     e.Cursor = Cursors.Hand;
 }

    private void ColumnResizerThumb_QueryCursor( object sender, QueryCursorEventArgs e )
    {
      ColumnBase parentColumn = this.ParentColumn;

      if( parentColumn == null )
        return;

      DataGridContext dataGridContext = this.DataGridContext;

      bool showResizeCursor = !parentColumn.HasFixedWidth;

      if( !showResizeCursor )
      {
        // Don't disable resizing if ColumnStretching can be disabled by an end-user resize.
        showResizeCursor = ( dataGridContext != null ) && ( TableView.GetRemoveColumnStretchingOnResize( dataGridContext ) );
      }

      if( showResizeCursor )
      {
        if( dataGridContext != null )
        {
          UIViewBase uiViewBase = dataGridContext.DataGridControl.GetView() as UIViewBase;

          e.Cursor = ( uiViewBase != null )
            ? uiViewBase.ColumnResizeWestEastCursor
            : UIViewBase.DefaultColumnResizeWestEastCursor;
        }
        else
        {
          e.Cursor = UIViewBase.DefaultColumnResizeWestEastCursor;
        }

        e.Handled = true;
      }
    }

 protected virtual void OnQueryCursor(QueryCursorEventArgs e);

    private void m_dragSourceManager_DragOutsideQueryCursor( object sender, QueryCursorEventArgs e )
    {
      GroupByControl parentGBC = this.GetParentGroupByControl();

      if( ( parentGBC == null ) || !parentGBC.IsGroupingModificationAllowed )
        return;

      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );

      if( ( dataGridContext != null ) && ( dataGridContext.DataGridControl != null ) )
      {
        UIViewBase uiViewBase = dataGridContext.DataGridControl.GetView() as UIViewBase;

        e.Cursor = ( uiViewBase != null )
          ? uiViewBase.RemovingGroupCursor
          : UIViewBase.DefaultGroupDraggedOutsideCursor;
      }
      else
      {
        e.Cursor = UIViewBase.DefaultGroupDraggedOutsideCursor;
      }
    }

        private void OnQueryCursor(object sender, QueryCursorEventArgs e)
        {
            if (_isSelecting || GetFixedPanelDocumentPage(e.GetPosition(_scope)) != null)
            { 
                e.Cursor = Cursors.Cross;
            } 
            else 
            {
                e.Cursor = Cursors.Arrow; 
            }

            e.Handled = true;
        } 

		protected internal virtual void OnQueryCursor(QueryCursorEventArgs e) 
		{ 
			//TODO: VisualLineElement.OnQueryCursor()
			throw new NotImplementedException();
		}

        private static void OnQueryCursor(object sender, QueryCursorEventArgs e)
        { 
            FrameworkContentElement fce = (FrameworkContentElement) sender;
 
            // We respond to querying the cursor by specifying the cursor set 
            // as a property on this element.
            Cursor cursor = fce.Cursor; 

            if(cursor != null)
            {
                // We specify the cursor if the QueryCursor event is not 
                // handled by the time it gets to us, or if we are configured
                // to force our cursor anyways.  Since the QueryCursor event 
                // bubbles, this has the effect of overriding whatever cursor 
                // a child of ours specified.
                if(!e.Handled || fce.ForceCursor) 
                {
                    e.Cursor = cursor;
                    e.Handled = true;
                } 
            }
        } 

 private static void OnQueryCursorOverride(object sender, QueryCursorEventArgs e)
 {
     FrameworkElement frameworkElement = (FrameworkElement) sender;
       Cursor cursor = frameworkElement.Cursor;
       if (cursor == null || e.Handled && !frameworkElement.ForceCursor)
     return;
       e.Cursor = cursor;
       e.Handled = true;
 }