HBITMAP Internet::getFromInternet(std::string gal)
{
     hInternet = InternetOpen( "GINA: Version 0.1", INTERNET_OPEN_TYPE_DIRECT, NULL, 0,0);
     
     std::string temp = gal  + ".overview.jpg";
     gal = "http://www.imperialconflict.com/images/Galaxies/";
     gal += temp;
     MessageBox(NULL,gal.c_str(),"",MB_OK);
     
     //get size of file
     hFile = InternetOpenUrl(hInternet, gal.c_str(), NULL, 0, 0, 0);
     DWORD sizeBuffer;
     DWORD length = sizeof(sizeBuffer);
     BYTE *buffer = NULL;
     
     bool succeeds = HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, (LPVOID)&sizeBuffer, &length, NULL);
     if (!succeeds)
     {
        throw "Unable to fetch map";
        return (HBITMAP) NULL;
     }
     buffer = new BYTE[sizeBuffer];
     
     //initialize all elements to 0
     for (int i = 0; i < sizeBuffer; i++)
         buffer[i] = 0;
          
     //get file     
     DWORD bytesRead;
     DWORD bytesToRead = sizeBuffer;
     if (hFile)
     {
               InternetReadFile(hFile, buffer, bytesToRead, &bytesRead);
     }
     else
         throw "Unable to grab overview image";
     InternetCloseHandle(hFile);
     InternetCloseHandle(hInternet);
     return loadImage(buffer);
}

HBITMAP Internet::loadImage(BYTE* jpgData)
{
        /* TODO (#1#): Fix access violaion in code below.
        May have something to do with how I'm passing jpgData*/
        MessageBox(NULL,"Load Image 1", "", NULL); 
        IPicture* pic = 0;
        IStream* stream = 0;
        IPersistStream* ps = 0; 
        void* pp = (void*)jpgData;
        MessageBox(NULL,"Load Image 3", "", NULL); 
        OleLoadPicture(stream,0,false,IID_IPicture,(void**)&pic);
        MessageBox(NULL,"Load Image 4", "", NULL);
        stream->Release(); //access violation here?
        MessageBox(NULL,"Load Image 5", "", NULL);
        HBITMAP hB = 0;
        MessageBox(NULL,"Load Image 6", "", NULL);
        pic->get_Handle((unsigned int*)&hB);
        MessageBox(NULL,"Load Image 7", "", NULL);
        // Copy the image. Necessary
        HBITMAP hBB = (HBITMAP)CopyImage(hB,IMAGE_BITMAP,0,0,LR_COPYRETURNORG);
        pic->Release();
        delete [] jpgData; //IMPORTANT
        return hBB;
}

HBITMAP Internet::loadImage(BYTE* jpgData)
{
        char *filename = "Something";
    	unsigned char *raw_image = NULL;
    	/* these are standard libjpeg structures for reading(decompression) */
    	struct jpeg_decompress_struct cinfo;
    	struct jpeg_error_mgr jerr;
    	/* libjpeg data structure for storing one row, that is, scanline of an image */
    	JSAMPROW row_pointer[1];
    	
    	FILE *infile = fopen( filename, "rb" );
    	unsigned long location = 0;
    	int i = 0;
    	
    	if ( !infile )
    	{
           throw "Anything. I know that the file name is bad.";
   		   return (HBITMAP) 0;
    	}
    	/* here we set up the standard libjpeg error handler */
    	cinfo.err = jpeg_std_error( &jerr );
    	/* setup decompression process and source, then read JPEG header */
    	jpeg_create_decompress( &cinfo );
    	/* this makes the library read from infile */
    	jpeg_stdio_src( &cinfo, infile );      //The source should be jpgData!
    	/* reading the image header which contains image information */
    	jpeg_read_header( &cinfo, TRUE );
    	/* Start decompression jpeg here */
    	jpeg_start_decompress( &cinfo );
    
    	/* allocate memory to hold the uncompressed image */
    	raw_image = (unsigned char*)malloc( cinfo.output_width*cinfo.output_height*cinfo.num_components );
    	/* now actually read the jpeg into the raw buffer */
    	row_pointer[0] = (unsigned char *)malloc( cinfo.output_width*cinfo.num_components );
    	/* read one scan line at a time */
    	while( cinfo.output_scanline < cinfo.image_height )
    	{
    		jpeg_read_scanlines( &cinfo, row_pointer, 1 );
    		for( i=0; i<cinfo.image_width*cinfo.num_components;i++) 
    			raw_image[location++] = row_pointer[0][i];
    	}
    	/* wrap up decompression, destroy objects, free pointers and close open files */
    	jpeg_finish_decompress( &cinfo );
    	jpeg_destroy_decompress( &cinfo );
    	free( row_pointer[0] );
    	fclose( infile );
    	/* yup, we succeeded! */
    	return (HBITMAP) 0;  //No we didn't :(
}

