Cursor Klasa

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Windows.Forms
Zestaw:
System.Windows.Forms.dll

Przedstawia obraz używany do malowania wskaźnika myszy.

public ref class Cursor sealed : IDisposable, System::Runtime::Serialization::ISerializable
[System.ComponentModel.TypeConverter(typeof(System.Windows.Forms.CursorConverter))]
[System.Serializable]
public sealed class Cursor : IDisposable, System.Runtime.Serialization.ISerializable
[System.ComponentModel.TypeConverter(typeof(System.Windows.Forms.CursorConverter))]
public sealed class Cursor : IDisposable, System.Runtime.Serialization.ISerializable
[<System.ComponentModel.TypeConverter(typeof(System.Windows.Forms.CursorConverter))>]
[<System.Serializable>]
type Cursor = class
    interface IDisposable
    interface ISerializable
[<System.ComponentModel.TypeConverter(typeof(System.Windows.Forms.CursorConverter))>]
type Cursor = class
    interface IDisposable
    interface ISerializable
Public NotInheritable Class Cursor
Implements IDisposable, ISerializable
Dziedziczenie
Object
Cursor
Atrybuty
TypeConverterAttribute SerializableAttribute
Implementuje
IDisposable ISerializable

Przykłady

Poniższy przykład kodu przedstawia formularz, który demonstruje użycie kursora niestandardowego. Element niestandardowy Cursor jest osadzony w pliku zasobów aplikacji. Przykład wymaga kursora zawartego w pliku kursora o nazwie MyCursor.cur. Aby skompilować ten przykład przy użyciu wiersza polecenia, dołącz następującą flagę: /res:MyCursor.Cur, CustomCursor.MyCursor.Cur

using System;
using System.Drawing;
using System.Windows.Forms;

namespace CustomCursor
{
    public class Form1 : System.Windows.Forms.Form
    {
        [STAThread]
        static void Main() 
        {
            Application.Run(new Form1());
        }

        public Form1()
        {
            this.ClientSize = new System.Drawing.Size(292, 266);
            this.Text = "Cursor Example";
            
            // The following generates a cursor from an embedded resource.
            
            // To add a custom cursor, create a bitmap
            //        1. Add a new cursor file to your project: 
            //                Project->Add New Item->General->Cursor File

            // --- To make the custom cursor an embedded resource  ---
            
            // In Visual Studio:
            //        1. Select the cursor file in the Solution Explorer
            //        2. Choose View->Properties.
            //        3. In the properties window switch "Build Action" to "Embedded Resources"

            // On the command line:
            //        Add the following flag:
            //            /res:CursorFileName.cur,Namespace.CursorFileName.cur
            //        
            //        Where "Namespace" is the namespace in which you want to use the cursor
            //        and   "CursorFileName.cur" is the cursor filename.

            // The following line uses the namespace from the passed-in type
            // and looks for CustomCursor.MyCursor.Cur in the assemblies manifest.
        // NOTE: The cursor name is acase sensitive.
            this.Cursor = new Cursor(GetType(), "MyCursor.cur");  
        }
    }
}

Imports System.Drawing
Imports System.Windows.Forms

Namespace CustomCursor
   
   Public Class Form1
      Inherits System.Windows.Forms.Form
      
      <System.STAThread()> _
      Public Shared Sub Main()
         System.Windows.Forms.Application.Run(New Form1())
      End Sub

      Public Sub New()

         Me.ClientSize = New System.Drawing.Size(292, 266)
         Me.Text = "Cursor Example"
         
        ' The following generates a cursor from an embedded resource.
         
        'To add a custom cursor, create a bitmap
        '       1. Add a new cursor file to your project: 
        '               Project->Add New Item->General->Cursor File

        '--- To make the custom cursor an embedded resource  ---

        'In Visual Studio:
        '       1. Select the cursor file in the Solution Explorer
        '       2. Choose View->Properties.
        '       3. In the properties window switch "Build Action" to "Embedded Resources"

        'On the command line:
        '       Add the following flag:
        '           /res:CursorFileName.cur,Namespace.CursorFileName.cur

        '       Where "Namespace" is the namespace in which you want to use the cursor
        '       and   "CursorFileName.cur" is the cursor filename.

        'The following line uses the namespace from the passed-in type
        'and looks for CustomCursor.MyCursor.cur in the assemblies manifest.
        'NOTE: The cursor name is acase sensitive.
        Me.Cursor = New Cursor(Me.GetType(), "MyCursor.cur")
      End Sub
   End Class
