Esempio n. 1
0
        void USBDetector_DeviceArrived(object sender, DriveDetectorEventArgs e)
        {
            if (Arrived)
            {
                return;
            }
            Arrived = true;

            Program.logEvent("USB device has been detected");
            SetLabelText(label, LanguageTranslation.IMPORTING);

            //open file choose dialog
            if (ImportType == ImportType.User)
            {
                FileChooser.InitialDirectory = Path.Combine(e.Drive, "Users.xml");
                DestinationFileName          = Path.Combine(System.Windows.Forms.Application.StartupPath, "Users.xml");
            }
            else if (ImportType == ImportType.AccessCode)
            {
                FileChooser.InitialDirectory = Path.Combine(e.Drive, "keypasswords.xml");
                DestinationFileName          = Path.Combine(System.Windows.Forms.Application.StartupPath, "keypasswords.xml");
            }
            FileChooser.ShowDialog();
        }
Esempio n. 2
0
 void USBDetector_DeviceRemoved(object sender, DriveDetectorEventArgs e)
 {
     Program.logEvent("USB Device Removed");
     this.Close();
     resetCurrentWorkingDirectory();
 }
Esempio n. 3
0
        /// <summary>
        /// Message handler which must be called from client form.
        /// Processes Windows messages and calls event handlers.
        /// </summary>
        /// <param name="m"></param>
        public void WndProc(ref Message m)
        {
            int  devType;
            char c;

            if (m.Msg == WM_DEVICECHANGE)
            {
                // WM_DEVICECHANGE can have several meanings depending on the WParam value...
                switch (m.WParam.ToInt32())
                {
                //
                // 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
                        DriveDetectorEventHandler tempDeviceArrived = DeviceArrived;
                        if (tempDeviceArrived != null)
                        {
                            DriveDetectorEventArgs e = new DriveDetectorEventArgs();
                            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
                        //
                        DriveDetectorEventHandler tempQuery = QueryRemove;
                        if (tempQuery != null)
                        {
                            DriveDetectorEventArgs e = new DriveDetectorEventArgs();
                            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
                            //
                            DriveDetectorEventHandler tempDeviceRemoved = DeviceRemoved;
                            if (tempDeviceRemoved != null)
                            {
                                DriveDetectorEventArgs e = new DriveDetectorEventArgs();
                                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;
                }
            }
        }