C / C++ / MFC

//Somewhere in code.
...
    CString *pStr = new CString();
    *pStr = "Set String Here!";
 
    //NOTE: Receiver of this message must delete pointer!!!
    pMyView->PostMessage(WM_MY_MSG, 0, (LPARAM)pStr);
...

LRESULT CMyView::OnHandleMyMsg(WPARAM wParam, LPARAM lParam)
{
    CString *pStr = (CString *)lParam;
    if(pStr)
    {
        //Do something with the string...
 
        //We must delete it when done!!!
        delete pStr;
    }
    return 0;
}

void CMyView::OnDestroy() 
{
    //Look for any WM_MY_MSG left in the queue. These have
    // pointers to allocated memory that must be freed or we will
    // have leaks!
    MSG msg;
    while(::PeekMessage(&msg, (HWND)NULL, WM_MY_MSG, WM_MY_MSG, PM_REMOVE))
    {
        CString *pStr = (CString *)msg.lParam;
        if(pStr)
            delete pStr;
    }
    CView::OnDestroy();
}

VOID Sleep(
  DWORD dwMilliseconds   // sleep time
);

...
//Show the logo.
CBitmapToDIB dib;
 
if(dib.Create(IDB_LOGO1))
{
    LPBITMAPINFOHEADER lpHdr;
    CSize sizeDisplay;
    CSize sizeLogo;
 
    lpHdr = dib.GetBitmapHeader();
    sizeLogo.cx = lpHdr->biWidth;
    sizeLogo.cy = lpHdr->biHeight;
 
    //Make logo twice as big.
    sizeDisplay.cx = sizeLogo.cx * 2;
    sizeDisplay.cy = sizeLogo.cy * 2;
 
    StretchDIBits(pDC->m_hDC, rcHeader.right - sizeDisplay.cx, rcHeader.top,
        sizeDisplay.cx, sizeDisplay.cy,
        0, 0, sizeLogo.cx, sizeLogo.cy,
        dib.GetBitmapBits(), dib.GetBitmapData(),
        DIB_RGB_COLORS, SRCCOPY);
}
...

// BitmapToDIB.h : interface of the CBitmapToDIB class
//
/////////////////////////////////////////////////////////////////////////////
 
#if !defined(_BITMAPTODIB_H__INCLUDED_)
#define _BITMAPTODIB_H__INCLUDED_
 
 
class CBitmapToDIB
{
public:
    CBitmapToDIB();
    ~CBitmapToDIB();
    BOOL Create(CBitmap *hBitmap, CDC *pDC, CPalette *pPal = NULL, int nBitsPerPixel = -1);
    BOOL Create(LPCSTR lpResourceString);
    BOOL Create(WORD nResourceID);
    void Destroy();
    const LPVOID GetBitmapBits();
    const LPBITMAPINFO GetBitmapData();
    const LPBITMAPINFOHEADER GetBitmapHeader();
 
    BOOL WriteDIBToFile(LPCTSTR lpszFileName, CProgressCtrl *pProgressCntrl = NULL);
    BOOL WriteDIBToFile(CFile *pFile, CProgressCtrl *pProgressCntrl = NULL);
 
private:
    void InitBitmapInfoHeader(LPBITMAPINFOHEADER pHdr, int nBitsPerPixel);
    static WORD PaletteSize(LPBITMAPINFOHEADER pHdr);
    static WORD DibNumColors(LPBITMAPINFOHEADER pHdr);
 
private:
    HANDLE m_hDIB;
    BITMAP m_Bitmap;
    LPBITMAPINFO m_lpbmInfo;
    LPBITMAPINFOHEADER m_lpbmInfoHdr;
    LPBYTE m_lpBits;
    DWORD m_dwDIBSize;
};
 
#endif //_BITMAPTODIB_H__INCLUDED_

// BitmapToDIB.cpp : implementation of the CBitmapToDIB class
//
 
