ddcaps.cpp

DDCAPS For WinCE use under X86

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//=========================================================================
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//  PURPOSE.
//
//
//=========================================================================

#ifndef STRICT
#define STRICT
#endif


#include "stdafx.h"
#include <WINDOWS.H>
#include <WINDOWSX.H>
#include <commctrl.h>

#pragma pack(4)

#include "DDCAPS.H"
#include "RESOURCE.H"
#include "DDRAWI.H"
#include "lbprintf.h"

#pragma pack()
//#define UNDER_CE
//
//  Constants
//
#define MAX_MODES   256         // 256 display modes maximum
#define MAX_BOXES   32
#define MAX_DRIVERS 32          // 32 drivers maximum


//
//  Function prototypes
//
LRESULT CALLBACK AboutDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
static void ReadDDrawCaps(void);

//
//  Structures
//
struct _modes
{
    DWORD dwWidth;
    DWORD dwHeight;
    DWORD dwBPP;
    DWORD dwRefreshRate;
} Modes[MAX_MODES];

typedef struct capsDef          // hold caps definitions
{
    TCHAR *szName;
    DWORD dwPos;
}
CAPSDEFSTYPE, *LPCAPSDEFSTYPE;

struct _gcaps
{
    LPDWORD caps;
    LPCAPSDEFSTYPE defs;

} gCaps[10];

struct
{
    TCHAR       szDescription[128];
    TCHAR       szName[128];
    GUID        *pGUID;
    GUID        GUIDcopy;
    HMONITOR    hm;
} Drivers[MAX_DRIVERS];


//
//  Global data
//
int Which = 0;
int ModeCnt = 0;                // keeps track of number of modes

HINSTANCE ghInstance;
TCHAR szClassName[] = TEXT("DdrawCaps");
TCHAR szAppName[]   = TEXT("Direct Draw Caps");

int gDriverCnt = 0;             // keeps track of number of drivers
GUID *gpSelectedDriverGUID;

LPDIRECTDRAW lpDD;              // DirectDraw object

// Map caps bits to readable strings
CAPSDEFSTYPE ddCapsDefs[MAX_BOXES] =
{
    {TEXT("3D"), DDCAPS_3D},
    {TEXT("ALIGNBOUNDARYDEST"), DDCAPS_ALIGNBOUNDARYDEST},
    {TEXT("ALIGNSIZEDEST"), DDCAPS_ALIGNSIZEDEST},
    {TEXT("ALIGNBOUNDARYSRC"), DDCAPS_ALIGNBOUNDARYSRC},
    {TEXT("ALIGNSIZESRC"), DDCAPS_ALIGNSIZESRC},
    {TEXT("ALIGNSTRIDE"), DDCAPS_ALIGNSTRIDE},
    {TEXT("BLT"), DDCAPS_BLT},
    {TEXT("BLTQUEUE"), DDCAPS_BLTQUEUE},
    {TEXT("BLTFOURCC"), DDCAPS_BLTFOURCC},
    {TEXT("BLTSTRETCH"), DDCAPS_BLTSTRETCH},
    {TEXT("GDI"), DDCAPS_GDI},
    {TEXT("OVERLAY"), DDCAPS_OVERLAY},
    {TEXT("OVERLAYCANTCLIP"), DDCAPS_OVERLAYCANTCLIP},
    {TEXT("OVERLAYFOURCC"), DDCAPS_OVERLAYFOURCC},
    {TEXT("OVERLAYSTRETCH"), DDCAPS_OVERLAYSTRETCH},
    {TEXT("PALETTE"), DDCAPS_PALETTE},
    {TEXT("PALETTEVSYNC"), DDCAPS_PALETTEVSYNC},
    {TEXT("READSCANLINE"), DDCAPS_READSCANLINE},
    {TEXT("STEREOVIEW"), DDCAPS_STEREOVIEW},
    {TEXT("VBI"), DDCAPS_VBI},
    {TEXT("ZBLTS"), DDCAPS_ZBLTS},
    {TEXT("ZOVERLAYS"), DDCAPS_ZOVERLAYS},
    {TEXT("COLORKEY"), DDCAPS_COLORKEY},
    {TEXT("ALPHA"), DDCAPS_ALPHA},
    {TEXT("CKEYHWASSIST"), DDCAPS_COLORKEYHWASSIST},
    {TEXT("NOHARDWARE"), DDCAPS_NOHARDWARE},
    {TEXT("BLTCOLORFILL"), DDCAPS_BLTCOLORFILL},
    {TEXT("BANKSWITCHED"), DDCAPS_BANKSWITCHED},
    {TEXT("BLTDEPTHFILL"), DDCAPS_BLTDEPTHFILL},
    {TEXT("CANCLIP"), DDCAPS_CANCLIP},
    {TEXT("CANCLIPSTRETCHED"), DDCAPS_CANCLIPSTRETCHED},
};

