Wallpaper Class Reference

#include <Wallpaper.h>

Public Member Functions
void	ExecuteRootCommand ()
void	ParseBSetBG ()
void	ParseBSetRoot ()
COLORREF	GetColorRef (LPSTR colorAsString)
void	SetDesktopColor (COLORREF color)
void	SetWallpaper (LPSTR wpPath, LPSTR wpStyle)
void	SetModula (int x, int y, COLORREF fg, COLORREF bg)
void	SetGradient (int type, bool interlaced, COLORREF from, COLORREF to)
PBITMAPINFO	CreateBitmapInfoStruct (HBITMAP hBitmap)
void	CreateBMPFile (LPTSTR pszFile, PBITMAPINFO pbi, HBITMAP hBitmap)

Member Function Documentation

ExecuteRootCommand()

void Wallpaper::ExecuteRootCommand

(

)

{
    if (IsInString(pSettings->rootCommand, "bsetbg")) ParseBSetBG();
    else if (IsInString(pSettings->rootCommand, "bsetroot")) ParseBSetRoot();
 
    pSettings->wallpaperPerWorkspaceSemaphore = false; // Reset if previously set by switchToDesktop() in Workspaces.cpp (i.e. when wallpaper per workspace is enabled)
}

ParseBSetBG()

void Wallpaper::ParseBSetBG

(

)

{
    // bsetbg.exe <-tile|-full|-center> <image.jpg>
 
    char szOption_1[MAX_LINE_LENGTH], szOption_2[MAX_LINE_LENGTH], szOption_3[MAX_LINE_LENGTH], szOption_4[MAX_LINE_LENGTH];
    char* tokens[4];
    tokens[0] = szOption_1;
    tokens[1] = szOption_2;
    tokens[2] = szOption_3;
    tokens[3] = szOption_4;
    szOption_1[0] = szOption_2[0] = szOption_3[0] = szOption_4[0] = '\0';
    BBTokenize(pSettings->rootCommand, tokens, 4, NULL);
 
    SetWallpaper(szOption_3, szOption_2);
}

ParseBSetRoot()

void Wallpaper::ParseBSetRoot

(

)