#include "stdafx.h"
#include "BitmapToDIB.h"
 
// WIDTHBYTES takes # of bits in a scan line and rounds up to nearest
//  word.
 
#define WIDTHBYTES(bits)      (((bits) + 31) / 32 * 4)
 
CBitmapToDIB::CBitmapToDIB()
{
    m_hDIB = NULL;
    Destroy();
}
 
CBitmapToDIB::~CBitmapToDIB()
{
    Destroy();
}
 
void CBitmapToDIB::Destroy()
{
    if(m_hDIB)
        delete [] m_hDIB;
    m_hDIB = NULL;
    m_lpBits = NULL;
    m_lpbmInfo = NULL;
    m_lpbmInfoHdr = NULL;
    m_dwDIBSize = 0;
}
 
void CBitmapToDIB::InitBitmapInfoHeader(LPBITMAPINFOHEADER pHdr, int nBitsPerPixel)
{
    int nBPP;
 
    memset(pHdr, 0, sizeof(BITMAPINFOHEADER));
 
    pHdr->biSize = sizeof(BITMAPINFOHEADER);
    pHdr->biWidth = m_Bitmap.bmWidth;
    pHdr->biHeight = m_Bitmap.bmHeight;
    pHdr->biPlanes = 1;
 
    if ((nBitsPerPixel == 1) || (nBitsPerPixel == 4) ||
        (nBitsPerPixel == 8) || (nBitsPerPixel == 24))
    {
        nBPP = nBitsPerPixel;
    }
    else
    {
        nBPP = m_Bitmap.bmPlanes * m_Bitmap.bmBitsPixel; // color bits per pixel
    }
 
    if(nBPP <= 1)
        nBPP = 1;
    else
    if(nBPP <= 4)
        nBPP = 4;
    else
    if(nBPP <= 8)
        nBPP = 8;
    else
        nBPP = 24;
 
    pHdr->biBitCount = (unsigned short)nBPP;
    pHdr->biSizeImage = WIDTHBYTES(m_Bitmap.bmWidth * nBPP) *
        m_Bitmap.bmHeight;
}
 
const LPVOID CBitmapToDIB::GetBitmapBits()
{
    return LPVOID(m_lpBits);
}
 
const LPBITMAPINFO CBitmapToDIB::GetBitmapData()
{
    return m_lpbmInfo;
}
 
const LPBITMAPINFOHEADER CBitmapToDIB::GetBitmapHeader()
{
    return m_lpbmInfoHdr;
}
 
BOOL CBitmapToDIB::Create(CBitmap *hBitmap, CDC *pDC, CPalette *pPal, int nBitsPerPixel)
{
    CDC dc;
    BITMAPINFOHEADER tempHdr;
 
    //Make sure our pointer are ok.
    ASSERT(hBitmap);
    if(!hBitmap)
        return FALSE;
 
    //Get the BITMAP structure from the DDB.
    if(!hBitmap->GetBitmap(&m_Bitmap))
        return FALSE;
 
    //Call this incase this is getting called twice.    
    Destroy();
 
    //Create a header for the DIB   
    InitBitmapInfoHeader(&tempHdr, nBitsPerPixel);
 
    //Allocate memory for the DIB.  Then, set the BITMAPINFOHEADER
    // into this memory, and find out where the bitmap bits go.
    m_dwDIBSize = sizeof(BITMAPINFOHEADER) + PaletteSize(&tempHdr) + tempHdr.biSizeImage;
    m_hDIB = (HANDLE)new char[m_dwDIBSize];
    if(!m_hDIB)
        return FALSE;
 
    m_lpbmInfo = (LPBITMAPINFO)m_hDIB;
    m_lpbmInfoHdr = &m_lpbmInfo->bmiHeader;
    *m_lpbmInfoHdr = tempHdr;
    m_lpBits = (LPBYTE)m_hDIB + (WORD)m_lpbmInfoHdr->biSize + PaletteSize(m_lpbmInfoHdr);
 
    // Now, we need a DC to hold our bitmap.  If the app passed us
    // a palette, it should be selected into the DC.
    if(!dc.CreateCompatibleDC(pDC))
        return FALSE;
    if(pPal)
    {
        dc.SelectPalette(pPal, FALSE);
        dc.RealizePalette();
    }
 
    // We're finally ready to get the DIB.  Call the driver and let
    //  it party on our bitmap.  It will fill in the color table,
    //  and bitmap bits of our global memory block.
    if(!::GetDIBits(dc.m_hDC, HBITMAP(*hBitmap), 0, m_Bitmap.bmHeight, m_lpBits,
        m_lpbmInfo, DIB_RGB_COLORS))
    {
        return FALSE;
    }
 
    return TRUE;
}
 
