ddcaps.cpp

DDCAPS For WinCE use under X86

{
    BOOL fProcessed = TRUE;

    Which = 7;
    switch (uMsg)
    {
        HANDLE_MSG(hDlg, WM_INITDIALOG, Dlg_OnInitDialog);
        HANDLE_MSG(hDlg, WM_COMMAND, Dlg_OnCommand);

        default:
            fProcessed = FALSE;
            break;
    }
    return (fProcessed);
}


//*------------------------------------------------------------------------
//| HELPalCapsDlg_Proc
//*------------------------------------------------------------------------
BOOL CALLBACK
HELPalCapsDlg_Proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    BOOL fProcessed = TRUE;

    Which = 8;
    switch (uMsg)
    {
        HANDLE_MSG(hDlg, WM_INITDIALOG, Dlg_OnInitDialog);
        HANDLE_MSG(hDlg, WM_COMMAND, Dlg_OnCommand);

        default:
            fProcessed = FALSE;
            break;
    }
    return (fProcessed);
}


//*------------------------------------------------------------------------
//| DDEnumCallback
//*------------------------------------------------------------------------
BOOL WINAPI
DDEnumCallbackEx(GUID *pGUID, LPTSTR pDescription, LPTSTR pName, LPVOID pContext, HMONITOR hm)
{
    if (pGUID)
    {
        Drivers[gDriverCnt].GUIDcopy = *pGUID;
        Drivers[gDriverCnt].pGUID = &Drivers[gDriverCnt].GUIDcopy;
    }
    else
        Drivers[gDriverCnt].pGUID = NULL;

    Drivers[gDriverCnt].szDescription[127] = TEXT('\0');
    Drivers[gDriverCnt].szName[127] = TEXT('\0');
    _tcsncpy(Drivers[gDriverCnt].szDescription,pDescription,127);
    _tcsncpy(Drivers[gDriverCnt].szName,pName,127);
    Drivers[gDriverCnt].hm = hm;

    if (gDriverCnt < MAX_DRIVERS)
        gDriverCnt++;
    else
        return DDENUMRET_CANCEL;

    return DDENUMRET_OK;
}

BOOL WINAPI
DDEnumCallback(GUID *pGUID, LPTSTR pDescription, LPTSTR pName, LPVOID context)
{
    return (DDEnumCallbackEx(pGUID, pDescription, pName, context, NULL));
}


//*------------------------------------------------------------------------
//| EnumModesCallback
//*------------------------------------------------------------------------
static int  gCurMode = 0;

DWORD DDAPI
EnumModesCallback(LPDDSURFACEDESC pddsd, LPVOID context)
{
    Modes[ModeCnt].dwWidth = pddsd->dwWidth;
    Modes[ModeCnt].dwHeight = pddsd->dwHeight;
    Modes[ModeCnt].dwBPP = pddsd->ddpfPixelFormat.dwRGBBitCount;
    Modes[ModeCnt].dwRefreshRate = pddsd->dwRefreshRate;

    LBPrintf(TEXT("Mode %2d: %4d x %4d  %2d bpp %d Hz"), ModeCnt, Modes[ModeCnt].dwWidth,
             Modes[ModeCnt].dwHeight, Modes[ModeCnt].dwBPP, Modes[ModeCnt].dwRefreshRate);

    if (ModeCnt < MAX_MODES)
        ModeCnt++;
    else
        return DDENUMRET_CANCEL;

    return DDENUMRET_OK;
}


//*------------------------------------------------------------------------
//| WinMain:
//|     Parameters:
//|         hInstance     - Handle to current Data Segment
//|         hPrevInstance - Always NULL in Win32
//|         lpszCmdLine   - Pointer to command line info
//|         nCmdShow      - Integer value specifying how to start app.,
//|                            (Iconic [7] or Normal [1,5])
//*------------------------------------------------------------------------
int WINAPI
WinMain(HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        LPWSTR lpszCmdLine,
        int nCmdShow)
{
    int                     nReturn = 0;
    HRESULT                 ddrval;
    HINSTANCE               hDDrawDLL;
    LPDIRECTDRAWENUMERATEEX pDirectDrawEnumerateEx;

    ghInstance = hInstance;

    // Pop up a dialog letting the user select a driver to use (if more than one)
    gpSelectedDriverGUID = NULL;

    // You need to do a GetModuleHandle and GetProcAddress in order to get the
    // DirectDrawEnumerateEx
    hDDrawDLL = GetModuleHandle(TEXT("DDRAW"));
    if (!hDDrawDLL)
    {
        OutputDebugString(TEXT("LoadLibrary() failed - ddcaps: Can't list display modes"));
        return (-1);
    }
    pDirectDrawEnumerateEx = (LPDIRECTDRAWENUMERATEEX )
        GetProcAddress(hDDrawDLL,TEXT("DirectDrawEnumerateExW"));

    if (pDirectDrawEnumerateEx)
        pDirectDrawEnumerateEx( DDEnumCallbackEx, (LPVOID) NULL,
                                DDENUM_ATTACHEDSECONDARYDEVICES |
                                DDENUM_DETACHEDSECONDARYDEVICES |
                                DDENUM_NONDISPLAYDEVICES);
    else    // Old DirectDraw, so do it the old way
        DirectDrawEnumerate(DDEnumCallback, NULL);

    ddrval = DirectDrawCreate(gpSelectedDriverGUID, &lpDD, NULL);
    if (ddrval != DD_OK)
    {
        OutputDebugString(TEXT("DirectDrawCreate failed"));
        return (-1);
    }

    // Read DirectDraw capabilities
    ReadDDrawCaps();

    if (Init(hInstance, hPrevInstance, lpszCmdLine, nCmdShow))
    {
        nReturn = DoMain(hInstance);
        CleanUp();
    }

    return nReturn;
}