{
    // bsetroot.exe -solid <colour>
    // bsetroot.exe -bitmap <tile|stretch|center> <image.bmp>
    // bsetroot.exe -bitmap <tile|stretch|center> <image.bmp> -solid <colour>
    // bsetroot.exe -gradient <type+interlaced> -from <colour> -to <colour>
    // bsetroot.exe -mod <x> <y> -fg <colour> -bg <colour>
 
    char szOption_1[MAX_LINE_LENGTH], szOption_2[MAX_LINE_LENGTH], szOption_3[MAX_LINE_LENGTH], szOption_4[MAX_LINE_LENGTH], szOption_5[MAX_LINE_LENGTH], szOption_6[MAX_LINE_LENGTH], szOption_7[MAX_LINE_LENGTH], szOption_8[MAX_LINE_LENGTH];
    char* tokens[8];
    tokens[0] = szOption_1;
    tokens[1] = szOption_2;
    tokens[2] = szOption_3;
    tokens[3] = szOption_4;
    tokens[4] = szOption_5;
    tokens[5] = szOption_6;
    tokens[6] = szOption_7;
    tokens[7] = szOption_8;
    szOption_1[0] = szOption_2[0] = szOption_3[0] = szOption_4[0] = szOption_5[0] = szOption_6[0] = szOption_7[0] = szOption_8[0] = '\0';
    BBTokenize(pSettings->rootCommand, tokens, 8, NULL);
 
    char msg[350];
 
    //====================
 
    // Execute any -solid commands... (see above)
    if (IsInString(pSettings->rootCommand, "-solid"))
    {
        COLORREF solidColor;
 
        if (!IsInString(pSettings->rootCommand, "-bitmap")) // bsetroot.exe -solid <colour>
        {
            SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, (PVOID)"(None)", SPIF_SENDCHANGE); // Remove any existing wallpaper
            solidColor = ReadColor(NULL, szOption_3, szOption_3);
        }
        else solidColor = ReadColor(NULL, szOption_6, szOption_6); // bsetroot.exe -bitmap <tile|stretch|center> <image.bmp> -solid <colour>
 
        int lpaElements[1] = { COLOR_BACKGROUND };
        COLORREF lpaRgbValues[1] = { solidColor };
 
        // Set the new desktop colour...
        if (!pSettings->wallpaperPerWorkspaceSemaphore)
        {
            sprintf(msg, "Setting the desktop colour to %s .", szOption_3);
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_REGULAR_MESSAGE, (LPARAM)msg);
        }
        SetSysColors(1, lpaElements, lpaRgbValues);
 
        if (!IsInString(pSettings->rootCommand, "-bitmap")) return;
    }
 
    //====================
 
    // Execute any -bitmap commands... (see above)
    if (IsInString(pSettings->rootCommand, "-bitmap"))
    {
        SetWallpaper(szOption_4, szOption_3);
        return;
    }
 
    //====================
 
    // Execute any -mod commands... (see above)
    if (IsInString(szOption_2, "-mod"))
    {
        int x = 4, y = 4;
        x = atoi(szOption_3);
        y = atoi(szOption_4);
 
        COLORREF fg = 0xffffff, bg = 0x000000;
        if (IsInString(szOption_5, "-fg")) fg = ReadColor(NULL, szOption_6, szOption_6);
        if (IsInString(szOption_5, "-bg")) bg = ReadColor(NULL, szOption_6, szOption_6);
        if (IsInString(szOption_7, "-fg")) fg = ReadColor(NULL, szOption_8, szOption_8);
        if (IsInString(szOption_7, "-bg")) bg = ReadColor(NULL, szOption_8, szOption_8);
 
        // sprintf(msg, "bsetroot %s %d %d %s %s %s %s", szOption_2, x, y, szOption_5, szOption_6, szOption_7, szOption_8);
        // SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
 
        SetModula(x, y, fg, bg);
        return;
    }
 
    //====================
 
    // Execute any -gradient commands... (see above)
    if (IsInString(szOption_2, "-gradient"))
    {
        // First we check the gradient "type"...
        int type = B_HORIZONTAL; // B_HORIZONTAL is the default type...
        if (IsInString(szOption_3, "vertical")) type = B_VERTICAL;
        else if (IsInString(szOption_3, "crossdiagonal")) type = B_CROSSDIAGONAL; // Note: Must be checked before "diagonal"... :)
        else if (IsInString(szOption_3, "diagonal")) type = B_DIAGONAL;
        else if (IsInString(szOption_3, "pipecross")) type = B_PIPECROSS;
        else if (IsInString(szOption_3, "elliptic")) type = B_ELLIPTIC;
        else if (IsInString(szOption_3, "rectangle")) type = B_RECTANGLE;
        else if (IsInString(szOption_3, "pyramid")) type = B_PYRAMID;
 
        // ...then we check the "interlaced" flag...
        bool interlaced = false;
        if (IsInString(szOption_3, "interlaced")) interlaced = true;
 
        // ...and finally the "from" and "to" colours...
        COLORREF from = 0xffffff, to = 0x000000;
        if (IsInString(szOption_4, "-from")) from = GetColorRef(szOption_5);
        if (IsInString(szOption_6, "-to")) to = GetColorRef(szOption_7);
 
        SetGradient(type, interlaced, from, to);
        return;
    }
 
    //====================
 
    // Unknown bsetroot command
    SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)"Error parsing style rootCommand! (unknown bsetroot command)");
}

GetColorRef()

COLORREF Wallpaper::GetColorRef

(

LPSTR

colorAsString

)

{
    COLORREF color;
    if (colorAsString[0] == '#') color = strtol(&colorAsString[1], NULL, 16);
    else color = strtol(colorAsString, NULL, 16);
 
    return RGB(GetBValue(color), GetGValue(color), GetRValue(color)); // Convert to BGR format...
}