BOOL CBitmapToDIB::Create(WORD nResourceID)
{
    return Create(MAKEINTRESOURCE(nResourceID));
}
 
BOOL CBitmapToDIB::Create(LPCSTR lpResourceString)
{
    HRSRC  hRsrc;
    HGLOBAL hTemp;
    LPSTR lpRes;
    HINSTANCE hInstance = AfxGetInstanceHandle();
 
    //Make sure our pointer are ok.
    ASSERT(hInstance && lpResourceString);
    if(!hInstance || !lpResourceString)
        return FALSE;
 
    hRsrc = FindResource(hInstance, lpResourceString, RT_BITMAP);
    if(hRsrc)
    {
        //Call this incase this is getting called twice.    
        Destroy();
 
        //Load the resource.
        hTemp = LoadResource(hInstance, hRsrc);
        m_dwDIBSize = SizeofResource(hInstance, hRsrc);
        lpRes = (LPSTR)LockResource(hTemp);
 
        //Allocate memory for the DIB.  Then, set the BITMAPINFOHEADER
        // into this memory, and find out where the bitmap bits go.
        m_hDIB = (HANDLE)new char[m_dwDIBSize];
        if(!m_hDIB)
            return FALSE;
        memcpy(m_hDIB, lpRes, m_dwDIBSize);
 
        //Free the resource.
        UnlockResource(hTemp);
        FreeResource(hTemp);
 
        m_lpbmInfo = (LPBITMAPINFO)m_hDIB;
        m_lpbmInfoHdr = &m_lpbmInfo->bmiHeader;
        m_lpBits = (LPBYTE)m_hDIB + (WORD)m_lpbmInfoHdr->biSize + PaletteSize(m_lpbmInfoHdr);
 
        return TRUE;
    }
    return FALSE;
}
 
WORD CBitmapToDIB::PaletteSize(LPBITMAPINFOHEADER pHdr)
{
    WORD NumColors;
 
    NumColors = DibNumColors(pHdr);
 
    if (pHdr->biSize == sizeof(BITMAPCOREHEADER))
        return (WORD)(NumColors * sizeof(RGBTRIPLE));
    else
        return (WORD)(NumColors * sizeof(RGBQUAD));
}
 
WORD CBitmapToDIB::DibNumColors(LPBITMAPINFOHEADER pHdr)
{
    int bits;
    LPBITMAPINFOHEADER  lpbi;
    LPBITMAPCOREHEADER  lpbc;
 
    lpbi = (LPBITMAPINFOHEADER)pHdr;
    lpbc = (LPBITMAPCOREHEADER)pHdr;
 
    /*  With the BITMAPINFO format headers, the size of the palette
     *  is in biClrUsed, whereas in the BITMAPCORE - style headers, it
     *  is dependent on the bits per pixel ( = 2 raised to the power of
     *  bits/pixel).
     */
    if(lpbi->biSize != sizeof(BITMAPCOREHEADER))
    {
        if(lpbi->biClrUsed != 0)
            return (WORD)lpbi->biClrUsed;
        bits = lpbi->biBitCount;
    }
    else
        bits = lpbc->bcBitCount;
 
    switch(bits)
    {
        case 1:
            return 2;
        case 4:
            return 16;
        case 8:
            return 256;
        default:
            /* A 24 bitcount DIB has no color table */
            return 0;
    }
}
 