#include <windows.h>
#include <gdiplus.h>
#include <cstdlib>
#include <vector>
#include <string>
#include <stdexcept>

// wrapper around GDI+ startup and shutdown
struct ScopedGDI
{
    ULONG_PTR token;
public:
    ScopedGDI()
    {
        Gdiplus::GdiplusStartupInput gdiInput;
        Gdiplus::GdiplusStartup(&token, &gdiInput, NULL);
    }
    ~ScopedGDI()
    {
        Gdiplus::GdiplusShutdown(token);
    }
};

std::wstring ConvertToWString(const std::string& narrowString)
{
    size_t sizeRequired = mbstowcs(NULL, file.c_str(), file.length());
    if(sizeRequired != static_cast<size_t>(-1))
    {
        std::vector<WCHAR> wideBuffer(sizeRequired);
        mbstowcs(&wideBuffer[0], file.c_str(), file.length());
        return std::wstring(wideBuffer.begin(), wideBuffer.end());
    }
    else throw std::invalid_argument(std::string("Cannot convert ") + narrowString);
}

HBITMAP GetHBitmapFromFile(const std::string& file)
{
    HBITMAP hBM = NULL;
    std::wstring wideFile = ConvertToWString(file);

    using namespace Gdiplus;
    ScopedGDI gdi; // initialize GDI+
    Color background; // colour to make any transparent sections - defaults to black
    Bitmap bm(wideFile.c_str()); // create a bitmap object for the file
    bm.GetHBITMAP(background, &hBM); // grab the image as a hbitmap
    return hBM;
}

#include <ole2.h>

HBITMAP GetHBitmapFromHGlobal(HGLOBAL hMem)
{
    HBITMAP hBM = NULL;
    IStream* stream = NULL;
    if(SUCCEEDED(CreateStreamOnHGlobal(hMem, FALSE, &stream)))
    {
        using namespace Gdiplus;
        ScopedGDI gdi;
        Color background;
        {
            Bitmap bm(stream);
            bm.GetHBITMAP(background, &hBM);
            // bitmap must be dsestructed before the stream is released
        }
        stream->Release();
    }
    return hBM;
}

LPPICTURE gpPicture; 


HBITMAP getFromInternet(std::string gal)
{

    HBITMAP    hBitmap;
    HINTERNET      hInternet = InternetOpen( "GINA: Version 0.1", INTERNET_OPEN_TYPE_DIRECT, NULL, 0,0);

    std::string temp = gal  + ".overview.jpg";
    gal = "http://www.imperialconflict.com/images/Galaxies/";
    gal += temp;
    MessageBox(NULL,gal.c_str(),"",MB_OK);
    //get size of file
    HINTERNET     hFile = InternetOpenUrl(hInternet, gal.c_str(), NULL, 0, 0, 0);
    DWORD sizeBuffer;
    DWORD length = sizeof(sizeBuffer);
    BYTE *buffer = NULL;

    bool succeeds = HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, (LPVOID)&sizeBuffer, &length, NULL);
    if (!succeeds)
    {
        throw "Unable to fetch map";
        return (HBITMAP) NULL;
    }
    buffer = new BYTE[sizeBuffer];

    //initialize all elements to 0
    for (int i = 0; i < sizeBuffer; i++)
        buffer[i] = 0;

    LPVOID pvData = NULL; 
    HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, sizeBuffer); 
    pvData = GlobalLock(hGlobal); 
    DWORD bytesRead;
    DWORD bytesToRead = sizeBuffer;
    if (hFile)
    {
        InternetReadFile(hFile, pvData, bytesToRead, &bytesRead);
    }
    else
        throw "Unable to grab overview image";

    GlobalUnlock(hGlobal); 
    CloseHandle(hFile); 
    LPSTREAM pstm = NULL; 
    // create IStream* from global memory 
    HRESULT hr = CreateStreamOnHGlobal(hGlobal, TRUE, &pstm); 
    // Create IPicture from image file 
    if (gpPicture) 
        gpPicture->Release(); 
    hr = OleLoadPicture(pstm, sizeBuffer, FALSE, IID_IPicture, (LPVOID *)&gpPicture); 
    pstm->Release(); 
    gpPicture-> get_Handle ((OLE_HANDLE *) & hBitmap); 
    hBitmap = (HBITMAP) CopyImage (hBitmap, IMAGE_BITMAP, 0,0,0); 
    InternetCloseHandle(hFile);
    InternetCloseHandle(hInternet);
    return hBitmap;
}