SetDesktopColor()

void Wallpaper::SetDesktopColor

(

COLORREF

color

)

{
    SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, (PVOID)"(None)", SPIF_SENDCHANGE); // Remove any existing wallpaper
    int lpaElements[1] = { COLOR_BACKGROUND };
    COLORREF lpaRgbValues[1] = { color };
 
    char colorAsString[10];
    sprintf(colorAsString, "#%02x%02x%02x", (BYTE)GetRValue(color), (BYTE)GetGValue(color), (BYTE)GetBValue(color));
 
    if (!pSettings->wallpaperPerWorkspaceSemaphore)
    {
        char msg[50];
        sprintf(msg, "Setting the desktop colour to %s.", colorAsString);
        SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_REGULAR_MESSAGE, (LPARAM)msg);
    }
 
    // Remember the manually applied desktop colour as the "last applied" rootCommand in case Designer mode wants to Save it later on... (see Broams.cpp)
    sprintf(pSettings->rootCommand, "bsetroot -solid %s", colorAsString);
    CopyStringToClipboard(pSettings->rootCommand);
 
    SetSysColors(1, lpaElements, lpaRgbValues);
}

SetWallpaper()

void Wallpaper::SetWallpaper	(	LPSTR	wpPath,
		LPSTR	wpStyle )