//*------------------------------------------------------------------------
//| ReadDDrawCaps
//*------------------------------------------------------------------------
void ReadDDrawCaps(void)
{
    static DDCAPS ddcapsHEL, ddcapsHAL;

    ddcapsHEL.dwSize = sizeof(ddcapsHEL);
    ddcapsHAL.dwSize = sizeof(ddcapsHAL);

   // lpDD->lpVtbl->GetCaps(lpDD, &ddcapsHAL, &ddcapsHEL);
    lpDD->GetCaps( &ddcapsHAL, &ddcapsHEL);

    gCaps[0].caps = &(ddcapsHAL.dwCaps);
    gCaps[0].defs = ddCapsDefs;

    gCaps[1].caps = &(ddcapsHAL.dwCKeyCaps);
    gCaps[1].defs = CKeyCapsDefs;

    gCaps[2].caps = &(ddcapsHAL.dwFXCaps);
    gCaps[2].defs = FXCapsDefs;

    gCaps[3].caps = &(ddcapsHAL.dwPalCaps);
    gCaps[3].defs = PalCapsDefs;

    gCaps[4].caps = &(ddcapsHAL.ddsCaps.dwCaps);
    gCaps[4].defs = SurfCapsDefs;

    gCaps[5].caps = &(ddcapsHEL.dwCaps);
    gCaps[5].defs = ddCapsDefs;

    gCaps[6].caps = &(ddcapsHEL.dwCKeyCaps);
    gCaps[6].defs = CKeyCapsDefs;

    gCaps[7].caps = &(ddcapsHEL.dwFXCaps);
    gCaps[7].defs = FXCapsDefs;

    gCaps[8].caps = &(ddcapsHEL.dwPalCaps);
    gCaps[8].defs = PalCapsDefs;

    gCaps[9].caps = &(ddcapsHEL.ddsCaps.dwCaps);
    gCaps[9].defs = SurfCapsDefs;
}


//*------------------------------------------------------------------------
//| Init
//|     Initialization for the program is done here:
//|
//*------------------------------------------------------------------------
BOOL
Init(HINSTANCE hInstance, HINSTANCE hPrevInstance,
     LPTSTR lpszCmdLine, int nCmdShow)
{
    WNDCLASS rClass;
    HWND hWnd1;
    HWND hwndLB;
    HWND hwndCmdBar;
    RECT rc = { 0 };

    rClass.style = 0;
    rClass.lpfnWndProc = (WNDPROC) OverlappedWinProc;
    rClass.cbClsExtra = 0;
    rClass.cbWndExtra = 0;
    rClass.hInstance = hInstance;
    rClass.hIcon = LoadIcon(hInstance, TEXT("DDCAPS_ICON"));
    rClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    rClass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
    rClass.lpszMenuName = NULL;
    rClass.lpszClassName = szClassName;

    if (!RegisterClass(&rClass))
    {
        return FALSE;
    }

    hWnd1 = CreateWindowEx(0,
                           szClassName,
                           szAppName,
                           WS_OVERLAPPED | WS_VISIBLE | WS_DLGFRAME | WS_CAPTION,
                           CW_USEDEFAULT,
                           CW_USEDEFAULT,
                           300,
                           200,
                           NULL,
                           NULL,
                           hInstance,
                           NULL);

    if (!hWnd1)
    {
        return FALSE;
    }

    hwndCmdBar = CommandBar_Create(hInstance, hWnd1, 1);
    if (!hwndCmdBar)
    {
        return FALSE;
    }

    CommandBar_InsertMenubar(hwndCmdBar, hInstance, IDR_MENU1, 0);
    CommandBar_AddAdornments(hwndCmdBar, 0, 0);
    CommandBar_DrawMenuBar(hwndCmdBar, 0);

    GetWindowRect(hwndCmdBar, &rc);

    hwndLB = LBCreate(hWnd1, hInstance, rc.bottom-rc.top, FALSE);

    ShowWindow(hWnd1, nCmdShow);
    UpdateWindow(hWnd1);

   // lpDD->lpVtbl->EnumDisplayModes(lpDD, 0, NULL, (LPVOID) hwndLB, EnumModesCallback);
    lpDD->EnumDisplayModes(0, NULL, (LPVOID) hwndLB,(long (__cdecl *)(struct _DDSURFACEDESC *,void *)) EnumModesCallback);

    // highlight the current mode
    SendMessage(hwndLB, LB_SETCURSEL, gCurMode, 0L);

    return (int) hWnd1;
}