#pragma comment( lib, "user32.lib" )
#pragma comment( lib, "olepro32.lib" )
#pragma comment( lib, "gdi32.lib" )
#pragma comment( lib, "ole32.lib" )
#pragma comment( lib, "Wininet.lib" )

#include <windows.h> 
#include <Wininet.h>
#include <olectl.h> 

#define COLORREF2RGB(Color) (Color & 0xff00) | ((Color >> 16) & 0xff) \
                                | ((Color << 16) & 0xff0000)

LPPICTURE gpPicture; 
HBITMAP hbm;

HBITMAP ChangePixels(HBITMAP hBmp,COLORREF cOldColor,COLORREF cNewColor,HDC hBitmapDC)
{
    HBITMAP hReturnBitmap = NULL;
    if (hBmp)
    {   
        HDC BufferDC=CreateCompatibleDC(NULL); 
        if (BufferDC)
        {
            HBITMAP hTempBitmap = (HBITMAP) NULL;
            if (hBitmapDC)
                if (hBmp == (HBITMAP)GetCurrentObject(hBitmapDC, OBJ_BITMAP))
                {
                    hTempBitmap = CreateBitmap(1, 1, 1, 1, NULL);
                    SelectObject(hBitmapDC, hTempBitmap);
                }
            HGDIOBJ PreviousBuffer=SelectObject(BufferDC,hBmp);
            HDC DirectDC=CreateCompatibleDC(NULL); 
            if (DirectDC)
            {
                BITMAP bm;
                GetObject(hBmp, sizeof(bm), &bm);
                BITMAPINFO BitmapInfo; 
                ZeroMemory(&BitmapInfo,sizeof(BITMAPINFO));
                BitmapInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
                BitmapInfo.bmiHeader.biWidth=bm.bmWidth;
                BitmapInfo.bmiHeader.biHeight=bm.bmHeight;
                BitmapInfo.bmiHeader.biPlanes = 1;
                BitmapInfo.bmiHeader.biBitCount = 32;
                UINT * upPixels; 
                HBITMAP DirectBitmap= CreateDIBSection(DirectDC, (BITMAPINFO *)&BitmapInfo, DIB_RGB_COLORS,(void **)&upPixels, NULL, 0);
                if (DirectBitmap)
                {
                    HGDIOBJ PreviousObject=SelectObject(DirectDC, DirectBitmap);
                    BitBlt(DirectDC,0,0,bm.bmWidth,bm.bmHeight,BufferDC,0,0,SRCCOPY);                   
                    char   cNewColorRef=COLORREF2RGB(cNewColor);
                    for (int iIndex = ((bm.bmWidth*bm.bmHeight) - 1); iIndex >= 0; iIndex--)
                        if (upPixels[iIndex] == cOldColor) upPixels[iIndex] = cNewColorRef;
                    SelectObject(DirectDC,PreviousObject);
                    hReturnBitmap=DirectBitmap;
                }
                DeleteDC(DirectDC);
            }           
            if (hTempBitmap)
            {
                SelectObject(hBitmapDC, hBmp);
                DeleteObject(hTempBitmap);
            }
            SelectObject(BufferDC,PreviousBuffer);
            DeleteDC(BufferDC);
        }
    }
    return hReturnBitmap;
}

