Graphics

// open the pic file 
void CTestLoadJPEGDlg::OnBtnNew() 
{
    CFileDialog cFileDlg( TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "File(*.JPEG;*.JPG;*.BMP)|*.JPEG;*.JPG;*.BMP||", NULL);
      
    if (IDOK == cFileDlg.DoModal())
    {
        // Get the pic and length
        CString strPicFilePath;
        strPicFilePath = cFileDlg.GetPathName();
        TRACE("the file path:%s\n",strPicFilePath);
        CFile cFile(strPicFilePath,CFile::modeRead);
        int nPicFileBufSize = cFile.GetLength(); 

        // Allocates movable memory. 
        // In Win32, memory blocks are never moved in physical memory, but they can be moved within the default heap. 
        HGLOBAL hGlobal = ::GlobalAlloc(GMEM_MOVEABLE, nPicFileBufSize);
        if(NULL != hGlobal)
        {
            // locks a global memory object and returns a pointer to the first byte of the object's memory block
            LPVOID lpData = NULL;
            lpData = ::GlobalLock(hGlobal);
            if (NULL != lpData)
            {
                // read and lock
                cFile.ReadHuge(lpData, nPicFileBufSize);
                GlobalUnlock(hGlobal);

                // create a stream object in the heap
                IStream *pIstream = NULL;
                CreateStreamOnHGlobal(hGlobal,TRUE,&pIstream);
                if (NULL != pIstream)
                {
                    // load the pic by the stream object
                    HRESULT hr = ::OleLoadPicture(pIstream, nPicFileBufSize, TRUE, IID_IPicture, (LPVOID*)&m_iPicture);
                    if (FAILED(hr))
                    {
                        TRACE("OleLoadPicture failed!!\n");
                        goto CLOSEFILE;
                    }
                    pIstream->Release();
                }
            }
            else
            {
                TRACE("lpData=NULL!!!\n");
                goto CLOSEFILE;
            }
        }
        else
        {
            TRACE("hGlobal=NULL!!!\n");
            goto CLOSEFILE;
        }

        // show the pic
        if (NULL != m_iPicture)
        {   
            CSize sizeInHimetric;   // pic size, metric system

            HRESULT hr = NULL;
            hr = m_iPicture->get_Width(&sizeInHimetric.cx);
            if (FAILED(hr))
            {
                TRACE("get_Width failed!!\n");
                goto CLOSEFILE;
            }
            hr = m_iPicture->get_Height(&sizeInHimetric.cy);
            if (FAILED(hr))
            {
                TRACE("get_Height failed!!\n");
                goto CLOSEFILE;
            }

            //himetric convert to inch, then inch to pixel

            HDC hDCScreen = ::GetDC(NULL);
            int nPixelsPerInchX = ::GetDeviceCaps(hDCScreen, LOGPIXELSX);
            int nPixelsPerInchY = ::GetDeviceCaps(hDCScreen, LOGPIXELSY);
            ::ReleaseDC(NULL, hDCScreen);

            CSize sizeInPixel;  // pic size, pixel system
            sizeInPixel.cx = MulDiv(sizeInHimetric.cx, nPixelsPerInchX, HIMETRIC_PER_INCH);
            sizeInPixel.cy = MulDiv(sizeInHimetric.cy, nPixelsPerInchY, HIMETRIC_PER_INCH);

            m_szPicPixel = sizeInPixel;
            m_szPicHimetric = sizeInHimetric;

            DrawPic();
        }
        
    CLOSEFILE:
        cFile.Close();
    }
    return;
}

// draw pic
void CTestLoadJPEGDlg::DrawPic()
{
    if (NULL == m_iPicture)
    {
        TRACE("m_iPicture=NULL!!\n");
        return;
    }

    CRect rect;
    m_staticPicRect.GetWindowRect(rect);
    
    // the left point
    CPoint ptTopLeft;
    ptTopLeft = rect.TopLeft();

    // zoom rate. [>1.0:zoom in, <1.0:zoom out] 
    float fZoomRate = 1.0;

    int   xSrcPos = (int)(ptTopLeft.x / fZoomRate);              
    int   ySrcPos = (int)(ptTopLeft.y / fZoomRate);            
    int   cxSrcWidth = (int)(rect.Width() / fZoomRate);          
    int   cySrcHeight = (int)(rect.Height() / fZoomRate);       
  
    CDC* dc = GetDC();
    int nPixelsPerInchX = ::GetDeviceCaps(*dc, LOGPIXELSX);
    int nPixelsPerInchY = ::GetDeviceCaps(*dc, LOGPIXELSY);

    // MulDiv(a,b,c) -> a*b/c

    // Horizontal   offset   in   source   picture
    int xHimetric = MulDiv(xSrcPos, HIMETRIC_PER_INCH, nPixelsPerInchX);   
    // Vertical   offset   in   source   picture   
    int yHimetric = MulDiv(ySrcPos, HIMETRIC_PER_INCH, nPixelsPerInchY);
    // Amount   to   copy   horizontally   in   source   picture
    int wHimetric = MulDiv(cxSrcWidth, HIMETRIC_PER_INCH, nPixelsPerInchX);
    // Amount   to   copy   vertically   in   source   picture   
    int hHimetric = MulDiv(cySrcHeight, HIMETRIC_PER_INCH, nPixelsPerInchY);

    HRESULT hr = m_iPicture->Render(dc->GetSafeHdc(), rect.left, rect.top, rect.Width(), rect.Height(), 
                xHimetric, yHimetric, wHimetric, hHimetric, NULL);

    if (FAILED(hr))
    {
        TRACE("Render failed!!\n");
        return;
    }
    TRACE("Render PIC SUC!!\n");
}

//Create a temporay bitmap and draw the metafile to it, then save it to disk
Bitmap saveImage = new Bitmap(m_canvasWidth, m_canvasHeight);
Graphics g = Graphics.FromImage(saveImage);
g.DrawImage(this.zoomAndScrollPictureBox.Image, new Point(0,0));
g.Dispose();


try
{
    saveImage.Save(savePath,System.Drawing.Imaging.ImageFormat.Bmp);
}
catch (Exception saveEx)
{
    MessageBox.Show(saveEx.Message);
}

RECT r = GetRect(); // That's not really what the function is called, but you get the gist...

HBRUSH brush = CreateSolidBrush(RGB(0x00, 0xD7, 0xEC));	
FillRect(hdc, &r, brush);
DeleteObject(brush);