{
    if (strchr(wpPath, '\"')) StrRemoveEncap(wpPath);
    if (strchr(wpPath, '$')) ReplaceShellFolders(wpPath);
    if (strchr(wpPath, '%')) ReplaceEnvVars(wpPath);
 
    char path[MAX_PATH];
    if (IsInString(wpPath, ":")) strcpy(path, wpPath); // Full path (i.e. includes ":" which is a reserved character for drive names)
    else if (!IsInString(wpPath, "\\")) // Filename only -> Look for the image in the default wallpaper folder
    {
        strcpy(path, pSettings->wallpapersFolder);
        strcat(path, "\\");
        strcat(path, wpPath);
    }
    else if (!IsInString(wpPath, pSettings->SF_blackboxPath)) // Relative path from the Blackbox folder
    {
        strcpy(path, pSettings->SF_blackboxPath);
        strcat(path, "\\");
        strcat(path, wpPath);
    }
 
    if (!FileExists(path))
    {
        char msg[MAX_LINE_LENGTH];
        sprintf(msg, "Error setting the desktop wallpaper - File not found! (%s).", path);
        SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)msg);
        return;
    }
 
    //====================
 
    int pointer = strlen(path) - 4;
 
    // We only need to check the last 4 characters to get the extension...
    // (we allow JPG/JPEG, PNG, and BMP files as wallpaper images)
    if (!_stricmp(&path[pointer], ".jpg")
        || !_stricmp(&path[pointer], ".png")
        || !_stricmp(&path[pointer], ".bmp")
        || !_stricmp(&path[pointer], "jpeg"))
    {
        /*
            if (GetAsyncKeyState(VK_CONTROL) & 0x8000) strcpy(arguments, "-center "); // Is the control key held down? -> Centered mode
            else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) strcpy(arguments, "-full "); // Is the shift key held down? -> Stretched mode
            else strcpy(arguments, "-tile "); // Default -> Tiled mode
        */
 
        char wallpaperStyle[10];
 
        // Update the registry keys defining if the wallpaper should be tiled/centered/stretched...
        // * WallpaperStyle key -> Fill 10, Fit 6, Stretch 2, Tile 0, Center 0, Span 22.
        // * TileWallpaper key -> Set to 1 if Tile, 0 if any other setting.
        HKEY key;
        if (RegOpenKeyEx(HKEY_CURRENT_USER, "Control Panel\\Desktop\\", 0, KEY_ALL_ACCESS, &key) == ERROR_SUCCESS)
        {
            LSTATUS result;
            if (IsInString(wpStyle, "tile"))
            {
                result = RegSetValueEx(key, "WallpaperStyle", 0, REG_SZ, (unsigned char*)"0", 2);
                result = RegSetValueEx(key, "TileWallpaper", 0, REG_SZ, (unsigned char*)"1", 2);
                strcpy(wallpaperStyle, "tiled");
            }
            else if (IsInString(wpStyle, "center"))
            {
                result = RegSetValueEx(key, "WallpaperStyle", 0, REG_SZ, (unsigned char*)"1", 2);
                result = RegSetValueEx(key, "TileWallpaper", 0, REG_SZ, (unsigned char*)"0", 2);
                strcpy(wallpaperStyle, "centered");
            }
            else if (IsInString(wpStyle, "span")) // -> A single wallpaper spanning across multiple monitors
            {
                result = RegSetValueEx(key, "WallpaperStyle", 0, REG_SZ, (unsigned char*)"22", 2);
                result = RegSetValueEx(key, "TileWallpaper", 0, REG_SZ, (unsigned char*)"0", 2);
                strcpy(wallpaperStyle, "spanned");
            }
            else // if (IsInString(wpStyle, "stretch") || IsInString(wpStyle, "full"))
            {
                result = RegSetValueEx(key, "WallpaperStyle", 0, REG_SZ, (unsigned char*)"2", 2);
                result = RegSetValueEx(key, "TileWallpaper", 0, REG_SZ, (unsigned char*)"0", 2);
                strcpy(wallpaperStyle, "stretched");
            }
 
            RegCloseKey(key);
 
            if (result != ERROR_SUCCESS)
            {
                SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)"Error writing to the wallpaper style registry keys!");
                return;
            }
        }
        else
        {
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)"Error opening the wallpaper style registry keys!");
            return;
        }
 
        // ...set the image to be the new desktop wallpaper...
        if (!pSettings->wallpaperPerWorkspaceSemaphore)
        {
            char msg[1024];
            if (IsInString(path, pSettings->SF_currentThemePath)) sprintf(msg, "Setting the desktop wallpaper to $CurrentTheme$%s (%s).", &path[strlen(pSettings->SF_currentThemePath)], wallpaperStyle);
            else if (IsInString(path, pSettings->SF_blackboxPath)) sprintf(msg, "Setting the desktop wallpaper to $Blackbox$%s (%s).", &path[strlen(pSettings->SF_blackboxPath)], wallpaperStyle);
            else sprintf(msg, "Setting the desktop wallpaper to %s (%s).", path, wallpaperStyle);
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_REGULAR_MESSAGE, (LPARAM)msg);
        }
        SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, (void*)path, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
 
        if (!pSettings->wallpaperPerWorkspaceSemaphore)
        {
            // ...and copy a matching rootCommand to the clipboard for
            // possibly updating of a style in case it was a good match! =]
            char* stylePtr = wpStyle;
            if (wpStyle[0] == '-') stylePtr++;
            char rootCmd[MAX_LINE_LENGTH];
            if (IsInString(path, pSettings->SF_currentThemePath)) sprintf(rootCmd, "rootCommand: bsetbg -%s \"$CurrentTheme$%s\"", stylePtr, &path[strlen(pSettings->SF_currentThemePath)]);
            else if (IsInString(path, pSettings->SF_blackboxPath)) sprintf(rootCmd, "rootCommand: bsetbg -%s \"%s\"", stylePtr, &path[strlen(pSettings->SF_blackboxPath) + 1]);
            else sprintf(rootCmd, "rootCommand: bsetbg -%s \"%s\"", stylePtr, path);
            CopyStringToClipboard(rootCmd);
 
            // Finally, remember the manually applied wallpaper as the "last applied" rootCommand in case Designer mode wants to Save it later on... (see Broams.cpp)
            strcpy(pSettings->rootCommand, &rootCmd[13]);
        }
    }
    else SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)"Error setting the desktop wallpaper - only JPG/JPEG, PNG and BMP files are supported.");
}

SetModula()