CAPSDEFSTYPE CKeyCapsDefs[MAX_BOXES] =
{
    {TEXT("DESTBLT"), DDCKEYCAPS_DESTBLT},
    {TEXT("DESTBLTCLRSPACE"), DDCKEYCAPS_DESTBLTCLRSPACE},
    {TEXT("DESTBLTCLRSPACEYUV"), DDCKEYCAPS_DESTBLTCLRSPACEYUV},
    {TEXT("DESTBLTYUV"), DDCKEYCAPS_DESTBLTYUV},
    {TEXT("DESTOVERLAY"), DDCKEYCAPS_DESTOVERLAY},
    {TEXT("DESTOVERLAYCLRSPACE"), DDCKEYCAPS_DESTOVERLAYCLRSPACE},
    {TEXT("DESTOVERLAYCLRSPACEYUV"), DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV},
    {TEXT("DESTOVERLAYONEACTIVE"), DDCKEYCAPS_DESTOVERLAYONEACTIVE},
    {TEXT("DESTOVERLAYYUV"), DDCKEYCAPS_DESTOVERLAYYUV},
    {TEXT("SRCBLT"), DDCKEYCAPS_SRCBLT},
    {TEXT("SRCBLTCLRSPACE"), DDCKEYCAPS_SRCBLTCLRSPACE},
    {TEXT("SRCBLTCLRSPACEYUV"), DDCKEYCAPS_SRCBLTCLRSPACEYUV},
    {TEXT("SRCBLTYUV"), DDCKEYCAPS_SRCBLTYUV},
    {TEXT("SRCOVERLAY"), DDCKEYCAPS_SRCOVERLAY},
    {TEXT("SRCOVERLAYCLRSPACE"), DDCKEYCAPS_SRCOVERLAYCLRSPACE},
    {TEXT("SRCOVERLAYCLRSPACEYUV"), DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV},
    {TEXT("SRCOVERLAYONEACTIVE"), DDCKEYCAPS_SRCOVERLAYONEACTIVE},
    {TEXT("SRCOVERLAYYUV"), DDCKEYCAPS_SRCOVERLAYYUV}
};

CAPSDEFSTYPE FXCapsDefs[MAX_BOXES] =
{
    { TEXT("BLTARITHSTRETCHY"), DDFXCAPS_BLTARITHSTRETCHY },
    { TEXT("BLTARITHSTRETCHYN"), DDFXCAPS_BLTARITHSTRETCHYN },
    { TEXT("BLTMIRRORLEFTRIGHT"), DDFXCAPS_BLTMIRRORLEFTRIGHT },
    { TEXT("BLTMIRRORUPDOWN"), DDFXCAPS_BLTMIRRORUPDOWN },
    { TEXT("BLTROTATION"), DDFXCAPS_BLTROTATION },
    { TEXT("BLTROTATION90"), DDFXCAPS_BLTROTATION90 },
    { TEXT("BLTSHRINKX"), DDFXCAPS_BLTSHRINKX },
    { TEXT("BLTSHRINKXN"), DDFXCAPS_BLTSHRINKXN },
    { TEXT("BLTSHRINKY"), DDFXCAPS_BLTSHRINKY },
    { TEXT("BLTSHRINKYN"), DDFXCAPS_BLTSHRINKYN },
    { TEXT("BLTSTRETCHX"), DDFXCAPS_BLTSTRETCHX },
    { TEXT("BLTSTRETCHXN"), DDFXCAPS_BLTSTRETCHXN },
    { TEXT("BLTSTRETCHY"), DDFXCAPS_BLTSTRETCHY },
    { TEXT("BLTSTRETCHYN"), DDFXCAPS_BLTSTRETCHYN },
    { TEXT("OVERLAYARITHSTRETCHY"), DDFXCAPS_OVERLAYARITHSTRETCHY },
    { TEXT("OVERLAYARITHSTRETCHYN"), DDFXCAPS_OVERLAYARITHSTRETCHYN },
    { TEXT("OVERLAYSHRINKX"), DDFXCAPS_OVERLAYSHRINKX },
    { TEXT("OVERLAYSHRINKXN"), DDFXCAPS_OVERLAYSHRINKXN },
    { TEXT("OVERLAYSHRINKY"), DDFXCAPS_OVERLAYSHRINKY },
    { TEXT("OVERLAYSHRINKYN"), DDFXCAPS_OVERLAYSHRINKYN },
    { TEXT("OVERLAYSTRETCHX"), DDFXCAPS_OVERLAYSTRETCHX },
    { TEXT("OVERLAYSTRETCHXN"), DDFXCAPS_OVERLAYSTRETCHXN },
    { TEXT("OVERLAYSTRETCHY"), DDFXCAPS_OVERLAYSTRETCHY },
    { TEXT("OVERLAYSTRETCHYN"), DDFXCAPS_OVERLAYSTRETCHYN },
    { TEXT("OVERLAYMIRRORLEFTRIGHT"), DDFXCAPS_OVERLAYMIRRORLEFTRIGHT },
    { TEXT("OVERLAYMIRRORUPDOWN"), DDFXCAPS_OVERLAYMIRRORUPDOWN },
};