HBITMAP getFromInternet(char *pURL)
{
    HBITMAP    hBitmap;
    HINTERNET      hInternet = InternetOpen( "GINA: Version 0.1", INTERNET_OPEN_TYPE_DIRECT, NULL, 0,0);
    HINTERNET     hFile = InternetOpenUrl(hInternet, pURL, NULL, 0, 0, 0);
    DWORD sizeBuffer;
    DWORD length = sizeof(sizeBuffer);

    bool succeeds = HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, (LPVOID)&sizeBuffer, &length, NULL);
    if (!succeeds)
    {
        throw "Unable to fetch map";
        return (HBITMAP) NULL;
    }
    LPVOID pvData = NULL; 
    HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, sizeBuffer); 
    pvData = GlobalLock(hGlobal); 
    DWORD bytesRead;
    DWORD bytesToRead = sizeBuffer;
    if (hFile)
    {
        InternetReadFile(hFile, pvData, bytesToRead, &bytesRead);
    }
    else
        throw "Unable to grab overview image";
    GlobalUnlock(hGlobal); 
    CloseHandle(hFile); 
    LPSTREAM pstm = NULL; 
    // create IStream* from global memory 
    HRESULT hr = CreateStreamOnHGlobal(hGlobal, TRUE, &pstm); 
    // Create IPicture from image file 
    if (gpPicture) 
        gpPicture->Release(); 
    hr = OleLoadPicture(pstm, sizeBuffer, FALSE, IID_IPicture, (LPVOID *)&gpPicture); 
    pstm->Release(); 
    gpPicture-> get_Handle ((OLE_HANDLE *) & hBitmap); 
    hBitmap = (HBITMAP) CopyImage (hBitmap, IMAGE_BITMAP, 0,0,0); 
    InternetCloseHandle(hFile);
    InternetCloseHandle(hInternet);
    return hBitmap;
}

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ; 


int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) 
{ 
    static char szAppName[] = "JpegExample" ; 
    HWND hwnd; 
    MSG msg; 
    WNDCLASSEX wndclass; 

    int WinSize = 500; 
    int Left = 200; 
    int Top = 100; 

    wndclass.cbSize = sizeof (wndclass) ; 
    wndclass.style = CS_HREDRAW | CS_VREDRAW; 
    wndclass.lpfnWndProc = WndProc ; 
    wndclass.cbClsExtra = 0 ; 
    wndclass.cbWndExtra = 0 ; 
    wndclass.hInstance = hInstance ; 
    wndclass.hIcon = NULL ; 
    wndclass.hCursor = LoadCursor (NULL, IDC_ARROW) ; 
    wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW) ; 
    wndclass.lpszMenuName = NULL ; 
    wndclass.lpszClassName = szAppName ; 
    wndclass.hIconSm = NULL ; 

    RegisterClassEx (&wndclass) ; 

    hwnd = CreateWindow ( 
        szAppName, 
        "Jpeg Example",
        WS_OVERLAPPEDWINDOW, 
        Left, 
        Top , 
        WinSize, 
        WinSize, 
        NULL, 
        NULL, 
        hInstance, 
        NULL 
        ) ; 

    ShowWindow (hwnd, iCmdShow); 
    UpdateWindow (hwnd); 

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


LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) 
{ 
    HDC hdc,hMemDC; 
    PAINTSTRUCT ps; 
    BITMAP bm;
    RECT MainRc;
    POINT pt;
    COLORREF colNew, colOld;

    switch (iMsg) 
    { 
        case WM_RBUTTONDOWN:
            colNew            = RGB(255,255,255);
            colOld            = RGB(0,0,0);
            hbm =  ChangePixels(hbm,colOld,colNew,NULL);
            InvalidateRect(hwnd, NULL, TRUE); 
            return 0;
        case WM_CREATE : 
            hbm = getFromInternet("http://www.imperialconflict.com/images/Galaxies/Capricorn.overview.jpg");
            return 0 ; 
        case WM_PAINT: 
            hdc = BeginPaint(hwnd, &ps); 
            GetClientRect(hwnd,&MainRc);
            hMemDC =  CreateCompatibleDC(hdc);
            SelectObject(hMemDC,hbm);
            GetObject(hbm,sizeof(BITMAP),&bm);
            pt.x = MainRc.right;
            pt.y = MainRc.bottom;
            SetStretchBltMode(hdc,COLORONCOLOR);
            StretchBlt(hdc,0,0,pt.x,pt.y,hMemDC,0,0,800,600,SRCCOPY);
            DeleteDC(hMemDC);
            EndPaint(hwnd, &ps);     
            return 0 ; 
        case WM_DESTROY : 
            PostQuitMessage (0) ; 
            return 0 ; 
    } 
    return DefWindowProc (hwnd, iMsg, wParam, lParam) ; 
}