End Namespace 'CustomCursor

Poniższy przykład kodu przedstawia informacje o kliencie w kontrolce TreeView . Węzły drzewa głównego wyświetlają nazwy klientów, a węzły drzewa podrzędnego wyświetlają numery zamówień przypisanych do każdego klienta. W tym przykładzie wyświetlanych jest 1000 klientów z 15 zamówieniami. Przemalowanie TreeView obiektu jest pomijane przy użyciu BeginUpdate metod i EndUpdate , a oczekiwanie Cursor jest wyświetlane podczas TreeView tworzenia i malowania TreeNode obiektów. W tym przykładzie jest wymagany plik kursora o nazwie MyWait.cur w katalogu aplikacji. Wymaga Customer również obiektu, który może przechowywać kolekcję Order obiektów i że utworzono wystąpienie kontrolki TreeView na obiekcie Form.

// The basic Customer class.
ref class Customer: public System::Object
{
private:
   String^ custName;

protected:
   ArrayList^ custOrders;

public:
   Customer( String^ customername )
   {
      custName = "";
      custOrders = gcnew ArrayList;
      this->custName = customername;
   }


   property String^ CustomerName 
   {
      String^ get()
      {
         return this->custName;
      }

      void set( String^ value )
      {
         this->custName = value;
      }

   }

   property ArrayList^ CustomerOrders 
   {
      ArrayList^ get()
      {
         return this->custOrders;
      }

   }

};


// End Customer class
// The basic customer Order class.
ref class Order: public System::Object
{
private:
   String^ ordID;

public:
   Order( String^ orderid )
   {
      ordID = "";
      this->ordID = orderid;
   }


   property String^ OrderID 
   {
      String^ get()
      {
         return this->ordID;
      }

      void set( String^ value )
      {
         this->ordID = value;
      }

   }

};
// End Order class



void FillMyTreeView()
{
   // Add customers to the ArrayList of Customer objects.
   for ( int x = 0; x < 1000; x++ )
   {
      customerArray->Add( gcnew Customer( "Customer " + x ) );
   }
   
   // Add orders to each Customer object in the ArrayList.
   IEnumerator^ myEnum = customerArray->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Customer^ customer1 = safe_cast<Customer^>(myEnum->Current);
      for ( int y = 0; y < 15; y++ )
      {
         customer1->CustomerOrders->Add( gcnew Order( "Order " + y ) );
      }
   }

   // Display a wait cursor while the TreeNodes are being created.
   ::Cursor::Current = gcnew System::Windows::Forms::Cursor( "MyWait.cur" );
   
   // Suppress repainting the TreeView until all the objects have been created.
   treeView1->BeginUpdate();
   
   // Clear the TreeView each time the method is called.
   treeView1->Nodes->Clear();
   
   // Add a root TreeNode for each Customer object in the ArrayList.
   myEnum = customerArray->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Customer^ customer2 = safe_cast<Customer^>(myEnum->Current);
      treeView1->Nodes->Add( gcnew TreeNode( customer2->CustomerName ) );
      
      // Add a child treenode for each Order object in the current Customer object.
      IEnumerator^ myEnum = customer2->CustomerOrders->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         Order^ order1 = safe_cast<Order^>(myEnum->Current);
         treeView1->Nodes[ customerArray->IndexOf( customer2 ) ]->Nodes->Add( gcnew TreeNode( customer2->CustomerName + "." + order1->OrderID ) );
      }
   }
   
   // Reset the cursor to the default for all controls.
   ::Cursor::Current = Cursors::Default;
   
   // Begin repainting the TreeView.
   treeView1->EndUpdate();
}


// The basic Customer class.
public class Customer : System.Object
{
   private string custName = "";
   protected ArrayList custOrders = new ArrayList();

   public Customer(string customername)
   {
      this.custName = customername;
   }

   public string CustomerName
   {      
      get{return this.custName;}
      set{this.custName = value;}
   }

   public ArrayList CustomerOrders 
   {
      get{return this.custOrders;}
   }
} // End Customer class 

// The basic customer Order class.
public class Order : System.Object
{
   private string ordID = "";

   public Order(string orderid)
   {
      this.ordID = orderid;
   }

   public string OrderID
   {      
      get{return this.ordID;}
      set{this.ordID = value;}
   }
} // End Order class

// Create a new ArrayList to hold the Customer objects.
private ArrayList customerArray = new ArrayList(); 

