Cursor.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Input / Cursor.cs / 1 / Cursor.cs
                        

                        
                            using System; 
using System.ComponentModel;
using System.Text;
using System.Globalization;
using MS.Win32; 
using System.Runtime.InteropServices;
using System.Resources; 
using System.IO; 
using System.Security;
using System.Security.Permissions; 
using SecurityHelper=MS.Internal.PresentationCore.SecurityHelper;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
using MS.Internal.PresentationCore;     //  FriendAccessAllowed 

namespace System.Windows.Input 
{ 
    /// 
    ///     Cursor class to support default cursor types. 
    ///    TBD: Support for cutomized cursor types.
    /// 
    [TypeConverter(typeof(CursorConverter))]
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] 
    public sealed class Cursor : IDisposable
    { 
        ///  
        /// Constructor for Standard Cursors, needn't be public as Stock Cursors
        /// are exposed in Cursors clas. 
        /// 
        /// 
        internal Cursor(CursorType cursorType)
        { 
            if (IsValidCursorType(cursorType))
            { 
                LoadCursorHelper(cursorType); 
            }
            else 
            {
                throw new ArgumentException(SR.Get(SRID.InvalidCursorType, cursorType));
            }
        } 

        ///  
        /// Cursor from .ani or .cur file 
        /// 
        ///  
        public Cursor(string cursorFile)
        {
            if (cursorFile == null)
                throw new ArgumentNullException("cursorFile"); 

            if ((cursorFile != String.Empty) && 
                (cursorFile.EndsWith(".cur", StringComparison.OrdinalIgnoreCase) || 
                 cursorFile.EndsWith(".ani", StringComparison.OrdinalIgnoreCase)))
            { 
                LoadFromFile(cursorFile);
                _fileName = cursorFile;
            }
            else 
            {
                throw new ArgumentException(SR.Get(SRID.Cursor_UnsupportedFormat , cursorFile)); 
            } 
        }
 
        /// 
        /// Cursor from Stream
        /// 
        ///  
        public Cursor(Stream cursorStream)
        { 
            if (cursorStream == null) 
            {
                throw new ArgumentNullException("cursorStream"); 
            }

            LoadFromStream(cursorStream);
 
        }
 
        ///  
        ///     Cursor from a SafeHandle to an HCURSOR
        ///  
        /// 
        /// 
        ///    Critical: This causes the cursor to change and accesses the SetHandleInternalMethod
        ///    TreatAsSafe: This code is safe to expose because in the worst case you change cursor for your app 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        [FriendAccessAllowed] //used by ColumnHeader.GetCursor in PresentationFramework 
        internal Cursor(SafeHandle cursorHandle )
        { 
            if (! cursorHandle.IsInvalid )
            {
                this._cursorHandle = cursorHandle ;
            } 
        }
 
         ///  
        /// Destructor (IDispose pattern)
        ///  
        ~Cursor()
        {
            Dispose(false);
        } 

        ///   
        ///     Cleans up the resources allocated by this object.  Once called, the cursor 
        ///     object is no longer useful.
        ///  
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this); 
        }
 
        ///  
        ///    Critical: SafeHandle code link demands on dispose.
        ///    TreatAsSafe: Safe to dispose a cursor. 
        /// 
        [SecurityCritical, SecurityTreatAsSafe ]
        void Dispose(bool disposing)
        { 
            if ( _cursorHandle != null )
            { 
                _cursorHandle.Dispose(); 
                _cursorHandle = null;
            } 
        }


 
        /// 
        /// CursorType - Cursor Type Enumeration 
        ///  
        /// 
        internal CursorType CursorType 
        {
            get
            {
                return _cursorType; 
            }
        } 
 
        /// 
        /// Handle - HCURSOR Interop 
        /// 
        /// 
        internal SafeHandle Handle
        { 
            get
            { 
                if ( _cursorHandle == null ) 
                    return new NativeMethods.CursorHandle( );
                else 
                    return _cursorHandle;
            }
        }
 

        ///  
        /// FileName - .ani or .cur files are allowed 
        /// 
        ///  
        internal String FileName
        {
            get
            { 
                return _fileName;
            } 
        } 

        /// 
        ///     Critical: calls Win32Exception ctor which LinkDemands
        ///     TreatAsSafe: ok to throw an exception in partial trust
        ///
        [SecurityCritical, SecurityTreatAsSafe] 
        private void LoadFromFile(string fileName)
        { 
            SecurityHelper.DemandFileIOReadPermission(fileName); 

            // Load a Custom Cursor 
            _cursorHandle = UnsafeNativeMethods.LoadImageCursor(IntPtr.Zero,
                                                                fileName,
                                                                NativeMethods.IMAGE_CURSOR,
                                                                0, 0, 
                                                                NativeMethods.LR_DEFAULTCOLOR |
                                                                NativeMethods.LR_LOADFROMFILE); 
 
            int errorCode = Marshal.GetLastWin32Error();
            if (_cursorHandle == null || SecurityHelper.SafeHandleIsInvalid(_cursorHandle)) 
            {
                // Note: [....] 02/02/2005
                // Bug # 1016022: LoadImage returns a null handle but does not set
                // the error condition when icon file is of an incorrect type (e.g., .bmp) 
                //
                // LoadImage has a bug where it doesn't set the correct error code 
                // when a file is given that is not an ico file.  Icon load fails 
                // but win32 error code is still zero (success).  Thus, we need to
                // special case this scenario. 
                //
                if (errorCode != 0)
                {
                    if ((errorCode == NativeMethods.ERROR_FILE_NOT_FOUND) || (errorCode == NativeMethods.ERROR_PATH_NOT_FOUND)) 
                    {
                        throw new Win32Exception(errorCode, SR.Get(SRID.Cursor_LoadImageFailure, fileName)); 
                    } 
                    else
                    { 
                        throw new Win32Exception(errorCode);
                    }
                }
                else 
                {
                    throw new ArgumentException(SR.Get(SRID.Cursor_LoadImageFailure, fileName)); 
                } 
            }
        } 

        private const int BUFFERSIZE = 4096; // the maximum size of the buffer used for loading from stream

        private void LoadFromStream(Stream cursorStream) 
        {
            //Generate a temporal file based on the memory stream. 
 
            // GetTempFileName requires unrestricted Environment permission
            // FileIOPermission.Write permission.  However, since we don't 
            // know the path of the file to be created we have to give
            // unrestricted permission here.
            // GetTempFileName documentation does not mention that it throws
            // any exception. However, if it does, CLR reverts the assert. 

            string filePath = Path.GetTempFileName(); 
            try 
            {
                using (BinaryReader reader = new BinaryReader(cursorStream)) 
                {
                    using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Write, FileShare.None))
                    {
                        // Read the bytes from the stream, up to BUFFERSIZE 
                        byte[] cursorData = reader.ReadBytes(BUFFERSIZE);
                        int dataSize; 
 
                        // If the buffer is filled up, then write those bytes out and read more bytes up to BUFFERSIZE
                        for (dataSize = cursorData.Length; 
                             dataSize >= BUFFERSIZE;
                             dataSize = reader.Read(cursorData, 0 /*index in array*/, BUFFERSIZE /*bytes to read*/))
                        {
                            fileStream.Write(cursorData, 0 /*index in array*/, BUFFERSIZE /*bytes to write*/); 
                        }
 
                        // Write any remaining bytes 
                        fileStream.Write(cursorData, 0 /*index in array*/, dataSize /*bytes to write*/);
                    } 
                }

                // This method is called with File Write permission still asserted.
                // However, this method just reads this file into an icon. 
               _cursorHandle = UnsafeNativeMethods.LoadImageCursor(IntPtr.Zero,
                                                                    filePath, 
                                                                    NativeMethods.IMAGE_CURSOR, 
                                                                    0, 0,
                                                                    NativeMethods.LR_DEFAULTCOLOR | 
                                                                    NativeMethods.LR_LOADFROMFILE);
                if (_cursorHandle == null || SecurityHelper.SafeHandleIsInvalid(_cursorHandle))
                {
                     throw new ArgumentException(SR.Get(SRID.Cursor_InvalidStream)); 
                }
            } 
            finally 
            {
                File.Delete(filePath); 
            }
        }

        private void LoadCursorHelper(CursorType cursorType) 
        {
            if (cursorType != CursorType.None) 
            { 
                // Load a Standard Cursor
                _cursorHandle = SafeNativeMethods.LoadCursor(new HandleRef(this,IntPtr.Zero), (IntPtr)(CursorTypes[(int)cursorType])); 
            }
            this._cursorType = cursorType;
        }
 
        /// 
        /// String Output 
        /// 

        public override string ToString() 
        {
            if (_fileName != String.Empty)
                return _fileName;
            else 
            {
                // Get the string representation fo the cursor type enumeration. 
                return Enum.GetName(typeof(CursorType), _cursorType); 
            }
        } 

        private bool IsValidCursorType(CursorType cursorType)
        {
            return ((int)cursorType >= (int)CursorType.None && (int)cursorType <= (int)CursorType.ArrowCD); 
        }
 
        private string      _fileName     = String.Empty; 
        private CursorType  _cursorType   = CursorType.None;
        private SafeHandle  _cursorHandle; 

        private static readonly int[] CursorTypes = {
            0, // None
            NativeMethods.IDC_NO, 
            NativeMethods.IDC_ARROW,
            NativeMethods.IDC_APPSTARTING, 
            NativeMethods.IDC_CROSS, 
            NativeMethods.IDC_HELP,
            NativeMethods.IDC_IBEAM, 
            NativeMethods.IDC_SIZEALL,
            NativeMethods.IDC_SIZENESW,
            NativeMethods.IDC_SIZENS,
            NativeMethods.IDC_SIZENWSE, 
            NativeMethods.IDC_SIZEWE,
            NativeMethods.IDC_UPARROW, 
            NativeMethods.IDC_WAIT, 
            NativeMethods.IDC_HAND,
            NativeMethods.IDC_ARROW + 119, // PenCursor 
            NativeMethods.IDC_ARROW + 140, // ScrollNSCursor
            NativeMethods.IDC_ARROW + 141, // ScrollWECursor
            NativeMethods.IDC_ARROW + 142, // ScrollAllCursor
            NativeMethods.IDC_ARROW + 143, // ScrollNCursor 
            NativeMethods.IDC_ARROW + 144, // ScrollSCursor
            NativeMethods.IDC_ARROW + 145, // ScrollWCursor 
            NativeMethods.IDC_ARROW + 146, // ScrollECursor 
            NativeMethods.IDC_ARROW + 147, // ScrollNWCursor
            NativeMethods.IDC_ARROW + 148, // ScrollNECursor 
            NativeMethods.IDC_ARROW + 149, // ScrollSWCursor
            NativeMethods.IDC_ARROW + 150, // ScrollSECursor
            NativeMethods.IDC_ARROW + 151 // ArrowCDCursor
       }; 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK