ZForge.Win32.RemovableDriveDetector.WndProc C# (CSharp) Method

WndProc() public method

Message handler which must be called from client form. Processes Windows messages and calls event handlers.
public WndProc ( Message &m ) : void
m Message
return void
        public void WndProc(ref Message m)
        {
            int devType;
            char c;

            try
            {
                if (m.Msg == WM_DEVICECHANGE)
                {
                    // WM_DEVICECHANGE can have several meanings depending on the WParam value...
                    switch (m.WParam.ToInt32())
                    {
                        case DBT_DEVNODES_CHANGED:
                            RemovableDriveDetectorEventHandler tempDeviceChanged = DeviceChanged;
                            if (tempDeviceChanged != null)
                            {
                                RemovableDriveDetectorEventArgs e = new RemovableDriveDetectorEventArgs();
                                tempDeviceChanged(this, e);
                            }
                            break;
                        //
                        // New device has just arrived
                        //
                        case DBT_DEVICEARRIVAL:

                            devType = Marshal.ReadInt32(m.LParam, 4);
                            if (devType == DBT_DEVTYP_VOLUME)
                            {
                                DEV_BROADCAST_VOLUME vol;
                                vol = (DEV_BROADCAST_VOLUME)
                                        Marshal.PtrToStructure(m.LParam, typeof(DEV_BROADCAST_VOLUME));

                                // Get the drive letter
                                c = DriveMaskToLetter(vol.dbcv_unitmask);

                                //
                                // Call the client event handler
                                //
                                // We should create copy of the event before testing it and
                                // calling the delegate - if any
                                RemovableDriveDetectorEventHandler tempDeviceArrived = DeviceArrived;
                                if (tempDeviceArrived != null)
                                {
                                    RemovableDriveDetectorEventArgs e = new RemovableDriveDetectorEventArgs();
                                    e.Drive = c + ":\\";
                                    tempDeviceArrived(this, e);

                                    // Register for query remove if requested
                                    if (e.HookQueryRemove)
                                    {
                                        // If something is already hooked, unhook it now
                                        if (mDeviceNotifyHandle != IntPtr.Zero)
                                        {
                                            RegisterForDeviceChange(false, null);
                                        }

                                        RegisterQuery(c + ":\\");
                                    }
                                }     // if  has event handler

                            }
                            break;

                        //
                        // Device is about to be removed
                        // Any application can cancel the removal
                        //
                        case DBT_DEVICEQUERYREMOVE:

                            devType = Marshal.ReadInt32(m.LParam, 4);
                            if (devType == DBT_DEVTYP_HANDLE)
                            {
                                // TODO: we could get the handle for which this message is sent
                                // from vol.dbch_handle and compare it against a list of handles for
                                // which we have registered the query remove message (?)
                                //DEV_BROADCAST_HANDLE vol;
                                //vol = (DEV_BROADCAST_HANDLE)
                                //   Marshal.PtrToStructure(m.LParam, typeof(DEV_BROADCAST_HANDLE));
                                // if ( vol.dbch_handle ....

                                //
                                // Call the event handler in client
                                //
                                RemovableDriveDetectorEventHandler tempQuery = DeviceQueryRemove;
                                if (tempQuery != null)
                                {
                                    RemovableDriveDetectorEventArgs e = new RemovableDriveDetectorEventArgs();
                                    e.Drive = mCurrentDrive;        // drive which is hooked
                                    tempQuery(this, e);

                                    // If the client wants to cancel, let Windows know
                                    if (e.Cancel)
                                    {
                                        m.Result = (IntPtr)BROADCAST_QUERY_DENY;
                                    }
                                    else
                                    {
                                        // Change 28.10.2007: Unregister the notification, this will
                                        // close the handle to file or root directory also.
                                        // We have to close it anyway to allow the removal so
                                        // even if some other app cancels the removal we would not know about it...
                                        RegisterForDeviceChange(false, null);   // will also close the mFileOnFlash
                                    }

                                }
                            }
                            break;

                        //
                        // Device has been removed
                        //
                        case DBT_DEVICEREMOVECOMPLETE:

                            devType = Marshal.ReadInt32(m.LParam, 4);
                            if (devType == DBT_DEVTYP_VOLUME)
                            {
                                devType = Marshal.ReadInt32(m.LParam, 4);
                                if (devType == DBT_DEVTYP_VOLUME)
                                {
                                    DEV_BROADCAST_VOLUME vol;
                                    vol = (DEV_BROADCAST_VOLUME)
                                            Marshal.PtrToStructure(m.LParam, typeof(DEV_BROADCAST_VOLUME));
                                    c = DriveMaskToLetter(vol.dbcv_unitmask);

                                    //
                                    // Call the client event handler
                                    //
                                    RemovableDriveDetectorEventHandler tempDeviceRemoved = DeviceRemoved;
                                    if (tempDeviceRemoved != null)
                                    {
                                        RemovableDriveDetectorEventArgs e = new RemovableDriveDetectorEventArgs();
                                        e.Drive = c + ":\\";
                                        tempDeviceRemoved(this, e);
                                    }

                                    // TODO: we could unregister the notify handle here if we knew it is the
                                    // right drive which has been just removed
                                    //RegisterForDeviceChange(false, null);
                                }
                            }
                            break;
                    }

                }
            }
            catch (Exception)
            {
            }
        }

Usage Example

        /// <summary>
        /// This function receives all the windows messages for this window (form).
        /// We call the DriveDetector from here so that is can pick up the messages about
        /// drives arrived and removed.
        /// </summary>
        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            if (mDetector != null)
            {
                mDetector.WndProc(ref m);
            }
        }