C# Input.QueryCursorEventArgs类代码示例

		/// <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);