void Wallpaper::SetModula	(	int	x,
		int	y,
		COLORREF	fg,
		COLORREF	bg )

{
    PAINTSTRUCT ps;
    HWND dwnd = GetDesktopWindow();
    HDC hdc = BeginPaint(dwnd, &ps);
    HDC buf = CreateCompatibleDC(NULL);
    PBYTE pixels;
 
//  int width = GetSystemMetrics(SM_CXSCREEN);
//  int height = GetSystemMetrics(SM_CYSCREEN);
    int width = x;
    int height = y;
    if (pSettings->scalingFactorHiDPI > 1) // Adapt bsetroot parameters to the current HiDPI scaling factor? (-> aligned with scaling aware style rendering etc)
    {
        width *= pSettings->scalingFactorHiDPI;
        height *= pSettings->scalingFactorHiDPI;
    }
 
    BITMAPINFOHEADER bv4info;
    bv4info.biSize = sizeof(BITMAPINFOHEADER);
    bv4info.biWidth = width;
    bv4info.biHeight = height;
    bv4info.biPlanes = 1;
    bv4info.biBitCount = 32;
    bv4info.biCompression = BI_RGB;
 
    BITMAPINFO bminfo;
    bminfo.bmiHeader = bv4info;
 
    HBITMAP bitmap = CreateDIBSection(hdc, &bminfo, DIB_RGB_COLORS, (PVOID*)&pixels, NULL, 0);
    if (bitmap) SelectObject(buf, bitmap);
 
    //====================
 
    int count = 0;
//  for (int vertical = 1; vertical < height; vertical++)
    for (int vertical = 0; vertical < height; vertical++)
    {
        for (int horizontal = 0; horizontal < width; horizontal++)
        {
//          if ((vertical % y) == 0)
            if ((vertical == 0) || (pSettings->doubleScaleHiDPI && (vertical == 1)))
            {
                pixels[count + 2] = GetRValue(fg);
                pixels[count + 1] = GetGValue(fg);
                pixels[count] = GetBValue(fg);
            }
            else
            {
//              if ((horizontal % x) == 0)
                if ((horizontal == 0) || (pSettings->doubleScaleHiDPI && (horizontal == 1)))
                {
                    pixels[count + 2] = GetRValue(fg);
                    pixels[count + 1] = GetGValue(fg);
                    pixels[count] = GetBValue(fg);
                }
                else
                {
                    pixels[count + 2] = GetRValue(bg);
                    pixels[count + 1] = GetGValue(bg);
                    pixels[count] = GetBValue(bg);
                }
            }
            count += 4;
        }
    }
 
    //====================
 
    char path[MAX_PATH];
    GetBlackboxPath(path, sizeof(path));
    strcat(path, "bsetroot.bmp");
 
    PBITMAPINFO pbmpi = CreateBitmapInfoStruct(bitmap);
    CreateBMPFile(path, pbmpi, bitmap);
 
    DeleteDC(buf);
    DeleteObject(bitmap);
    EndPaint(dwnd, &ps);
 
    SetWallpaper(path, "tile");
}

SetGradient()

void Wallpaper::SetGradient	(	int	type,
		bool	interlaced,
		COLORREF	from,
		COLORREF	to )

{
    SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Sorry, bsetroot -gradient is not yet supported... (stay tuned).");
    return;
}

CreateBitmapInfoStruct()

PBITMAPINFO Wallpaper::CreateBitmapInfoStruct

(

HBITMAP

hBitmap

)

