Windows编程

开发平台：
Visual C++

DATACONV.C：源码内容
							/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
    dataconv.c
Abstract:
    This source file implements data conversion routines that know
    the format of Windows 95 screen saver settings and can convert
    them to the Windows NT format.
Author:
    Jim Schmidt (jimschm) 14-Apr-1997
Revision History:
--*/
#include "pch.h"
static CHAR g_Data[MAX_PATH];
BOOL
pHasSpecialProcessing (
    IN      LPCSTR ScreenSaverName
    );
BOOL
pTranslateBezier (
    IN      HKEY RegRoot
    );
BOOL
pTranslateMarquee (
    IN      HKEY RegRoot
    );
HKEY
pCreateControlPanelKey (
    IN      HKEY RootKey,
    IN      LPCSTR SubKeyName,
    IN      BOOL CreateEmptyKey
    )
{
    CHAR FullRegKey[MAX_PATH];
    wsprintf (FullRegKey, S_CONTROL_PANEL_MASK, SubKeyName);
    if (CreateEmptyKey) {
        RegDeleteKey (RootKey, FullRegKey);
    }
    return CreateRegKey (RootKey, FullRegKey);
}
HKEY
pCreateScreenSaverKey (
    IN      HKEY RegRoot, 
    IN      LPCSTR ScreenSaverName
    )
{
    CHAR FullScreenSaverName[MAX_PATH];
    wsprintf (FullScreenSaverName, S_SCRNSAVE_MASK, ScreenSaverName);
    return pCreateControlPanelKey (RegRoot, FullScreenSaverName, FALSE);
}
BOOL
pCopyValuesFromSettingsFileToRegistry (
    IN      HKEY RegKeyRoot,
    IN      LPCSTR RegKeyName,
    IN      LPCSTR ScreenSaverName,
    IN      LPCSTR ValueArray[]
    )
{
    INT i;
    CHAR IniKeyName[MAX_PATH];
    HKEY RegKey;
    BOOL b = TRUE;
    //
    // This function takes the values stored in our settings file and
    // copies them to a brand new key in the NT registry.
    //
    // In the settings file, we store screen saver parameters in the
    // format of <screen saver name len>/<screen saver name>/<parameter>=<value>.
    //
    //
    // Create new registry key
    //
    RegKey = pCreateControlPanelKey (RegKeyRoot, RegKeyName, TRUE);
    if (!RegKey) {
        return FALSE;
    }
    //
    // Copy values to reg key
    //
    for (i = 0 ; ValueArray[i] ; i++) {
        if (!CreateScreenSaverParamKey (ScreenSaverName, ValueArray[i], IniKeyName)) {
            // fail if screen saver name is huge for some unknown reason
            SetupLogError (S_HUGEDATA_ERROR, LogSevWarning);
            b = FALSE;
            break;
        }
        GetSettingsFileVal (IniKeyName);
        if (!SetRegValueString (RegKey, ValueArray[i], g_Data)) {
            b = FALSE;
            break;
        }
    }
    CloseRegKey (RegKey);
    return b;
}
BOOL
TranslateGeneralSetting (
    IN      HKEY RegKey,
    IN      LPCSTR Win9xSetting,
    IN      LPCSTR WinNTSetting
    )
{
    BOOL b = TRUE;
    if (!WinNTSetting) {
        WinNTSetting = Win9xSetting;
    } else {
        //
        // Delete the Win9x setting that was copied to NT, ignore
        // any failures.
        //
        RegDeleteValue (RegKey, Win9xSetting);
    }
    //
    // Obtain setting from data file
    //
    if (GetSettingsFileVal (Win9xSetting)) {
        //
        // Save settings to registry
        //
        b = SetRegValueString (RegKey, WinNTSetting, g_Data);
    }
    return b;
}
typedef struct {
    LPCSTR Win9xName;
    LPCSTR WinNtName;
} FILE_TRANS, *PFILE_TRANS;
FILE_TRANS g_FileNameTranslation[] = {
    // Win9x name                   // WinNT name (NULL=no change)
    "black16.scr",                  NULL,
    "Blank Screen.scr",             "black16.scr",
    "ssbezier.scr",                 NULL,
    "Curves and Colors.scr",        "ssbezier.scr",
    "ssstars.scr",                  NULL,
    "Flying Through Space.scr",     "ssstars.scr",
    "ssmarque.scr",                 NULL,
    "Scrolling Marquee.scr",        "ssmarque.scr",
    "ssmyst.scr",                   NULL,
    "Mystify Your Mind.scr",        "ssmyst.scr",
    NULL, NULL
};
LPCSTR
GetSettingsFileVal (
    IN      LPCSTR Key
    )
{
    GetPrivateProfileString (
        g_User, 
        Key, 
        S_EMPTY, 
        g_Data, 
        MAX_PATH, 
        g_SettingsFile
        );
    return g_Data[0] ? g_Data : NULL;
}
BOOL
pTranslateScrName (
    IN OUT  LPSTR KeyName,
    OUT     LPSTR FullPath      OPTIONAL
    )
{
    int i;
    //
    // Compare against translation list
    //
    for (i = 0 ; g_FileNameTranslation[i].Win9xName ; i++) {
        if (!_mbsicmp (KeyName, g_FileNameTranslation[i].Win9xName)) {
            break;
        }
    }
    //
    // Translate filename only if a match was found in our list
    //
    if (g_FileNameTranslation[i].Win9xName) {
        //
        // If WinNtName is NULL, there is no renaming necessary.  Otherwise,
        // use the NT name, which is always a file in system32.
        //
        if (g_FileNameTranslation[i].WinNtName && FullPath) {
            // Rebuild path
            GetSystemDirectory (FullPath, MAX_PATH);
            _mbscat (FullPath, "\");
            _mbscat (FullPath, g_FileNameTranslation[i].WinNtName);
        }
        _mbscpy (KeyName, g_FileNameTranslation[i].WinNtName);
    }
    else if (FullPath) {
        FullPath[0] = 0;
    }
    return TRUE;
}
BOOL
SaveScrName (
    IN      HKEY RegKey, 
    IN      LPCSTR KeyName
    )
{
    LPSTR p;
    CHAR FullPath[MAX_PATH];
    CHAR ShortName[MAX_PATH];
    //
    // The Windows 95 screen saver names are different than
    // Windows NT.
    //
    if (!GetSettingsFileVal (KeyName)) {
        // Unexpected: .SCR name does not exist in our file
        return TRUE;
    }
    //
    // Locate the screen saver name within the full path
    //
    p = _mbsrchr (g_Data, '\');
    if (!p) {
        p = g_Data;
    } else {
        p = _mbsinc (p);
    }
    //
    // Translate it if necessary
    //
    if (!pTranslateScrName (p, FullPath)) {
        return FALSE;
    }
    if (!FullPath[0]) {
        //
        // No change was made, so copy original path to FullPath
        //
        
        _mbscpy (FullPath, g_Data);
    }
    //
    // Screen savers are always stored in short filename format
    //
    GetShortPathName (FullPath, ShortName, MAX_PATH);
    return SetRegValueString (RegKey, KeyName, ShortName);
}
INT
GetHexDigit (
    IN      CHAR c
    )
{
    if (c >= '0' && c <= '9') {
        return c - '0';
    }
    c = tolower (c);
    if (c >= 'a' && c <= 'f') {
        return c - 'a' + 10;
    }
    return -1;
}
BYTE
GetNextHexByte (
    IN      LPCSTR HexString,
    OUT     LPCSTR *HexStringReturn
    )
{
    INT a, b;
    a = GetHexDigit (HexString[0]);
    b = GetHexDigit (HexString[1]);
    if (a == -1 || b == -1) {
        *HexStringReturn = NULL;
        return 0;
    }
    *HexStringReturn = &(HexString[2]);
    return a * 16 + b;
}
BOOL
GetNextDword (
    IN      LPCSTR HexString,
    OUT     LPCSTR *HexStringReturn,
    OUT     PDWORD ValuePtr
    )
{
    INT i;
    BYTE NextByte;
    *ValuePtr = 0;
    for (i = 0 ; i < 4 ; i++) {
        NextByte = GetNextHexByte (HexString, &HexString);
        if (!HexString) {
            return FALSE;
        }
        *ValuePtr = ((*ValuePtr) << 8) | NextByte;
    }
    return TRUE;
}
BOOL
VerifyBezierChecksum (
    IN      LPCSTR HexString
    )
{
    BYTE Checksum = 0;
    INT Len;
    Len = _mbslen (HexString);
    Len -= 2;
    if (Len < 1) {
        return FALSE;
    }
    while (Len > 0) {
        Checksum += GetNextHexByte (HexString, &HexString);
        if (!HexString) {
            return FALSE;
        }
    }
    if (Checksum != GetNextHexByte (HexString, &HexString)) {
        return FALSE;
    }
    return TRUE;
}
BOOL
CopyUntranslatedSettings (
    IN      HKEY RegRoot
    )
{
    LPSTR KeyBuffer;
    DWORD KeyBufferSize;
    LPSTR p;
    CHAR ScreenSaverName[MAX_PATH];
    CHAR ValueName[MAX_PATH];
    HKEY Key;
    //
    // Enumerate each entry in our private settings file for the user
    //
    KeyBufferSize = 32768;
    KeyBuffer = (LPSTR) HeapAlloc (g_hHeap, 0, KeyBufferSize);
    if (!KeyBuffer) {
        return FALSE;
    }
    //
    // Get all keys in the user's section
    //
    GetPrivateProfileString (
        g_User,
        NULL,
        S_DOUBLE_EMPTY,
        KeyBuffer,
        KeyBufferSize,
        g_SettingsFile
        );
    for (p = KeyBuffer ; *p ; p = _mbschr (p, 0) + 1) {
        //
        // Process only if key is encoded
        //
        if (!DecodeScreenSaverParamKey (p, ScreenSaverName, ValueName)) {
            continue;
        }
        //
        // Key is encoded, so perform migration!
        //
        pTranslateScrName (ScreenSaverName, NULL);
        //
        // Skip screen savers that have special processing
        //
        if (pHasSpecialProcessing (ScreenSaverName)) {
            continue;
        }
        //
        // Save the value to the registry
        //
        GetSettingsFileVal (p);
        Key = pCreateScreenSaverKey (RegRoot, ScreenSaverName);
        if (Key) {
            if (SetRegValueString (Key, ValueName, g_Data))
            {
                CHAR DebugMsg[MAX_PATH*2];
                wsprintf (DebugMsg, "Saved %s=%srn", ValueName, g_Data);
                SetupLogError (DebugMsg, LogSevInformation);
            } else {
                CHAR DebugMsg[MAX_PATH*2];
                wsprintf (DebugMsg, "Could not save %s=%srn", ValueName, g_Data);
                SetupLogError (DebugMsg, LogSevError);
            }
            CloseRegKey (Key);
        }
    }
    HeapFree (g_hHeap, 0, KeyBuffer);
    return TRUE;
}
BOOL
pHasSpecialProcessing (
    IN      LPCSTR ScreenSaverName
    )
{
    //
    // Return TRUE if we are doing something special for the
    // named screen saver.
    //
    if (!_mbsicmp (ScreenSaverName, S_BEZIER) ||
        !_mbsicmp (ScreenSaverName, S_MARQUEE)
        ) {
        return TRUE;
    }
    return FALSE;
}
BOOL
TranslateScreenSavers (
    IN      HKEY RegRoot
    )
{
    BOOL b = TRUE;
    b &= pTranslateBezier (RegRoot);
    b &= pTranslateMarquee (RegRoot);
    return b;
}
BOOL
pTranslateBezier (
    IN      HKEY RegRoot
    )
{
    DWORD Value;
    CHAR StrValue[32];
    LPCSTR p;
    HKEY RegKey;
    BOOL b;
    //
    // NT's Bezier has three settings:
    //
    // Length (REG_SZ)      = Curve Count on Win9x
    // LineSpeed (REG_SZ)   = Speed on Win9x
    // Width (REG_SZ)       = Density on Win9x
    //
    // Win9x's Bezier has a big string of hex in the following format:
    // 
    // Clear Screen Flag (DWORD)
    // Random Colors Flag (DWORD)
    // Curve Count (DWORD)
    // Line Count (DWORD)
    // Density (DWORD)
    // Speed (DWORD)
    // Current Color (DWORD RGB)
    // Checksum (BYTE)
    //
    //
    // Verify structure
    //
    GetSettingsFileVal (S_BEZIER_SETTINGS);
    if (!VerifyBezierChecksum (g_Data)) {
        return TRUE;
    }
    //
    // Open reg key
    //
    RegKey = pCreateControlPanelKey (RegRoot, S_BEZIER_SETTINGS, TRUE);
    if (!RegKey) {
        return FALSE;
    }
    p = g_Data;
    // Get clear screen flag (but ignore it)
    b = GetNextDword (p, &p, &Value);
    // Get random colors flag (but ignore it)
    if (b) {
        b = GetNextDword (p, &p, &Value);
    }
    //
    // Get curve count
    //
    if (b) {
        b = GetNextDword (p, &p, &Value);
    }
    if (b) {
        wsprintf (StrValue, "%u", Value);
        b = SetRegValueString (RegKey, S_LENGTH, StrValue);
    }
    // Get line count (but ignore it)
    if (b) {
        b = GetNextDword (p, &p, &Value);
    }
    //
    // Get density
    //
    if (b) {
        b = GetNextDword (p, &p, &Value);
    }
    if (b) {
        wsprintf (StrValue, "%u", Value);
        b = SetRegValueString (RegKey, S_WIDTH, StrValue);
    }
    //
    // Get speed
    //
    if (b) {
        b = GetNextDword (p, &p, &Value);
    }
    if (b) {
        wsprintf (StrValue, "%u", Value);
        b = SetRegValueString (RegKey, S_LINESPEED, StrValue);
    }
    CloseRegKey (RegKey);
    if (!b) {
        SetupLogError (S_BEZIER_DATA_ERROR, LogSevError);
    }
    return TRUE;
}
LPCSTR g_MarqueeValues[] = {
    S_BACKGROUND_COLOR,
    S_CHARSET,
    S_FONT,
    S_MODE,
    S_SIZE,
    S_SPEED,
    S_TEXT,
    S_TEXTCOLOR,
    NULL
};
BOOL
pTranslateMarquee (
    IN      HKEY RegRoot
    )
{
    BOOL b;
    //
    // Marquee has the same settings on Win9x and NT.  They just need
    // to be copied from the control.ini file to the NT registry.
    //
    b = pCopyValuesFromSettingsFileToRegistry (
                RegRoot,
                S_MARQUEE_SETTINGS, 
                S_MARQUEE,
                g_MarqueeValues
                );
    //
    // We need to divide the speed by two to be compatible
    //
    if (b) {
        HKEY MarqueeKey;
        LPCSTR Value;
        CHAR NewValue[32];
        // Read the setting we just wrote in the registry
        MarqueeKey = pCreateControlPanelKey (RegRoot, S_MARQUEE_SETTINGS, FALSE);
        if (MarqueeKey) {
            Value = GetRegValueString (MarqueeKey, S_SPEED);
            if (Value) {
                // Write speed divided by two
                wsprintf (NewValue, "%i", atoi (Value) / 2);
                SetRegValueString (MarqueeKey, S_SPEED, NewValue);
            }
            CloseRegKey (MarqueeKey);
        }
    }
    return b;
}

						