CAPSDEFSTYPE PalCapsDefs[MAX_BOXES] =
{
    {TEXT("1BIT"), DDPCAPS_1BIT},
    {TEXT("2BIT"), DDPCAPS_2BIT},
    {TEXT("4BIT"), DDPCAPS_4BIT},
    {TEXT("8BITENTRIES"), DDPCAPS_8BITENTRIES},
    {TEXT("8BIT"), DDPCAPS_8BIT},
    {TEXT("ALLOW256"), DDPCAPS_ALLOW256},
    {TEXT("INITIALIZE"), DDPCAPS_INITIALIZE},
    {TEXT("PRIMARYSURFACE"), DDPCAPS_PRIMARYSURFACE},
    {TEXT("PRIMARYSURFACELEFT"), DDPCAPS_PRIMARYSURFACELEFT},
    {TEXT("VSYNC"), DDPCAPS_VSYNC}
};

CAPSDEFSTYPE SurfCapsDefs[MAX_BOXES] =
{
    {TEXT("3DDEVICE"), DDSCAPS_3DDEVICE},
    {TEXT("ALPHA"), DDSCAPS_ALPHA},
    {TEXT("BACKBUFFER"), DDSCAPS_BACKBUFFER},
    {TEXT("COMPLEX"), DDSCAPS_COMPLEX},
    {TEXT("FLIP"), DDSCAPS_FLIP},
    {TEXT("FRONTBUFFER"), DDSCAPS_FRONTBUFFER},
    {TEXT("MIPMAP"), DDSCAPS_MIPMAP},
    {TEXT("OFFSCREENPLAIN"), DDSCAPS_OFFSCREENPLAIN},
    {TEXT("OVERLAY"), DDSCAPS_OVERLAY},
    {TEXT("PALETTE"), DDSCAPS_PALETTE},
    {TEXT("PRIMARYSURFACE"), DDSCAPS_PRIMARYSURFACE},
    {TEXT("PRIMARYSURFACELEFT"), DDSCAPS_PRIMARYSURFACELEFT},
    {TEXT("SYSTEMMEMORY"), DDSCAPS_SYSTEMMEMORY},
    {TEXT("TEXTURE"), DDSCAPS_TEXTURE},
    {TEXT("VIDEOMEMORY"), DDSCAPS_VIDEOMEMORY},
    {TEXT("VISIBLE"), DDSCAPS_VISIBLE},
    {TEXT("WRITEONLY"), DDSCAPS_WRITEONLY},
    {TEXT("ZBUFFER"), DDSCAPS_ZBUFFER}
};



//*------------------------------------------------------------------------
//| Dlg_OnCommand
//*------------------------------------------------------------------------
BOOL
Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
    switch (id)
    {
        case IDCANCEL:
        case IDC_EXIT:
            DestroyWindow(hwnd);
            break;
    }

    return TRUE;
}


//*------------------------------------------------------------------------
//| Dlg_OnInitDialog
//*------------------------------------------------------------------------
BOOL
Dlg_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
{
    int i;
    TCHAR szTitle[256];
    static TCHAR *rgszCaps[] = {
        TEXT("Direct Draw Caps Bits"),
        TEXT("Direct Draw Color Key Caps Bits"),
        TEXT("Direct Draw FX Caps Bits"),
        TEXT("Direct Draw Palette Caps Bits"),
        TEXT("Direct Draw Surface Caps Bits")};

    wsprintf(szTitle, TEXT("%s (%s)"), rgszCaps[Which%5],
            (Which < 5) ? TEXT("HAL") : TEXT("HEL"));
    SetWindowText(hwnd, szTitle);

    ShowWindow(GetDlgItem(hwnd, IDC_RESTORE), SW_HIDE);
    ShowWindow(GetDlgItem(hwnd, IDC_REFRESH), SW_HIDE);

    for (i = 0; i < MAX_BOXES; i++)
    {
        if (gCaps[Which].defs[i].szName == NULL)
        {
            SetDlgItemText(hwnd, i + IDC_CHECK1, TEXT(""));
            ShowWindow( GetDlgItem(hwnd, i + IDC_CHECK1), SW_HIDE );
        }
        else
        {
            SetDlgItemText(hwnd, i + IDC_CHECK1, gCaps[Which].defs[i].szName);
            ShowWindow( GetDlgItem(hwnd, i + IDC_CHECK1), SW_SHOW );
        }
        CheckDlgButton(hwnd, i + IDC_CHECK1,
                       (gCaps[Which].defs[i].dwPos & *gCaps[Which].caps) != 0);
    }
    return TRUE;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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

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

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

//*------------------------------------------------------------------------
//| HELFXCapsDlg_Proc
//*------------------------------------------------------------------------
BOOL CALLBACK
HELFXCapsDlg_Proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)