CodeProject: Loading JPG & PNG resources using GDI+. Free source code and programming help

Announcements

Monthly Competition

Articles

Desktop Development

Web Development

Enterprise Systems

Content Management Server

Microsoft BizTalk Server

SQL Reporting Services

Platforms, Frameworks & Libraries

Windows Communication Foundation

Windows Presentation Foundation

Windows Workflow Foundation

Cryptography & Security

Threads, Processes & IPC

Development Lifecycle

Debug Tips

Design and Architecture

Uncategorised Technical Blogs

Services

Code-signing Certificates

Job Board

CodeProject VS2008 Addin

Feature Zones

Product Showcase

WhitePapers / Webcasts

IBM DeveloperWorks

ASP.NET Web Hosting

Advanced Search

Report

Discuss

46 votes for this article.

Popularity: 7.64 Rating: 4.60 out of 5

Introduction

Recently, I needed to display some JPG and PNG files. I had an old copy of LeadTools and the open source libraries for both formats, but wanted my executable to be as small as possible. So I decided to give GDI+ a try. I quickly found GDI+ to be poorly designed and very quirky, but it worked well for my purposes until I discovered, to my horror, that GDI+ cannot load JPG or PNG images stored as resources!

Like, I'm sure, other developers facing this issue, I disbelieved the documentation and tried Bitmap::FromResource to no avail. While perusing the Bitmap methods available, I ran across Bitmap::FromStream.

After a bit of testing and several errors, due mostly to the horrible GDI+ documentation, I came up with working code. After a night of rest, I decided to encapsulate the code in a simple class to ensure memory got freed. The result were two classes: CGdiPlusBitmap and CGdiPlusBitmapResource.

The Gotcha

Before discussing the code itself, there is a caveat with GDI+ that must be addressed. With JPG, some TIFF and other formats, the original image information must be available at all times. In other words, if you open a bitmap using Bitmap::FromFile, you cannot delete or otherwise change that file while the image is open. This same restriction applies to CGdiPlusBitmapResource. (My testing found that PNG and BMP files don't seem to follow this generalization, though I don't know if this is standard behavior or just a fluke with my file set.)

GDI+ Initialization

GDI+ needs to be initialized before any GDI+ calls are made. I suggest adding the following data member to the class derived from CWinApp:

ULONG_PTR m_gdiplusToken;

In InitInstance(), add the following calls:

Gdiplus::GdiplusStartupInput gdiplusStartupInput;
Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL);

In ExitInstance(), add the following:

Gdiplus::GdiplusShutdown(m_gdiplusToken);

The Class

I created two classes, with the base class being a very simple encapsulation of Bitmap and the derived class encapsulating the global memory. I suppose that if I ever had the patience and desire, I could extend that class, but I have no need to do so. (If you're curious why I didn't simply derive from the ATL class CImage, it's because the code was used in a program that didn't use MFC or ATL. However, the code is so simple, it could easily be modified to use CImage as the base class.)

I'm not going to bother going over the CGdiPlusBitmap class except to say that it has a single, public, data member Bitmap* m_pBitmap. (In the class I prefaced the GDI+ objects with the Gdiplus namespace in case the developer doesn't want to declare using namespace Gdiplus;.)

The CGdiPlusBitmapResource class has several constructors and several overloaded Load functions. The overloaded functions simply allow lazy programmers, like myself, to not have to type MAKEINTRESOURCE. The main Load function takes the resource name and type as strings and is the key to the class. This code follows in its entirety:

inline
bool CGdiPlusBitmapResource::Load(LPCTSTR pName, LPCTSTR pType, 
                                  HMODULE hInst)
{
    Empty();

    HRSRC hResource = ::FindResource(hInst, pName, pType);
    if (!hResource)
        return false;
    
    DWORD imageSize = ::SizeofResource(hInst, hResource);
    if (!imageSize)
        return false;

    const void* pResourceData = ::LockResource(::LoadResource(hInst, 
                                              hResource));
    if (!pResourceData)
        return false;

    m_hBuffer  = ::GlobalAlloc(GMEM_MOVEABLE, imageSize);
    if (m_hBuffer)
    {
        void* pBuffer = ::GlobalLock(m_hBuffer);
        if (pBuffer)
        {
            CopyMemory(pBuffer, pResourceData, imageSize);

            IStream* pStream = NULL;
            if (::CreateStreamOnHGlobal(m_hBuffer, FALSE, &pStream) == S_OK)
            {
                m_pBitmap = Gdiplus::Bitmap::FromStream(pStream);
                pStream->Release();
        if (m_pBitmap)
        { 
          if (m_pBitmap->GetLastStatus() == Gdiplus::Ok)
            return true;

          delete m_pBitmap;
          m_pBitmap = NULL;
        }
            }
            m_pBitmap = NULL;
            ::GlobalUnlock(m_hBuffer);
        }
        ::GlobalFree(m_hBuffer);
        m_hBuffer = NULL;
    }
    return false;
}