BOOL CBitmapToDIB::WriteDIBToFile(LPCTSTR lpszFileName, CProgressCtrl *pProgressCntrl)
{
    CString s;
 
    //Make sure we have a DIB.
    if(!m_hDIB)
        return FALSE;
 
    try
    {
        CFileStatus rStatus;
 
        //See if the file exist.
        if(CFile::GetStatus(lpszFileName, rStatus))
        {
            s.Format("File \"%s\" already exits. Overwrite?", lpszFileName);
            if(AfxMessageBox(s, MB_OKCANCEL) == IDCANCEL)
                return FALSE;
        }
         
        CFile file(lpszFileName, CFile::modeCreate | CFile::modeWrite);
        return WriteDIBToFile(&file, pProgressCntrl);
    }
    catch(...)
    {
        s.Format("ERROR: Could not create BMP file \"%s\".", lpszFileName);
        AfxMessageBox(s);
    }
    return FALSE;
}
 
BOOL CBitmapToDIB::WriteDIBToFile(CFile *pFile, CProgressCtrl *pProgressCntrl)
{
    BITMAPFILEHEADER bfh;
    DWORD dwFileSize;
 
    //Make sure we have a DIB.
    ASSERT(m_hDIB && pFile);
    if(!m_hDIB || !pFile)
        return FALSE;
 
    //The size of the whole file.
    dwFileSize = sizeof(BITMAPFILEHEADER) + m_dwDIBSize;
 
    //Build the bitmap file header.
    bfh.bfType = 0x4d42; //'BM'
    bfh.bfSize = dwFileSize;
    bfh.bfReserved1 = 0;
    bfh.bfReserved2 = 0; 
    //Where does the data start.
    bfh.bfOffBits = (m_lpBits - (LPBYTE)m_hDIB) + sizeof(BITMAPFILEHEADER); 
       
    try
    {
        if(pProgressCntrl)
            pProgressCntrl->SetRange(0, 100);
 
        //Write the bitmap file header.
        pFile->Write(&bfh, sizeof(BITMAPFILEHEADER));
         
        if(pProgressCntrl)
            pProgressCntrl->SetPos(50);
 
        //Wrtie the DIB.
        pFile->Write(m_hDIB, m_dwDIBSize);
 
        if(pProgressCntrl)
            pProgressCntrl->SetPos(100);
 
        return TRUE;
    }
    catch(...)
    {
        CString s;
        s.Format("ERROR: Problem writing to BMP file \"%s\".", pFile->GetFilePath);
        AfxMessageBox(s);
    }
 
    return FALSE;
}

bool CDummyDlg::checkIP(char *ip)
{char* tmpIP = ip; // local copy of string pointer
 char* tmpNR = new char[4]; // holder for group between dots
 bool OK = true;	
 memset(tmpNR,0,4);

 int len = 0, groups = 0; // len = length of chars between dots, groups = number of groups in ip 	

 do
 {if (*tmpIP >= '0' && *tmpIP <= '9') // 1) Building number
	if(len < 4)
		tmpNR[len++] = *tmpIP;
	else
		OK = false; // number consists of more than 3 digits

  else if('.' == *tmpIP || 0 == *tmpIP)  // 2) Verify number
  {if (atoi(tmpNR) > 255)
	   OK=false; // to large number between points
   memset(tmpNR,0,4);	
   len = 0;
   groups++;
  }
  else
	  OK = false; // other character encountered
 }
 while(*tmpIP++ && OK);
 delete tmpNR;
 return OK && (4 == groups); //four groups between dots 
}

Neil Gaiman - Cold Colours