The simple implemetion is to handle the EN_UPDATE notification message. The EN_UPDATE message is useful to handle as it caters for both normal entry and clipboard paste. You can do that in the Dialog or subclass the CEdit class.

Here is an example of a derived CEdit class.

class CNumEdit : public CEdit
{
//….
afx_msg void OnUpdate();
//}}AFX_MSG

DECLARE_MESSAGE_MAP()
private:
CString m_strLastGood;
};

In the cpp file:

BEGIN_MESSAGE_MAP(CNumEdit, CEdit)
//{{AFX_MSG_MAP(CNumEdit)
ON_CONTROL_REFLECT(EN_UPDATE, OnUpdate)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CNumEdit::OnUpdate()
{
CString str;
GetWindowText( str );
bool bProblem = false;
for ( int indx = 0; indx < str.GetLength(); indx++ )
{
if (( str[indx] < ‘0′ ) || ( str[indx] > ‘9′) )
{
bProblem = true;
break;
}
}
if ( bProblem )
{
int start, end;
/* Find the current caret position */
GetSel( start, end );
/* Restore the last good text that was entered */
SetWindowText( m_strLastGood );
/* Restore the caret */
SetSel( start-1, end-1, true );
/* Let the user know */
MessageBeep( MB_OK );
}
else
{
/* Store the last good entry string in a member variable of the Hex edit class*/
m_strLastGood = str;
}
}

At last, you may find one of these meets your needs:

• http://www.codeproject.com/editctrl/maskededit.asp
• http://www.codeproject.com/editctrl/validatingedit.asp

There are two main steps:

• Load the bitmap from the file to a memory DC.
• Paint the content of the memory DC to the one which display the bitmap.

In MFC, there is no API to load a bitmap directly from a file, but you can use a Win32 API: LoadImage.
Here is the delaration of LoadImage.

HANDLE LoadImage(
HINSTANCE hinst, //handle to instance, if load from file, it should be NULL
LPCTSTR lpszName, //image resource name or the image file path
UINT uType, //image type
//1. IMAGE_BITMAP
//2. IMAGE_CURSOR
//3. IMAGE_ICON
int cxDesired, //desired width
int cyDesired, //desired height
UINT fuLoad //load options
);

After this,  the following steps are similar with loading a bitmap from resource. Here is a short example.

CClientDC dc(this);
CDC *mdc=new CDC;
mdc->CreateCompatibleDC(&dc);

CBitmap bitmap;
//CBitmap is devived from CGdiObject
//It has a handle:m_hObject, which can obtained with LoadImage
bitmap.m_hObject=(HBITMAP)::LoadImage(
NULL,
“b1.bmp”,
IMAGE_BITMAP,
500,
400,
LR_LOADFROMFILE);

mdc->SelectObject(bitmap);
CRect rect;
GetClientRect(&rect);
//BitBlt()
dc.BitBlt(0,0,rect.right,rect.bottom,mdc,0,0,SRCCOPY);

//release mdc
delete mdc;

The following article from CodeProject provided a good solution.

• Changing Row Height in an owner drawn Control

And there is a similar article on CodeGuru.

• Changing row height in owner drawn control

The inspiration to write this code was to have an easy-to-use parser for functions given as string. You have a string like

and you want to compute some values, maybe for displaying the graph of the function. You can write code like this:

Most people have heard of the standard auto_ptr smart pointer facility, but not everyone uses it daily. That’s a shame, because it turns out that auto_ptr neatly solves common C++ design and coding problems, and using it well can lead to more robust code. This article shows how to use auto_ptr correctly to make your code safer–and how to avoid the dangerous but common abuses of auto_ptr that create intermittent and hard-to-diagnose bugs.

Why Call It an "Auto" Pointer?

auto_ptr is just one of a wide array of possible smart pointers. Many commercial libraries provide more sophisticated kinds of smart pointers that can do wild and wonderful things, from managing reference counts to providing advanced proxy services. Think of the Standard C++ auto_ptr as the Ford Escort of smart pointers: A simple general-purpose smart pointer that doesn’t have all the gizmos and luxuries of special-purpose or high-performance smart pointers, but that does many common things well and is perfectly suitable for regular daily use.

What auto_ptr does is own a dynamically allocated object and perform automatic cleanup when the object is no longer needed. Here’s a simple example of code that’s unsafe without auto_ptr:

Visit the author’s website for more details.

BOOL GetBinaryFromVariant(COleVariant & ovData, BYTE ** ppBuf, unsigned long * pcBufLen)
{
BOOL fRetVal = FALSE;
//Binary data is stored in the variant as an array of unsigned char
if(ovData.vt == (VT_ARRAY|VT_UI1)) // (OLE SAFEARRAY)
{
//Retrieve size of array
*pcBufLen = ovData.parray->rgsabound[0].cElements;
*ppBuf = new BYTE[*pcBufLen]; //Allocate a buffer to store the data
if(*ppBuf != NULL)
{
void * pArrayData;
//Obtain safe pointer to the array
SafeArrayAccessData(ovData.parray,&pArrayData);
//Copy the bitmap into our buffer
memcpy(*ppBuf, pArrayData, *pcBufLen); //Unlock the variant data
SafeArrayUnaccessData(ovData.parray);
fRetVal = TRUE;
}
}
return fRetVal;
}



BOOL PutBinaryIntoVariant(COleVariant * ovData, BYTE * pBuf,unsigned long cBufLen)
{
BOOL fRetVal = FALSE;
VARIANT var;
VariantInit(&var); //Initialize our variant
//Set the type to an array of unsigned chars (OLE SAFEARRAY)
var.vt = VT_ARRAY | VT_UI1;
//Set up the bounds structure
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].cElements = cBufLen;
rgsabound[0].lLbound = 0;
//Create an OLE SAFEARRAY
var.parray = SafeArrayCreate(VT_UI1,1,rgsabound);
if(var.parray != NULL)
{
void * pArrayData = NULL;
//Get a safe pointer to the array
SafeArrayAccessData(var.parray,&pArrayData);
//Copy data to it
memcpy(pArrayData, pBuf, cBufLen);
//Unlock the variant data
SafeArrayUnaccessData(var.parray);
*ovData = var;
// Create a COleVariant based on our variant
VariantClear(&var);
fRetVal = TRUE;
}
return fRetVal;
}