I find the code very self explanatory, though those that know the return value of ::LoadResource is an HGLOBAL may find the apparent double copy using CopyMemory confusing. In brief CreateStreamOnHGlobal requires a HGLOBAL handle allocated by GlobalAlloc using the GMEM_MOVEABLE flag.

The Demo

The demo is a Visual Studio .NET 2003 project with ANSI and UNICODE builds. It allows you to load resampled JPG or PNG resources (For the curious, I took both photographs in Oahu, Hawaii for, and while filming content of, a multimedia product. One is of Laie Bay, the other is a sunset viewed from Waikiki.)

GDI+ Disclaimer

I am not a GDI+ expert, nor am I a big fan, even if I do find GDI+ occasionally very useful. Please don't ask me questions about it.

Why not IPicture?

I've been asked why I didn't use IPicture. The answer is threefold; first, IPicture does not support PNG images. Second, IPicture is pretty much only an image loader, with little more capability than the standard GDI bitmap calls. Third, IPicture decodes the image data immediately. JPG and GIF images will use more memory than this class.

Updates

22 April 2004

CreateStreamOnHGlobal now uses FALSE for the second argument since Bitmap requires that the memory be retained for at least JPG images and I decided to err on the side of caution. Interestingly, my testing showed this flag is often ignored, but I received reports that this wasn't always the case and was technically incorrect.

In addition, while fixing this bug I realized I wasn't clearing up the global memory on failure. That resulted in the code being rearranged as it is now.

15 June 2004

If Gdiplus::Bitmap::FromStream fails, I added what I believe is redundant, but more correct code in handling m_pBitmap. (Unfortunately, the documentation is silent on the subject as to whether NULL will always be returned on failure.)

3 September 2004

Added a section on GDI+ initialization.

Fixed a potential memory leak on image load failure in the sample application.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Joe Woodbury

Member

Joe is one of those software engineers with a film degree. His first paid programming job (what, you think film is a good way to make a living?) was writing games for Apple II's using 6502 assembly. He soon moved to 80x86 assembly, C then C++ for a long time and finally, C#/.NET.

He first wrote software for Windows 3.0 in 1990, when it was first released. Save for some continued work in DOS and a horid, and mercifully brief, foray into OS/2, he has concentrated on designing and writing Windows applications, libraries and middleware, whatever that is.

Occupation:	Software Developer (Senior)
Location:	United States

Other popular GDI+ articles:

Image Processing Lab in C#
A tool and library for image processing
Image Processing for Dummies with C# and GDI+ Part 1 - Per Pixel Filters
The first in a series of articles which will build an image processing library in C# and GDI+
A 3D Plotting Library in C#
A library which draws 3D images on any GDI+ Graphics object.
A lovely goldfish desktop pet (using alpha-PNG and GDI+)
Using alpha-PNG and GDI+ technology to implement a desktop pet fish!
Image Processing for Dummies with C# and GDI+ Part 5 - Displacement filters, including swirl
In the fifth installment, we build a framework for generating filters that work by changing a pixel's location, rather than colour.

Article Top

You must Sign In to use this message board.

FAQ
Noise Tolerance Layout Per page

Msgs 1 to 25 of 95 (Total in Forum: 95) (Refresh)

FirstPrevNext

Please Suggest?

prda

23:58 23 Jun '09

Is this code works with ATL projects. Requirement is IE toolbar to have a PNG icons instead of ICO.Now It works fine with ICO.I need to make it work for PNG.Any Help??
Sign In·View Thread·PermaLink

Re: Please Suggest?

Joe Woodbury

6:03 24 Jun '09

I can think of no reason this wouldn't work with ATL. Anyone who thinks he has a better idea of what's good for people than people do is a swine. - P.J. O'Rourke
Sign In·View Thread·PermaLink