private void FillMyTreeView()
{
   // Add customers to the ArrayList of Customer objects.
   for(int x=0; x<1000; x++)
   {
      customerArray.Add(new Customer("Customer" + x.ToString()));
   }

   // Add orders to each Customer object in the ArrayList.
   foreach(Customer customer1 in customerArray)
   {
      for(int y=0; y<15; y++)
      {
         customer1.CustomerOrders.Add(new Order("Order" + y.ToString()));    
      }
   }

   // Display a wait cursor while the TreeNodes are being created.
   Cursor.Current = new Cursor("MyWait.cur");
        
   // Suppress repainting the TreeView until all the objects have been created.
   treeView1.BeginUpdate();

   // Clear the TreeView each time the method is called.
   treeView1.Nodes.Clear();

   // Add a root TreeNode for each Customer object in the ArrayList.
   foreach(Customer customer2 in customerArray)
   {
      treeView1.Nodes.Add(new TreeNode(customer2.CustomerName));
          
      // Add a child treenode for each Order object in the current Customer object.
      foreach(Order order1 in customer2.CustomerOrders)
      {
         treeView1.Nodes[customerArray.IndexOf(customer2)].Nodes.Add(
           new TreeNode(customer2.CustomerName + "." + order1.OrderID));
      }
   }

   // Reset the cursor to the default for all controls.
   Cursor.Current = Cursors.Default;

   // Begin repainting the TreeView.
   treeView1.EndUpdate();
}

Public Class Customer
   Inherits [Object]
   Private custName As String = ""
   Friend custOrders As New ArrayList()

   Public Sub New(ByVal customername As String)
      Me.custName = customername
   End Sub

   Public Property CustomerName() As String
      Get
         Return Me.custName
      End Get
      Set(ByVal Value As String)
         Me.custName = Value
      End Set
   End Property

   Public ReadOnly Property CustomerOrders() As ArrayList
      Get
         Return Me.custOrders
      End Get
   End Property
End Class


Public Class Order
   Inherits [Object]
   Private ordID As String

   Public Sub New(ByVal orderid As String)
      Me.ordID = orderid
   End Sub

   Public Property OrderID() As String
      Get
         Return Me.ordID
      End Get
      Set(ByVal Value As String)
         Me.ordID = Value
      End Set
   End Property
End Class

' Create a new ArrayList to hold the Customer objects.
Private customerArray As New ArrayList()

Private Sub FillMyTreeView()
   ' Add customers to the ArrayList of Customer objects.
   Dim x As Integer
   For x = 0 To 999
      customerArray.Add(New Customer("Customer" + x.ToString()))
   Next x

   ' Add orders to each Customer object in the ArrayList.
   Dim customer1 As Customer
   For Each customer1 In customerArray
      Dim y As Integer
      For y = 0 To 14
         customer1.CustomerOrders.Add(New Order("Order" + y.ToString()))
      Next y
   Next customer1

   ' Display a wait cursor while the TreeNodes are being created.
   Cursor.Current = New Cursor("MyWait.cur")

   ' Suppress repainting the TreeView until all the objects have been created.
   treeView1.BeginUpdate()

   ' Clear the TreeView each time the method is called.
   treeView1.Nodes.Clear()

   ' Add a root TreeNode for each Customer object in the ArrayList.
   Dim customer2 As Customer
   For Each customer2 In customerArray
      treeView1.Nodes.Add(New TreeNode(customer2.CustomerName))

      ' Add a child TreeNode for each Order object in the current Customer object.
      Dim order1 As Order
      For Each order1 In customer2.CustomerOrders
         treeView1.Nodes(customerArray.IndexOf(customer2)).Nodes.Add( _
    New TreeNode(customer2.CustomerName + "." + order1.OrderID))
      Next order1
   Next customer2

   ' Reset the cursor to the default for all controls.
   Cursor.Current = System.Windows.Forms.Cursors.Default

   ' Begin repainting the TreeView.
   treeView1.EndUpdate()
End Sub

Uwagi

Kursor jest małym obrazem, którego lokalizacja na ekranie jest kontrolowana przez urządzenie wskazujące, takie jak mysz, pióro lub trackball. Gdy użytkownik przenosi urządzenie wskazujące, system operacyjny odpowiednio przenosi kursor.

Różne kształty kursorów są używane do informowania użytkownika o operacji myszy. Na przykład podczas edytowania lub wybierania tekstu Cursors.IBeam kursor jest zwykle wyświetlany. Kursor oczekiwania jest często używany do informowania użytkownika, że proces jest obecnie uruchomiony. Przykłady procesów, na które może czekać użytkownik, otwierają plik, zapisują plik lub wypełniają kontrolkę, taką jak DataGrid, ListBox lub TreeView z dużą ilością danych.

