Re: Preventing memory and resource leaks with GDI Objects ???

I will study your concrete example an attempt to implement
it. My great difficulty is with the tedious little
syntactical details, thus Joe's abstract examples don't work
for me. I can't simply let my GDI object get destroyed
because the objects must retain their state in case
subsequent operations must be performed on them.

I open a bitmap and it may be written to, or saved or
another bitmap may be opened. If another bitmap is opened, I
must create another CBitmap object of this new size.
Currently I only have the single CBitmap object as an object
member variable.

I am guessing that I could implement your design by making
pairs of GDI object member and toggling between them upon
every re-use. For example CBitmap cbitmap[2]; and then
toggle its subscript between one and zero.

I looked at your design again and there were too many things
that I did not understand.
Here is my currently working code. It does not work if I
remove the:
  this->cfont.DeleteObject();
It does work with repeated invocations, thus must be
deleting the selected CFont object.

// Displays a Font Selection DialogBox with
// default "Times New Roman", Bold, Italic, 8 Point
//
inline void ScreenCaptureType::SelectFont() {
  this->cfont.DeleteObject();

  int PointSize = 8;
  int FontHeight = -MulDiv(PointSize,
GetDeviceCaps(MemoryDC.m_hDC, LOGPIXELSY), 72);
  LOGFONT LogFont = {FontHeight, 0, 0, 0, FW_BOLD, 1, 0, 0,
ANSI_CHARSET, OUT_DEFAULT_PRECIS,
  CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH |
FF_DONTCARE, L"Times New Roman"};
  CFontDialog dlg(&LogFont);
  if (dlg.DoModal() == IDOK)
    cfont.CreateFontIndirect(&LogFont);
  this->MemoryDC.SelectObject(&cfont);
}

"Goran" <goran.pusic@gmail.com> wrote in message
news:0a7d9ef0-f706-4832-a12e-e265dc6272de@q16g2000yqq.googlegroups.com...
On Mar 10, 6:56 pm, "Peter Olcott" <NoS...@OCR4Screen.com>
wrote:


Well, certainly nothing stops you from doing that, e.g.

(Warning: works with head-compiler and in head-debugger,
YMMV)

typedef shared_ptr<CGdiObject> SPGdiObject;
class COhSoGreat
{
typedef KeyType int;
std::map<KeyType, SPGdiObject> m_gdiObjects;
  struct CTempGdiObjectSelection : noncopyable
  {
    CTempGdiObjectSelection(CDC& dc, const CGdiObject& o) :
m_dc(dc),
m_new(o) { m_pOld = dc.SelectObject(&o); }
    ~CTempGdiObjectSelection() {
m_dc.SelectObject(m_pOld); }
   CDC& m_dc;
   CGdiObject* m_pOld;
   CGdiObject& m_new
  }

  void SoGreatDrawingCode(CDC& dc) const /*an important
const*/
  {
    { CTempGdiObjectSelection SelectSomething(dc,
*m_gdiObject[someObjectKey]);
      // Draw, baby, draw.
      { CTempGdiObjectSelection SelectSomething(dc,
*m_gdiObject[someObjectKey]);
        // Draw, baby, draw.
      }
    }
  }

  void OtherFunctionsThatMustFillYourGdiObjectContainer()
  { // e.g.
    SPGdiObject P(new CFont);
    if (!P->CreateXYZ(params))
      AfxThrowResourceException();
    m_gdiObjects[some_key] = P;
  }
};

Use an approach like this and it will be rather hard to leak
any
resources.

You also said:

"The main thing that I want to do is to manually free any
memory or resources that the CBitmap object is using. I
don't know what resources it is using, and I don't know how
to free them."

Just let CBitmap C++ object be destroyed. As Joe said, don't
try to
get smart with leaving it selected in a DC while destroyed.
That's why
I proposed CTempGdiObjectSelection up here. If you can make
your gdi
object container constant while drawing (note the "const"
qualifier on
"SoGreatDrawingCode"), you're practically locked out of a
resource
leak (bar limitless ingenuity in shooting oneself in the
foot :-) ).

You say that you tried destroying gdi object while selected
and that
this works, but did you verify this with some GDI handle
monitor
program? There are some on the internet. Try this first.


Listening to Joe gets you far :-).

Goran.