PNG 8bit 16bit

Ray Guan

0:37 17 Apr '09

great work. thanks. can i save as 8 bit PNG file ? how ? Today is a gift, that's why we call it present
Sign In·View Thread·PermaLink

Re: PNG 8bit 16bit

Joe Woodbury

6:52 17 Apr '09

Not sure. I've only used GDI+ to load and display images. For programs that need to manipulate them, I've had access to LeadTools. GDI+ has an Image::Save method, but I've never used it. If you're converting from one bit-per-pixel count to a lower one, you'll need to use some sort of dithering.

Anyone who thinks he has a better idea of what's good for people than people do is a swine.
- P.J. O'Rourke

Note: CImage does not support transparent (alpha) PNG

ZhenyOK

0:28 15 Feb '09

In case you wonder (like I did) if it might be simpler to use CImage along similar lines and avoid GDI+
It indeed works using CImage::Load(IStream*) and the image is displayed.
The only catch is that the transparency (alpha channel) info from PNG image is either lost or (most probably) just ignored in CImage. Some articles recommend manually 'pre-multiplying' color values by alpha =)
Gdiplus::Bitmap works fine.

P.S. I wonder if it might be a reason why IE did not handle transparent PNGs until recently Wink

5.00/5 (1 vote)

Small notice about image size !

Zitoune 2

0:42 8 Dec '08

Hi,

Nice job I use it on my app with PNG on a dialog: It works fine !
But I notice something when the image is loaded, the size was not the same as the original file, and blured as a redimensionned picture.
After a small investigation, I have found that my pictures made with Gimp were scaled in 72 DPI (Dot Per Inch) instead of 96 DPI in native. I scaled them back in 96 DPI, now everything looks find.
I didn't try in other format than PNG, and I didn't notice that anybody report a problem about this.
Anyway, this can be usefull for anyone that meet this kind of behaviour with images.

Bye.
Big Grin

Active Double Click and move the button

vic_mrh

1:34 25 Nov '08

First of all thank you very much for this code... I am trying to change the functionality in order to do something when the button is double clicked and to move the button or the dialog that contains the button when the left button is released, do you think is possible? could you give me some clues? Thanks in advance
Sign In·View Thread·PermaLink

Re: Active Double Click and move the button

vic_mrh

1:44 25 Nov '08

Hello, another more question, when the mouse is over the image the image is resized, it’s mean I see two images with different size, do you know which the problem could be? Thank you very much
Sign In·View Thread·PermaLink

look like geneous code

zhongyougang@gmail.com

21:54 9 Oct '08

look like geneous code,very good
Sign In·View Thread·PermaLink

Replacing CreateStreamOnHGlobal with a custom IStream object to directly read resource data

Member 2833543

8:59 18 Aug '08

Instead of having to copy the resource data to global memory in order to use CreateStreamOnHGlobal, I wrote a simple COM class to allow the image to be loaded directly from the resource data.


////////////////////////////////////////////////////////////////////////////////
//
class MEMORY_STREAM
//
////////////////////////////////////////////////////////////////////////////////
:
    IStream
{
    ULONG m_ReferenceCount;
    const PUCHAR m_Memory;
    ULARGE_INTEGER m_Offset;
    ULARGE_INTEGER m_Size;

public:
    MEMORY_STREAM
    (
        const void* Memory,
        DWORD Size
    );
    
    // IUnknown
    
    STDMETHODIMP QueryInterface
    (
        REFIID InterfaceId,
        void** Object
    );
    
    STDMETHODIMP_(ULONG) AddRef();
    
    STDMETHODIMP_(ULONG) Release(); 

    // ISequentialStream
        
    STDMETHODIMP Read
    ( 
        void* Buffer,
        ULONG ReadBytes,
        ULONG* BytesRead
    );
        
    STDMETHODIMP Write
    ( 
        const void* Buffer,
        ULONG WriteBytes,
        ULONG* BytesWritten
    );

    // IStream

    STDMETHODIMP Seek
    ( 
        LARGE_INTEGER Move,
        DWORD Origin,
        ULARGE_INTEGER* NewPosition
    );
    
    STDMETHODIMP SetSize
    ( 
        ULARGE_INTEGER NewSize
    );
    
    STDMETHODIMP CopyTo
    ( 
        IStream* Stream,
        ULARGE_INTEGER CopyBytes,
        ULARGE_INTEGER* BytesRead,
        ULARGE_INTEGER* BytesWritten
    );
    
    STDMETHODIMP Commit
    ( 
        DWORD Flags
    );
    
    STDMETHODIMP Revert();
    
    STDMETHODIMP LockRegion
    ( 
        ULARGE_INTEGER Offset,
        ULARGE_INTEGER Size,
        DWORD Type
    );
    
    STDMETHODIMP UnlockRegion
    ( 
        ULARGE_INTEGER Offset,
        ULARGE_INTEGER Size,
        DWORD Type
    );
    
    STDMETHODIMP Stat
    ( 
        STATSTG* Stats,
        DWORD Flag
    );
    
    STDMETHODIMP Clone
    ( 
        IStream** Stream
    );
};


