smbrdr.c

winddk src目录下的文件系统驱动源码压缩!

    }
    break;

    case WM_RDRSTATECHANGE:
    {
        //Enter();
        PDLGDATASTRUCT pdds = GetDDS( hDlg );

        // must be a transitional state

        if ( (ULONG_PTR) lParam != pdds->RdrState )
        {
            pdds->RdrState = (ULONG_PTR) lParam;
            EnableWindow( GetDlgItem( hDlg, IDC_DRVLOAD ),
                    ( pdds->RdrState == RDR_UNLOADED )|| ( pdds->RdrState == RDR_LOADED ) || ( pdds->RdrState == RDR_STOPPED ));
            EnableWindow( GetDlgItem( hDlg, IDC_DRVUNLOAD ),
                    ( pdds->RdrState == RDR_UNLOADED )|| ( pdds->RdrState == RDR_LOADED ) || ( pdds->RdrState == RDR_STOPPED ));

            EnableWindow( GetDlgItem( hDlg, IDC_RDRSTART ),
                    (pdds->RdrState == RDR_LOADED )||(pdds->RdrState == RDR_STOPPED) || (pdds->RdrState == RDR_STARTED ) );
            EnableWindow( GetDlgItem( hDlg, IDC_RDRSTOP ),
                    (pdds->RdrState == RDR_LOADED )||(pdds->RdrState == RDR_STOPPED) || (pdds->RdrState == RDR_STARTED ) );

            switch ( lParam )
            {
                case RDR_UNLOADED:
                    SetDlgItemText( hDlg, IDC_LOADSTATUS, TEXT("Driver Unloaded" ) );
                    break;

                case RDR_UNLOADING:
                    SetDlgItemText( hDlg, IDC_LOADSTATUS, TEXT("Driver Unloading" ) );
                    InitiateAction( pdds );
                    break;

                case RDR_LOADING:
                    SetDlgItemText( hDlg, IDC_LOADSTATUS, TEXT("Driver Loading" ) );
                    InitiateAction( pdds );
                    break;
                case RDR_LOADED:
                    SetDlgItemText( hDlg, IDC_LOADSTATUS, TEXT("Driver Loaded" ) );
                    break;

                case RDR_STOPPING:
                    SetDlgItemText( hDlg, IDC_STARTSTATUS, TEXT("RDR Stopping" ) );
                    InitiateAction( pdds );
                    break;

                case RDR_STOPPED:
                    SetDlgItemText( hDlg, IDC_STARTSTATUS, TEXT("RDR Stopped" ) );
                    pdds->ElapsedStartTime = 0;
                    SetDlgItemText( hDlg, IDC_STARTTIME, TEXT( "00:00" ) );
                    break;

                case RDR_STARTING:
                    SetDlgItemText( hDlg, IDC_STARTSTATUS, TEXT("RDR Starting" ) );
                    InitiateAction( pdds );
                    break;

                case RDR_STARTED:
                    SetDlgItemText( hDlg, IDC_STARTSTATUS, TEXT("RDR Started" ) );
                    break;

                default:
                    break;
            }
        }
        if ( pdds->Action == ACTION_ERROR )
        {
            MessageBox( hDlg, OPERROR, APP_TITLE, MB_OK | MB_ICONERROR );
        }
//Leave();
    }
    break;

    case WM_TIMER:
    {
        TCHAR timestring[8];

        PDLGDATASTRUCT pdds = GetDDS( hDlg );
        if ( wParam == TIMER_ID && pdds->RdrState > RDR_STOPPED )
        {
            pdds->ElapsedStartTime++;
            wsprintf( timestring, TEXT("%02d:%02d"), pdds->ElapsedStartTime / 60,
                        pdds->ElapsedStartTime % 60 );
            SetDlgItemText( hDlg, IDC_STARTTIME, timestring );
        }
    }
    break;

    case WM_CTLCOLORSTATIC:
    {
        PDLGDATASTRUCT pdds = GetDDS( hDlg );
        HBRUSH hBkBrush;

        switch ( GetWindowLongPtr( (HWND) lParam, GWL_ID ) )
        {
            case IDC_DRVCONTROLTEXT:
            case IDC_RDRCONTROLTEXT:
            case IDC_SETTINGSTEXT:
                SetBkMode( (HDC) wParam, TRANSPARENT );
                hBkBrush = pdds->hWhtBrush;
                break;

            case IDC_LOADSTATUS:
            {
                SetBkMode( (HDC) wParam, TRANSPARENT );
                if ( pdds->RdrState < RDR_UNLOADING )
                {
                    hBkBrush = pdds->hRedBrush;
                }
                else if (  pdds->RdrState < RDR_LOADED )
                {
                    hBkBrush = pdds->hYelBrush;
                }
                else
                {
                    hBkBrush = pdds->hGrnBrush;
                }
            }
            break;

            case IDC_STARTSTATUS:
            {
                SetBkMode( (HDC) wParam, TRANSPARENT );
                if ( pdds->RdrState < RDR_STOPPING )
                {
                    hBkBrush = pdds->hRedBrush;
                }
                else if (  pdds->RdrState < RDR_STARTED )
                {
                    hBkBrush = pdds->hYelBrush;
                }
                else
                {
                    hBkBrush = pdds->hGrnBrush;
                }
            }
            break;

            case IDC_BUSY:
            default:
                hBkBrush = (HBRUSH) FALSE;
                break;
        }

        return (INT_PTR) hBkBrush;
    }
    break;


    case WM_SETICON:
    {
        // catch it on the second pass so it has the previous icon to now draw
        if ( wParam == ICON_BIG )
        {
            ShowWindow( hDlg, SW_SHOWNORMAL );
        }
    }
    break;

    case WM_SHNOTIFY:
    {
        if ( wParam == IDI_SMBRDR )
        {
            if ( lParam == WM_LBUTTONDBLCLK )
            {
                if ( IsWindowVisible( hDlg ) )
                {
                    SetForegroundWindow( hDlg );
                }
                else
                {
                    ShowWindow( hDlg, SW_RESTORE );
                }
            }
            else if ( lParam == WM_RBUTTONDOWN && !IsWindowVisible( hDlg ) )
            {
                HMENU hPopup = CreatePopupMenu( );
                POINT cursorpos;
                HWND hfgrd;
                ULONG_PTR popselect;
                                                
                GetCursorPos( &cursorpos );

                if ( hPopup )
                {
                    PDLGDATASTRUCT pdds = GetDDS( hDlg );
                    MENUITEMINFO mii;
                    
                    ZeroMemory( &mii, sizeof( MENUITEMINFO ) );
                    mii.cbSize = sizeof( MENUITEMINFO );
                    mii.fMask = MIIM_DATA | MIIM_ID | MIIM_TYPE;
                    mii.fType = MFT_STRING;

                    mii.wID = IDM_OPEN;
                    mii.fState = MFS_DEFAULT;
                    mii.fMask |= MIIM_STATE;
                    mii.dwTypeData = TEXT("Open ") APP_TITLE TEXT(" Control");
                    InsertMenuItem( hPopup, 0, TRUE, &mii );

                    mii.wID = IDM_CLOSE;
                    mii.fMask &= ~MIIM_STATE;
                    mii.fState &= ~MFS_DEFAULT;
                    mii.dwTypeData = TEXT("Exit");
                    InsertMenuItem( hPopup, 1, TRUE, &mii );

                    if ( ( pdds->RdrState == RDR_STOPPED ) ||
                            (pdds->RdrState == RDR_STARTED ) ||
                            (pdds->RdrState == RDR_LOADED ) )
                    {
                        mii.wID = 0;
                        mii.fMask = MIIM_TYPE;
                        mii.dwTypeData = NULL;
                        mii.fType = MFT_SEPARATOR;
                        InsertMenuItem( hPopup, 2, TRUE, &mii );

                        mii.fType = MFT_STRING;
                        mii.fMask = MIIM_DATA | MIIM_ID | MIIM_TYPE;
                        if ( ( pdds->RdrState == RDR_STOPPED ) ||
                                (pdds->RdrState == RDR_LOADED ) )
                        {
                            mii.wID = IDM_START;
                            mii.dwTypeData = TEXT( "Start the RDR" );
                            InsertMenuItem( hPopup, 3, TRUE, &mii );
                        }
                        else if ( pdds->RdrState == RDR_STARTED )
                        {
                            mii.wID = IDM_STOP;
                            mii.dwTypeData = TEXT( "Stop the RDR" );
                            InsertMenuItem( hPopup, 3, TRUE, &mii );
                        }
                    }

                    SetActiveWindow( hDlg );

                    popselect = TrackPopupMenu( hPopup,
                                      TPM_LEFTBUTTON | TPM_RIGHTALIGN | TPM_BOTTOMALIGN |
                                      TPM_NONOTIFY | TPM_RETURNCMD,
                                      cursorpos.x,
                                      cursorpos.y,
                                      0,
                                      hDlg,
                                      NULL );
                    DestroyMenu( hPopup );

                    switch ( popselect )
                    {
                        case IDM_OPEN:
                        {
                            ShowWindow( hDlg, SW_SHOWNORMAL );
                        }
                        break;

                        case IDM_CLOSE:
                        {
                            PostMessage( hDlg, WM_CLOSE, 0, 0 );
                        }
                        break;

                        case IDM_START:
                        {
                            CheckRadioButton( hDlg, IDC_RDRSTART, IDC_RDRSTOP, IDC_RDRSTART );
                            PostMessage( hDlg, WM_COMMAND, MAKELONG(IDC_RDRSTART, BN_CLICKED),
                                        (LPARAM) GetDlgItem( hDlg, IDC_RDRSTART) );
                        }
                        break;

                        case IDM_STOP:
                        {
                            CheckRadioButton( hDlg, IDC_RDRSTART, IDC_RDRSTOP, IDC_RDRSTOP );
                            PostMessage( hDlg, WM_COMMAND, MAKELONG(IDC_RDRSTOP, BN_CLICKED),
                                        (LPARAM) GetDlgItem( hDlg, IDC_RDRSTOP) );
                        }
                        break;

                        default:
                            break;
                    }
                }
            }
        }
    }
    break;

    case WM_SYSCOMMAND:
    {
        if ( wParam == SC_MINIMIZE )
        {
            ShowWindow( hDlg, SW_HIDE );
            return TRUE;            
        }   
    }
    break;

    case WM_CLOSE:
    {
        PDLGDATASTRUCT pdds = GetDDS( hDlg );

        if ( pdds->hActionThread )
        {
            if ( WaitForSingleObject( pdds->hActionThread, 0 ) != WAIT_OBJECT_0 )