{
    BITMAP bmp;
    PBITMAPINFO pbmi;
 
    // Retrieve the bitmap's color format, width and height...
    if (!GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bmp)) return NULL;
 
    // Convert the bitmap's color format to depth in bits...
    WORD cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel);
    if (cClrBits == 1) cClrBits = 1;
    else if (cClrBits <= 4) cClrBits = 4;
    else if (cClrBits <= 8) cClrBits = 8;
    else if (cClrBits <= 16) cClrBits = 16;
    else if (cClrBits <= 24) cClrBits = 24;
    else cClrBits = 32;
 
    // Allocate memory for the BITMAPINFO structure... (this contains a BITMAPINFOHEADER structure and an array of RGBQUAD data structures) 
    if (cClrBits != 24) pbmi = (PBITMAPINFO)LocalAlloc(LPTR, sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD) * (1 << cClrBits)));
    else pbmi = (PBITMAPINFO)LocalAlloc(LPTR, sizeof(BITMAPINFOHEADER)); // There is no RGBQUAD array for the 24-bit-per-pixel format...
 
    // Initialize the fields in the BITMAPINFO structure...
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    pbmi->bmiHeader.biWidth = bmp.bmWidth;
    pbmi->bmiHeader.biHeight = bmp.bmHeight;
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes;
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel;
    pbmi->bmiHeader.biCompression = BI_RGB; // The bitmap is not compressed
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits + 31) & ~31) / 8 * pbmi->bmiHeader.biHeight;
    if (cClrBits < 16) pbmi->bmiHeader.biClrUsed = (1 << cClrBits);
    pbmi->bmiHeader.biClrImportant = 0;
 
    return pbmi;
}

CreateBMPFile()

void Wallpaper::CreateBMPFile	(	LPTSTR	pszFile,
		PBITMAPINFO	pbi,
		HBITMAP	hBitmap )

{
    HANDLE hf;                  // File handle 
    BITMAPFILEHEADER hdr;       // Bitmap file-header 
    PBITMAPINFOHEADER pbih;     // Bitmap info-header 
    LPBYTE lpBits;              // Memory pointer 
    DWORD dwTotal;              // Total count of bytes 
    DWORD cb;                   // Incremental count of bytes 
    BYTE* hp;                   // Byte pointer 
    DWORD dwTmp;
 
    HDC hDC;
 
    pbih = (PBITMAPINFOHEADER)pbi;
    lpBits = (LPBYTE)GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);
    if (!lpBits) return;
 
    hDC = CreateCompatibleDC(NULL);
 
    if (!GetDIBits(hDC, hBitmap, 0, (WORD)pbih->biHeight, lpBits, pbi, DIB_RGB_COLORS))
    {
        DeleteDC(hDC);
        GlobalFree((HGLOBAL)lpBits);
    }
 
    // Create the .bmp file...
    hf = CreateFile(pszFile, GENERIC_READ | GENERIC_WRITE, (DWORD)0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
    if (hf != INVALID_HANDLE_VALUE)
    {
        hdr.bfType = 0x4d42; // 0x42 = "B" 0x4d = "M"
 
        // Calculate the size of the entire file...
        hdr.bfSize = (DWORD)(sizeof(BITMAPFILEHEADER) + pbih->biSize + pbih->biClrUsed * sizeof(RGBQUAD) + pbih->biSizeImage);
        hdr.bfReserved1 = 0;
        hdr.bfReserved2 = 0;
 
        // Calculate the offset to the array of color indices...
        hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + pbih->biSize + pbih->biClrUsed * sizeof(RGBQUAD);
 
        // Copy the BITMAPFILEHEADER into the file...
        if (WriteFile(hf, (LPVOID)&hdr, sizeof(BITMAPFILEHEADER), (LPDWORD)&dwTmp, NULL))
        {
            // Copy the BITMAPINFOHEADER and RGBQUAD array into the file...
            if (WriteFile(hf, (LPVOID)pbih, sizeof(BITMAPINFOHEADER) + pbih->biClrUsed * sizeof(RGBQUAD), (LPDWORD)&dwTmp, (NULL)))
            {
                // Copy the array of color indices into the file...
                dwTotal = cb = pbih->biSizeImage;
                hp = lpBits;
                if (WriteFile(hf, (LPSTR)hp, (int)cb, (LPDWORD)&dwTmp, NULL))
                {
                    // Close the file...
                    CloseHandle(hf);
                }
            }
        }
    }
 
    DeleteDC(hDC);
    GlobalFree((HGLOBAL)lpBits);
}