////////////////////////////////////////////////////////////////////////////////
//
// MEMORY_STREAM Implementation
//
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODCALLTYPE MEMORY_STREAM::MEMORY_STREAM
(
    const void* Image,
    DWORD Size
)
//
////////////////////////////////////////////////////////////////////////////////
:
    m_ReferenceCount(0),
    m_Memory((PUCHAR)Image)
{
    m_Offset.QuadPart = 0;
    m_Size.QuadPart = Size;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP_(ULONG) MEMORY_STREAM::AddRef()
//
////////////////////////////////////////////////////////////////////////////////
{
    return ++m_ReferenceCount;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP_(ULONG) MEMORY_STREAM::Release()
//
////////////////////////////////////////////////////////////////////////////////
{
    ULONG ReferenceCount(--m_ReferenceCount);
    
    if (m_ReferenceCount == 0)
    {
        delete this;
    }

    return ReferenceCount;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::QueryInterface
(
    REFIID InterfaceId,
    void** Object
)
//
////////////////////////////////////////////////////////////////////////////////
{
    while (true)
    {
        if (IsEqualGUID(InterfaceId, __uuidof(IUnknown)))
        {
            *Object = static_cast<IUnknown*>(this);
            break;
        }

        if (IsEqualGUID(InterfaceId, __uuidof(IStream)))
        {
            *Object = static_cast<IStream*>(this);
            break;
        }

        *Object = NULL;
        return E_NOINTERFACE;
    }

    AddRef();
    return S_OK;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::Read
( 
    void* Buffer,
    ULONG ReadBytes,
    ULONG* BytesRead
)
//
////////////////////////////////////////////////////////////////////////////////
{
    ULONG Length;
    HRESULT Result;

    if (m_Offset.QuadPart + ReadBytes > m_Size.QuadPart)
    {
        Length = (ULONG)(m_Size.QuadPart - m_Offset.QuadPart);
        Result = S_FALSE;
    }
    else
    {
        Length = ReadBytes;
        Result = S_OK;
    }
        
    CopyMemory(Buffer, m_Memory + (ULONG_PTR)m_Offset.QuadPart, Length);
    m_Offset.QuadPart += Length;

    if (BytesRead)
    {
        *BytesRead = Length;
    }

    return Result;
}

    
////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::Write
( 
    const void* Buffer,
    ULONG WriteBytes,
    ULONG* BytesWritten
)
//
////////////////////////////////////////////////////////////////////////////////
{
    return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::Seek
( 
    LARGE_INTEGER Move,
    DWORD Origin,
    ULARGE_INTEGER* NewPosition
)
//
////////////////////////////////////////////////////////////////////////////////
{
    switch (Origin)
    {
        case STREAM_SEEK_SET:
            m_Offset.QuadPart = Move.QuadPart;
            break;
            
        case STREAM_SEEK_CUR:
            if (m_Offset.QuadPart + Move.QuadPart > m_Size.QuadPart)
            {
                return STG_E_INVALIDFUNCTION;
            }
            
            m_Offset.QuadPart += Move.QuadPart;
            break;
            
        case STREAM_SEEK_END:
            if ((ULONGLONG)Move.QuadPart > m_Offset.QuadPart)
            {
                return STG_E_INVALIDFUNCTION;
            }
            
            m_Offset.QuadPart = m_Size.QuadPart - Move.QuadPart;
            break;
            
        default:
            return STG_E_INVALIDFUNCTION;
    }
            
    if (NewPosition)
    {
        *NewPosition = m_Offset;
    }

    return S_OK;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::SetSize
( 
    ULARGE_INTEGER NewSize
)
{
    return E_NOTIMPL;
}

////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::CopyTo
( 
    IStream* Stream,
    ULARGE_INTEGER CopyBytes,
    ULARGE_INTEGER* BytesRead,
    ULARGE_INTEGER* BytesWritten
)
//
////////////////////////////////////////////////////////////////////////////////
{
    return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::Commit
( 
    DWORD Flags
)
{
    return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::Revert()
{
    return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::LockRegion
( 
    ULARGE_INTEGER Offset,
    ULARGE_INTEGER Size,
    DWORD Type
)
//
////////////////////////////////////////////////////////////////////////////////
{
    return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::UnlockRegion
( 
    ULARGE_INTEGER Offset,
    ULARGE_INTEGER Size,
    DWORD Type
)
//
////////////////////////////////////////////////////////////////////////////////
{
    return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::Stat
( 
    STATSTG* Stats,
    DWORD Flags
)
//
////////////////////////////////////////////////////////////////////////////////
{
    ZeroMemory(Stats, sizeof(*Stats));

    if ((Flags & STATFLAG_NONAME) != STATFLAG_NONAME)
    {
        Stats->pwcsName = (LPOLESTR)CoTaskMemAlloc(sizeof(OLECHAR));
        
        if (Stats->pwcsName)
        {
            *Stats->pwcsName = 0;
        }
    }
 
    Stats->type = STGTY_STREAM;
    Stats->cbSize = m_Size;
    return S_OK;
}        


////////////////////////////////////////////////////////////////////////////////
//
STDMETHODIMP MEMORY_STREAM::Clone
( 
    IStream** Stream
)
//
////////////////////////////////////////////////////////////////////////////////
{
    return E_NOTIMPL;
}


////////////////////////////////////////////////////////////////////////////////
//
HRESULT CreateStreamOnResource
(
    HMODULE Instance,
    PCTSTR Type,
    PCTSTR Name,
    IStream** Stream
)
//
////////////////////////////////////////////////////////////////////////////////
{
	HRSRC ResourceHandle = FindResource(Instance, Name, Type);

    if (ResourceHandle)
    {
    	DWORD Size = ::SizeofResource(Instance, ResourceHandle);

	    if (Size)
	    {
            HGLOBAL Resource = LoadResource(Instance, ResourceHandle);

            if (Resource)
            {
                const void* Data = LockResource(Resource);
                
                MEMORY_STREAM* MemoryStream = new MEMORY_STREAM(Data, Size);
                
                if (!MemoryStream)
                {
                    return E_OUTOFMEMORY;
                }
                
                return MemoryStream->QueryInterface
                (
                    __uuidof(IStream),
                    (void**)Stream
                );
            }
        }
    }

    return HRESULT_FROM_WIN32(GetLastError());
}

You can then use the class like this to create a GDI+ bitmap:


        IStream* Stream;
        Bitmap* bitmap(NULL);

        if 
        (
            CreateStreamOnResource
            (
                Instance,
                _T("PNG"),
                MAKEINTRESOURCE(IDI_IMAGE),
                &Stream
            ) == S_OK
        )
        {
            bitmap = Gdiplus::Bitmap::FromStream(Stream);
            Stream->Release();
        }

Nick Acquaviva

Re: Replacing CreateStreamOnHGlobal with a custom IStream object to directly read resource data

Joe Woodbury

10:27 18 Aug '08

I like it. This could be an article. Anyone who thinks he has a better idea of what's good for people than people do is a swine. - P.J. O'Rourke
Sign In·View Thread·PermaLink

[Message Deleted]

Member 3116270

18:00 13 Aug '08


Sign In·View Thread·PermaLink

Re: Bug in CreateStreamOnHGlobal

Joe Woodbury

6:21 14 Aug '08

I appreciate feedback, but I find your comments useless without any explanation as to why you are making your assertions. Please explain how Release() is a bug. According to all the documentation I have seen, the Release() is proper.

You statement about try and catch make no sense. You do understand that IStream is part of windows structured storage, not STL.

If you want to have exceptions thrown, you may modify the code for your benefit.

Anyone who thinks he has a better idea of what's good for people than people do is a swine.
- P.J. O'Rourke

Re: Bug in CreateStreamOnHGlobal

Member 3116270

21:24 17 Aug '08

Thanks for your reply.

The testing like this
Begin another thread and load resource image in thread function (could sleep(100) once for a while),
then pop up a simple modal dialog with an edit box, you could see when you press the edit box it will display rubbish data, then press editbox another time, crash!

The problem seems about CreateStreamOnHGlobal, I made second parameter FALSE, then it's ok
HRESULT hResult = ::CreateStreamOnHGlobal(hBuffer, FALSE, &pStream);

HGLOBAL hBuffer = NULL;

try
{
// get resource from PNG
HRSRC hResource = ::FindResource(hInst, MAKEINTRESOURCE(nResourcId), pType);
if (!hResource) throw int();

// get size of read resource
DWORD dwSize = ::SizeofResource(hInst, hResource);
if (!dwSize) throw int();

// allocate memory to store data
hBuffer = ::GlobalAlloc(GMEM_FIXED, dwSize);

// put data into HGLOBAL
HGLOBAL hGresource = ::LoadResource(hInst, hResource);
if (!hGresource) throw int();

// copy data into buffer
void *pData = ::LockResource(hGresource);

memcpy((void*)hBuffer, pData, dwSize);

// convert data into stream
LPSTREAM pStream;
HRESULT hResult = ::CreateStreamOnHGlobal(hBuffer, FALSE, &pStream);
if (hResult != S_OK) throw int();

// convert data into Bitmap
m_pbmPicture = Gdiplus::Bitmap::FromStream(pStream);
bResult = TRUE;
pStream->Release();

// release buffer
::GlobalFree(hBuffer);
}
catch (...) // on error: release memory
{
if (hBuffer)
{
::GlobalFree(hBuffer);
}

if (m_pbmPicture != NULL)
{
delete m_pbmPicture;
m_pbmPicture = NULL;
}
}

Re: Bug in CreateStreamOnHGlobal

Member 3116270

22:26 17 Aug '08

Hi,I'm not an expert, just want to find the problem,

The reason maybe complicated, i just testing your demo(2008) and find no crash, since my project using 2002 I'm not sure if project environment is different.

The testing result is either I change
HRESULT hResult = ::CreateStreamOnHGlobal(hBuffer, FALSE, &pStream);
then lpStream->Release(); it's ok
or I remove lpStream->Release(); , keep HRESULT hResult = CreateStreamOnHGlobal(hBuffer, TRUE, &lpStream);, also ok.

BTW, english is not my first language, sorry for any impolite

could you port this to C# ?

The Code Guru

1:39 1 Jul '08

I really find this to be cool if wrapped in a user control, could you help me port it into C# ? "Imagination is more important than knowledge.." {Albert Einstein}
Sign In·View Thread·PermaLink

Re: could you port this to C# ?

Joe Woodbury

6:19 1 Jul '08

No, since this isn't an issue in .NET. Anyone who thinks he has a better idea of what's good for people than people do is a swine. - P.J. O'Rourke
Sign In·View Thread·PermaLink

Thanks, I used this code here:

Darren Sessions

18:59 13 Jun '08

I used this code in my CGdipButton class and it works well. http://www.codeproject.com/KB/buttons/GdipButton.aspx[^] 5/5
Sign In·View Thread·PermaLink

Same code in a single function

Sean O'Connor

6:11 29 Feb '08

All this inherited object stuff was looking a bit complicated to me so I've re-written this code (thanks very much for it BTW!) in a single function. It seems to work but please let me know if you spot anything wrong with what I've done as I'm new to GDIplus.



Bitmap*      pToolbar;
pToolbar = LoadPNG("TOOLBAR", RT_RCDATA, hInstance);

// use pToolbar

delete pToolbar


Bitmap* LoadPNG(LPCTSTR pName, LPCTSTR pType, HMODULE hInstance)
{
  HGLOBAL		hBuffer;
  Bitmap*		pBitmap;

  // find this resource
  HRSRC hResource = ::FindResource(hInstance, pName, pType);
  if (!hResource)
  {
    return NULL;
  }

  // get the size
  DWORD dwImageSize = ::SizeofResource(hInstance, hResource);
  if (!dwImageSize)
  {
    return NULL;
  }

  // get data
  const void* pResourceData = ::LockResource(::LoadResource(hInstance, hResource));
  if (!pResourceData)
  {
    return NULL;
  }

  // allocate memory
  hBuffer  = ::GlobalAlloc(GMEM_MOVEABLE, dwImageSize);
  if (hBuffer)
  {
    // lock this memory
    void* pBuffer = ::GlobalLock(hBuffer);

    if (pBuffer)
    {
      // copy memory
      CopyMemory(pBuffer, pResourceData, dwImageSize);

      // stream in data
      IStream* pStream = NULL;
			
      if (::CreateStreamOnHGlobal(hBuffer, FALSE, &pStream) == S_OK)
      {
        pBitmap = Gdiplus::Bitmap::FromStream(pStream);
        pStream->Release();

        if (pBitmap)
        { 
          if (pBitmap->GetLastStatus() == Gdiplus::Ok)
          {
            // success
            ::GlobalUnlock(hBuffer);
            ::GlobalFree(hBuffer);
						
            return pBitmap;
          }

          delete pBitmap;
        }
      }

      ::GlobalUnlock(hBuffer);
    }

    ::GlobalFree(hBuffer);
  }

  return NULL;
}

Re: Same code in a single function

Joe Woodbury

6:29 29 Feb '08

Your version will fail on success with those files (particularly JPG) which require that the global buffer remain valid while the bitmap object is being used. Anyone who thinks he has a better idea of what's good for people than people do is a swine. - P.J. O'Rourke
Sign In·View Thread·PermaLink

Re: Same code in a single function

Sean O'Connor

7:22 29 Feb '08

Ahhh, I hadn't realised that! Personally I only need this code for loading PNG files though so I guess I'm OK?
Sign In·View Thread·PermaLink

Re: Same code in a single function

Joe Woodbury

10:28 29 Feb '08

Sean O'Connor wrote: so I guess I'm OK? I think so; it appears that PNG's decompress right away. Of course, the test is whether you have any problems. Anyone who thinks he has a better idea of what's good for people than people do is a swine. - P.J. O'Rourke
Sign In·View Thread·PermaLink

Thanks Joe!

Gary Wheeler

2:26 31 Jan '08

This article was just what I needed Smile

.

I've got a VS2003 project that has a lot of bitmap resources and uses normal GDI for drawing. The Powers That Be have decided all of these bitmaps (stolen from all the best web sources) look crappy, so they've got some yabbo's drawing new ones. Said yabbo's only produce PNG's (bunch of Mac sissies), and of course the images all include an alpha channel. My GDI drawing code could handle that, but I didn't have any way to load the PNG's as resources.

Your code does the trick, and I've added a slight refinement. Since VS2003 doesn't let you define PNG's as a normal BITMAP resource, I put the following in my .RC file:

IDB_BITMAP BITMAP "res\bitmap.bmp"
IDB_BITMAP PNG "res\bitmap.png"

If then use your approach to try and load a resource of type "PNG" with the ID IDB_BITMAP. If it works, all well and good. If it doesn't, I issue the normal ::LoadImage call. This way, all I need to do is update the .RC file with PNG resources as the artsy types get them done.

Since I do all of my image loading through a common routine, all I've had to do to make this work is modify the routine and begin updating .RC's, rather than all of the load calls. I can also programatically decide whether or not to use the PNG resources in one place. Very, very, Cool

.

Thanks again Rose

Software Zen: delete this;

Gotcha????

pwasser

18:14 19 Nov '07

In your code: If the snippet... if (m_pBitmap->GetLastStatus() == Gdiplus::Ok) return true; executes then... ::GlobalUnlock(m_hBuffer); } ::GlobalFree(m_hBuffer); does not. This leaves m_hBuffer locked and unfreed whch would reinforce the commonly stated warning about returning from within a function. Peter Wasser
Sign In·View Thread·PermaLink	2.00/5 (1 vote)

Re: Gotcha????

Joe Woodbury

7:31 31 Jan '08

I never got notified about this message. However, the answer is that the code is correct since the buffer needs to remain locked while the bitmap is being used. Anyone who thinks he has a better idea of what's good for people than people do is a swine. - P.J. O'Rourke
Sign In·View Thread·PermaLink	2.00/5 (1 vote)

Last Visit: 18:49 4 Jul '09 Last Update: 18:49 4 Jul '09

12 3 4 Next »

General News Question Answer Joke Rant Admin

PermaLink | Privacy | Terms of Use
Last Updated: 6 Sep 2004
Editor: Nishant Sivakumar