#ifndef jpegSourceManager_H
#define jpegSourceManager_H

//modified from http://www.groupsrv.com/science/about102031.html

#include <jpeglib.h>

typedef struct MemSource
{
       struct jpeg_source_mgr jsm;
       JOCTET * next_input_byte;
       size_t bytes_in_buffer;          
}MemSource;

static void initSource (j_decompress_ptr cinfo)
{    
}
static boolean fillInputBuffer ( j_decompress_ptr cinfo)
{
    //should never get here. Jpeg is bad if this happens
    throw "FillInputBuffer called. Jpeg Bad";
    return true;
}
static void skipInputData (j_decompress_ptr cinfo, long skipBytes)
{
    //skipping bytes in stream that libjpeg doesn't care for
    MemSource *msm = (MemSource *)cinfo->src;
    msm->jsm.bytes_in_buffer = msm->bytes_in_buffer - skipBytes;
    msm->jsm.next_input_byte += skipBytes;            
}
static void doneWithSource (j_decompress_ptr cinfo)
{}

static void setUpSource( j_decompress_ptr cinfo, unsigned char *imageData, int length)
{
       static MemSource mS;
       if (cinfo->src == NULL)
          cinfo->src = (struct jpeg_source_mgr *) &mS;
       MemSource *msm = (MemSource *)cinfo->src;
       msm->jsm.next_input_byte =         imageData;       
       msm->jsm.init_source =             initSource;
       msm->jsm.fill_input_buffer =       fillInputBuffer;
       msm->jsm.skip_input_data =         skipInputData;
       msm->jsm.term_source =             doneWithSource;
       msm->jsm.resync_to_restart =       jpeg_resync_to_restart; //provided by libjpeg
       msm->bytes_in_buffer =             msm->jsm.bytes_in_buffer = length;
       msm->next_input_byte =             imageData;
}

#endif

#define ROW_SIZE     cinfo.output_width * 3

void Internet::loadImage(unsigned char* jpgData, int length)
{
    	unsigned char *rawImage = NULL;
    	unsigned char *rawBuffer = NULL;
    	MapFile map;
    	/* these are standard libjpeg structures for reading(decompression) */
    	struct jpeg_decompress_struct cinfo;
    	struct jpeg_error_mgr jerr;
    	/* libjpeg data structure for storing one row, that is, scanline of an image */
    	cinfo.err = jpeg_std_error( &jerr );
    	jpeg_create_decompress( &cinfo );
    	//set up source manager so we can read from memory
    	setUpSource( &cinfo, jpgData, length );
    	jpeg_read_header( &cinfo, TRUE );
    	jpeg_start_decompress( &cinfo );
        
    	rawImage = new unsigned char[cinfo.output_height * ROW_SIZE];
    	rawBuffer = new unsigned char[ROW_SIZE];
    	
    	while (cinfo.output_scanline < cinfo.output_height)
        {
              jpeg_read_scanlines( &cinfo, &rawBuffer, 1 );
              memcpy(&rawImage[cinfo.output_scanline * ROW_SIZE], rawBuffer, ROW_SIZE);
        }
        
        //get image dimensions
        pMap->width = (cinfo.output_width - 8) / 8; //8 pixel border, 8 pixels per unit
        pMap->height = (cinfo.output_height - 8) / 8;
        char temp[50];
        MessageBox(NULL,itoa(pMap->height, temp, 10),"",MB_OK);
    	/* wrap up decompression, destroy objects, free pointers*/
    	jpeg_finish_decompress( &cinfo );
    	jpeg_destroy_decompress( &cinfo );
    	
    	delete [] rawImage;
    	delete [] rawBuffer;
    	delete [] jpgData;
    	return;
}