//*------------------------------------------------------------------------
//| DoMain:
//|     This is the main loop for the application:
//*------------------------------------------------------------------------
int
DoMain(HINSTANCE hInstance)
{
    MSG msg;

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return msg.wParam;
}

//*------------------------------------------------------------------------
//| CleanUp:
//|     Any last-minute application cleanup activities are done here:
//*------------------------------------------------------------------------
void
CleanUp(void)
{
}

//*------------------------------------------------------------------------
//| OverlappedWinProc:
//|
//*------------------------------------------------------------------------
LRESULT WINAPI
OverlappedWinProc(HWND hWnd,
                   UINT wMsgID,
                   UINT wParam,
                   LPARAM lParam)
{
    UINT sel;
    HRESULT ddrval;

    switch (wMsgID)
    {
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case ID_FILE_EXIT:
                    SendMessage(hWnd, WM_CLOSE, 0, 0L);
                    break;

                case IDD_ABOUT:
                    DialogBox(ghInstance, TEXT("About"), hWnd, (DLGPROC)AboutDlgProc);
                    break;

                case ID_VIEW_DRIVERCAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, ddCapsDlg_Proc);
                    break;

                case ID_VIEW_DRIVERCOLORKEYCAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, CKeyCapsDlg_Proc);
                    break;

                case ID_VIEW_DRIVERFXCAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, FXCapsDlg_Proc);
                    break;

                case ID_VIEW_DRIVERPALETTECAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, PalCapsDlg_Proc);
                    break;

                case ID_VIEW_DRIVERSURFACECAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, SurfCapsDlg_Proc);
                    break;

                case ID_VIEW_HELCAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, HELddCapsDlg_Proc);
                    break;

                case ID_VIEW_HELCOLORKEYCAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, HELCKeyCapsDlg_Proc);
                    break;

                case ID_VIEW_HELFXCAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, HELFXCapsDlg_Proc);
                    break;

                case ID_VIEW_HELPALETTECAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, HELPalCapsDlg_Proc);
                    break;

                case ID_VIEW_HELSURFACECAPS:
                    CreateDialog(ghInstance, MAKEINTRESOURCE(IDD_DIALOG1),
                                 NULL, HELSurfCapsDlg_Proc);
                    break;

                case ID_PRINTF_LISTBOX:
                    if (HIWORD(wParam) == LBN_DBLCLK)
                    {
                        sel = (UINT) SendMessage((HWND) lParam, LB_GETCURSEL, 0,
                                                 0L);
                        if (sel < (UINT)ModeCnt)
                        {
                            //ddrval = lpDD->lpVtbl->SetCooperativeLevel(lpDD,
							ddrval = lpDD->SetCooperativeLevel(hWnd,
                                                        DDSCL_EXCLUSIVE |
                                                        DDSCL_NOWINDOWCHANGES |
                                                        DDSCL_FULLSCREEN);
                            if (ddrval == DD_OK)
                            {
                                //ddrval = lpDD->lpVtbl->SetDisplayMode(lpDD,
								ddrval = lpDD->SetDisplayMode(Modes[sel].dwWidth,
                                                        Modes[sel].dwHeight,
                                                        Modes[sel].dwBPP);
                                //ddrval = lpDD->lpVtbl->SetCooperativeLevel(lpDD,
							    ddrval = lpDD->SetCooperativeLevel(hWnd, DDSCL_NORMAL);
                            }
                        }
                    }
                    else if (HIWORD(wParam) == LBN_SETFOCUS)
                    {
                        SendMessage((HWND) lParam, LB_SETCURSEL, gCurMode, 0L);
                    }
                    break;
            }
            break;

        case WM_PAINT:
            {
                PAINTSTRUCT ps;

                BeginPaint(hWnd, &ps);
                EndPaint(hWnd, &ps);
            }
            break;

        case WM_SIZE:
            LBSize(LOWORD(lParam), HIWORD(lParam));
            break;

        case WM_DESTROY:
            PostQuitMessage(0);
            break;

        default:
            return DefWindowProc(hWnd, wMsgID, wParam, lParam);
    }
    return 0;
}


//================================================================
//  About - process about box
//================================================================
LRESULT CALLBACK AboutDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_INITDIALOG:
            return(TRUE);

        case WM_COMMAND:                      // message: received a command
            if(LOWORD(wParam) == IDOK         // "OK" box selected?
            || LOWORD(wParam) == IDCANCEL) {  // System menu close command?
                EndDialog(hDlg, TRUE);        // Exit the dialog
                return(TRUE);
            }
            break;
    }
    return(FALSE); // Didn't process the message
}