// Program to load clipboard CF_DIB data to desktop
// Example: C:\MinGW\Progs>g++ ClipbrdReadDIB.cpp -lgdi32 -o crdib.exe

// Ref: https://stackoverflow.com/questions/30552255/how-to-read-a-bitmap-from-the-windows-clipboard
// Ref: http://www.cplusplus.com/reference/fstream/ofstream/open/

#include <iostream>
#include <fstream>
#include <windows.h>

typedef struct
{
    std::uint32_t biSize;
    std::int32_t  biWidth;
    std::int32_t  biHeight;
    std::uint16_t  biPlanes;
    std::uint16_t  biBitCount;
    std::uint32_t biCompression;
    std::uint32_t biSizeImage;
    std::int32_t  biXPelsPerMeter;
    std::int32_t  biYPelsPerMeter;
    std::uint32_t biClrUsed;
    std::uint32_t biClrImportant;
} DIB;

typedef struct
{
    std::uint16_t type;
    std::uint32_t bfSize;
    std::uint32_t reserved;
    std::uint32_t offset;
} HEADER;

typedef struct
{
    HEADER header;
    DIB dib;
} BMP;


int wmain(int argc, char* argv[])
{
    std::cout<<"Format Bitmap: "<<IsClipboardFormatAvailable(CF_BITMAP)<<"\n";
    std::cout<<"Format DIB: "<<IsClipboardFormatAvailable(CF_DIB)<<"\n";
    std::cout<<"Format DIBv5: "<<IsClipboardFormatAvailable(CF_DIBV5)<<"\n";

    if (IsClipboardFormatAvailable(CF_BITMAP) || IsClipboardFormatAvailable(CF_DIB) || IsClipboardFormatAvailable(CF_DIBV5))
    {
    std::cout<<"We had Clipboard Data Available.\n";
        if (OpenClipboard(NULL))
        {
        std::cout<<"We WERE able to open the Clipboard.\n";

            HANDLE hClipboard = GetClipboardData(CF_DIB);

            if (hClipboard)
                std::cout<<"We WERE able get a CF_DIB handle.\n";
            else
                std::cout<<"We were NOT able get a CF_DIB handle.\n";

            if (!hClipboard)
            {
                hClipboard = GetClipboardData(CF_DIBV5);
            }

            if (hClipboard != NULL && hClipboard != INVALID_HANDLE_VALUE)
            {
                std::cout<<"hClipboard was not NULL or INVALID_HANDLE_VALUE and hClipboard of "<<hClipboard<<".\n";
                void* dib = GlobalLock(hClipboard);

                if (dib)
                {
                std::cout<<"For hClipboard we were able to get a GlobalLock of dib.\n";
                    DIB *info = reinterpret_cast<DIB*>(dib);
                    BMP bmp = {0};
                    bmp.header.type = 0x4D42;
                    bmp.header.offset = 54;
                    bmp.header.bfSize = info->biSizeImage + bmp.header.offset;
                    bmp.dib = *info;

                    std::cout<<"Type: "<<std::hex<<bmp.header.type<<std::dec<<"\n";
                    std::cout<<"bfSize: "<<bmp.header.bfSize<<"\n";
                    std::cout<<"Reserved: "<<bmp.header.reserved<<"\n";
                    std::cout<<"Offset: "<<bmp.header.offset<<"\n";
                    std::cout<<"biSize: "<<bmp.dib.biSize<<"\n";
                    std::cout<<"Width: "<<bmp.dib.biWidth<<"\n";
                    std::cout<<"Height: "<<bmp.dib.biHeight<<"\n";
                    std::cout<<"Planes: "<<bmp.dib.biPlanes<<"\n";
                    std::cout<<"Bits: "<<bmp.dib.biBitCount<<"\n";
                    std::cout<<"Compression: "<<bmp.dib.biCompression<<"\n";
                    std::cout<<"Size: "<<bmp.dib.biSizeImage<<"\n";
                    std::cout<<"X-res: "<<bmp.dib.biXPelsPerMeter<<"\n";
                    std::cout<<"Y-res: "<<bmp.dib.biYPelsPerMeter<<"\n";
                    std::cout<<"ClrUsed: "<<bmp.dib.biClrUsed<<"\n";
                    std::cout<<"ClrImportant: "<<bmp.dib.biClrImportant<<"\n";



                    std::ofstream ofs;
                    ofs.open ("test.bmp", std::ofstream::out | std::ios::binary);  // open in binary mode

                    /* We cannot use compression on the raw DIB block, so override this to zero */
                    bmp.dib.biCompression = 0;

                    ofs.write (reinterpret_cast<char*>(&bmp.header.type), sizeof(bmp.header.type));
                    ofs.write (reinterpret_cast<char*>(&bmp.header.bfSize), sizeof(bmp.header.bfSize));
                    ofs.write (reinterpret_cast<char*>(&bmp.header.reserved), sizeof(bmp.header.reserved));
                    ofs.write (reinterpret_cast<char*>(&bmp.header.offset), sizeof(bmp.header.offset));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biSize), sizeof(bmp.dib.biSize));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biWidth), sizeof(bmp.dib.biWidth));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biHeight), sizeof(bmp.dib.biHeight));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biPlanes), sizeof(bmp.dib.biPlanes));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biBitCount), sizeof(bmp.dib.biBitCount));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biCompression), sizeof(bmp.dib.biCompression));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biSizeImage), sizeof(bmp.dib.biSizeImage));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biXPelsPerMeter), sizeof(bmp.dib.biXPelsPerMeter));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biYPelsPerMeter), sizeof(bmp.dib.biYPelsPerMeter));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biClrUsed), sizeof(bmp.dib.biClrUsed));
                    ofs.write (reinterpret_cast<char*>(&bmp.dib.biClrImportant), sizeof(bmp.dib.biClrImportant));
                    ofs.write (reinterpret_cast<char*>(info + 1), bmp.dib.biSizeImage);

                    ofs.close();

                    GlobalUnlock(dib);
                }
                else
                std::cout<<"hClipboard was NOT able to be GlobalLocked.\n";

            }

            CloseClipboard();
        }
        else
            std::cout<<"We were NOT able to open the Clipboard.\n";
    }

    return 0;
}