Wszystkie kontrolki pochodzące z Control klasy mają Cursor właściwość . Aby zmienić kursor wyświetlany przez wskaźnik myszy, gdy znajduje się on w granicach kontrolki, przypisz element Cursor do Cursor właściwości kontrolki. Możesz też wyświetlić kursory na poziomie aplikacji, przypisując element Cursor do Current właściwości. Jeśli na przykład celem aplikacji jest edytowanie pliku tekstowego, można ustawić Current właściwość Cursors.WaitCursor tak, aby wyświetlała kursor oczekiwania na aplikację podczas ładowania lub zapisywania pliku, aby zapobiec przetwarzaniu zdarzeń myszy. Po zakończeniu procesu ustaw Current właściwość na Cursors.Default dla aplikacji, aby wyświetlić odpowiedni kursor nad każdym typem kontrolki.

Uwaga

Jeśli wywołasz wywołanie Application.DoEvents przed zresetowaniem Current właściwości z powrotem do kursora Cursors.Default , aplikacja wznowi nasłuchiwanie zdarzeń myszy i wznowi wyświetlanie odpowiednich Cursor dla każdej kontrolki w aplikacji.

Obiekty kursora można tworzyć na podstawie kilku źródeł, takich jak uchwyt istniejącego Cursorpliku , pliku standardowego Cursor , zasobu lub strumienia danych.

Uwaga

Klasa Cursor nie obsługuje animowanych kursorów (plików animowanych) ani kursorów z kolorami innymi niż czarno-białe.

Jeśli obraz używany jako kursor jest za mały, możesz użyć DrawStretched metody , aby wymusić wypełnienie granic kursora. Kursor można tymczasowo ukryć, wywołując metodę Hide i przywracając ją, wywołując metodę Show .

Począwszy od .NET Framework 4.5.2, Cursor rozmiar zostanie zmieniony na podstawie ustawienia dpi systemu, gdy plik app.config zawiera następujący wpis:

<appSettings>  
  <add key="EnableWindowsFormsHighDpiAutoResizing" value="true" />  
</appSettings>

Konstruktory

Cursor(IntPtr)

Inicjuje Cursor nowe wystąpienie klasy z określonego uchwytu Windows.
Cursor(Stream)

Inicjuje Cursor nowe wystąpienie klasy z określonego strumienia danych.
Cursor(String)

Inicjuje Cursor nowe wystąpienie klasy z określonego pliku.
Cursor(Type, String)

Inicjuje nowe wystąpienie Cursor klasy z określonego zasobu o określonym typie zasobu.

Właściwości

Clip

Pobiera lub ustawia granice reprezentujące prostokąt wycinki dla kursora.
Current

Pobiera lub ustawia obiekt kursora, który reprezentuje kursor myszy.
Handle

Pobiera uchwyt kursora.
HotSpot

Pobiera kursor w gorącym miejscu.
Position

Pobiera lub ustawia położenie kursora.
Size

Pobiera rozmiar obiektu kursora.
Tag

Pobiera lub ustawia obiekt zawierający dane dotyczące obiektu Cursor.

Metody

CopyHandle()

Kopiuje uchwyt tego Cursorobiektu .
Dispose()

Zwalnia wszelkie zasoby używane przez element Cursor.
Draw(Graphics, Rectangle)

Rysuje kursor na określonej powierzchni w określonych granicach.
DrawStretched(Graphics, Rectangle)

Rysuje kursor w formacie rozciągniętym na określonej powierzchni w obrębie określonych granic.
Equals(Object)

Zwraca wartość wskazującą, czy ten kursor jest równy określonej Cursorwartości .
Finalize()

Umożliwia obiektowi próbę zwolnienia zasobów i wykonania innych operacji oczyszczania przed odzyskaniem przez odzyskiwanie pamięci.
GetHashCode()

Pobiera kod skrótu dla bieżącego Cursorelementu .
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
Hide()

Ukrywa kursor.
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
Show()

Wyświetla kursor.
ToString()

Pobiera czytelny dla człowieka ciąg reprezentujący ten Cursorelement .

Operatory

Equality(Cursor, Cursor)

Zwraca wartość wskazującą, czy dwa wystąpienia Cursor klasy są równe.
Inequality(Cursor, Cursor)

Zwraca wartość wskazującą, czy dwa wystąpienia Cursor klasy nie są równe.

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Serializuje obiekt.

Dotyczy

Zobacz też