ipaddr.cpp

#pragma title("IP Address Custom Control Implementation")

// Created by Joseph A. Dziedzic, September 1997
// Revised April 1998
// Thanks to Dan Anderson, Kenny Goers, Kevin Lussier, and Doug Miller for their suggestions
// and code enhancements.
// Mail comments to dziedzic@ma.ultranet.com


#include "stdafx.h"
#include "IPAddr.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// Style bits for the individual edit controls
const int WS_EDIT = WS_CHILD | WS_VISIBLE | ES_CENTER | ES_MULTILINE;
const TCHAR szDialogClass[] = _T("#32770");                     // Special window class for dialogs

BOOL CIPAddrCtl::m_bRegistered = Register();            // Register the control during class initialization

// CIPAddrCtl

IMPLEMENT_DYNCREATE(CIPAddrCtl, CWnd)

CIPAddrCtl::CIPAddrCtl()
{
        m_bEnabled = TRUE;                                                              // Window enabled flag (TRUE by default)
        m_bReadOnly = FALSE;                                                    // Read only flag (FALSE by default)
        m_bNoValidate = FALSE;                                                  // Don't do immediate field validation on input
}

CIPAddrCtl::~CIPAddrCtl()
{
}


BEGIN_MESSAGE_MAP(CIPAddrCtl, CWnd)
        //{{AFX_MSG_MAP(CIPAddrCtl)
        ON_WM_CREATE()
        ON_WM_NCDESTROY()
        ON_WM_SIZE()
        ON_WM_SETFOCUS()
        ON_WM_PAINT()
        ON_WM_ENABLE()
        ON_WM_ERASEBKGND()
        ON_MESSAGE(WM_SETFONT, OnSetFont)
        ON_MESSAGE(IPAM_GETADDRESS, OnGetAddress)
        ON_MESSAGE(IPAM_SETADDRESS, OnSetAddress)
        ON_MESSAGE(IPAM_SETREADONLY, OnSetReadOnly)
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()


// CIPAddrCtl message handlers

BOOL CIPAddrCtl::Register()
{
        // Register the window class of the control
        WNDCLASS        wc;
        wc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;    // Usual style bits
        wc.lpfnWndProc = IPAddrWndProc;                                 // Message processing code
        wc.cbClsExtra = 0;                                                              // No extra bytes needed
        wc.cbWndExtra = 0;
        wc.hInstance = NULL;                                                    // No instance handle
        wc.hIcon = NULL;                                                                // No icon
        wc.hCursor = ::LoadCursor(NULL, IDC_IBEAM);             // Use I-beam cursor (like edit control)
        wc.hbrBackground = (HBRUSH) (COLOR_WINDOW+1);   // Use default window color (overriden in OnEraseBkgnd)
        wc.lpszMenuName = NULL;                                                 // No menus
        wc.lpszClassName = _T("IPAddr");                                // Class name
        if (!::RegisterClass(&wc))                                              // If registration failed, subsequent dialogs will fail
        {
                ASSERT(FALSE);
                return FALSE;
        }
        else
                return TRUE;
}

BOOL CIPAddrCtl::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, DWORD dwExStyle/*=0*/)
{
        // Create a window class that has the properties we want
        CString szWndClass = AfxRegisterWndClass(CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW,
                ::LoadCursor(NULL, IDC_IBEAM), (HBRUSH) COLOR_WINDOW+1);

        // Create using the extended window style
#if _MSC_VER >= 1100
        // Original VC 5.0 stuff
        return CWnd::CreateEx(dwExStyle, szWndClass, NULL, dwStyle, rect, pParentWnd, nID);
#else
        // Back ported to VC 4.2
        return CWnd::CreateEx(dwExStyle, szWndClass, NULL, dwStyle,
                rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top,
                pParentWnd->GetSafeHwnd(), (HMENU) nID);
#endif
}

LRESULT CALLBACK IPAddrWndProc(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
        switch (uiMsg)                                                                  // Dispatch on message type
        {
        case WM_NCCREATE:                                                               // On WM_NCCREATE we create a C++ object and attach it to the control
                {
                        CIPAddrCtl* pCtl = new CIPAddrCtl;              // Create an instance of the class
                        ASSERT(pCtl);                                                   // Better not fail!
                        BOOL b = pCtl->SubclassWindow(hWnd);    // Attach the window handle to the new object
                        ASSERT(b);                                                              // Better not fail!
                        return b;                                                               // Return result to continue/abort window creation
                        break;
                }
        default:                                                                                // All other messages go through default window processor
                return ::DefWindowProc(hWnd, uiMsg, wParam, lParam);
        }
}

int CIPAddrCtl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
        if (CWnd::OnCreate(lpCreateStruct) == -1)       
                return -1;

        // Save the "no immediate validation on input" style setting
        m_bNoValidate = (lpCreateStruct->style & IPAS_NOVALIDATE);

        // Set the styles for the parent control
        ModifyStyleEx(0, WS_EX_CLIENTEDGE | WS_EX_NOPARENTNOTIFY);

        // Create the four edit controls used to obtain the four parts of the IP address (size
        // of controls gets set during OnSize)
        for (int ii = 0; ii < 4; ii++)
        {
                m_Addr[ii].Create(WS_EDIT, CRect(0,0,0,0), this, IDC_ADDR1 + ii);
                m_Addr[ii].LimitText(3);
                m_Addr[ii].SetParent(this);
        }
        
        return 0;
}

void CIPAddrCtl::OnNcDestroy() 
{
        CWnd::OnNcDestroy();
        
        // Make sure the window was destroyed
        ASSERT(NULL == m_hWnd);

        // Destroy this object since it won't be destroyed otherwise
        delete this;
}

void CIPAddrCtl::OnSize(UINT nType, int cx, int cy) 
{
        CWnd::OnSize(nType, cx, cy);

        // Get the width of a "." drawn in the control
        CDC*    pDC = GetDC();
        CSize   szDot = pDC->GetTextExtent(_T("."), 1);
        int nDotWidth = szDot.cx;
        ReleaseDC(pDC); 

        // Based on the size of the parent window, compute the width & height of the edit
        // controls.  Leave room for the three "." which will be drawn on the parent window
        // to separate the four parts of the IP address.
        CRect   rcClient;
        GetClientRect(&rcClient);
        int nEditWidth = (rcClient.Width() - (3 * nDotWidth)) / 4;
        int nEditHeight = rcClient.Height();
        int cyEdge = ::GetSystemMetrics(SM_CYEDGE);

        // Compute rectangles for the edit controls, then move the controls into place
        CRect rect = CRect(0, cyEdge, nEditWidth, nEditHeight);
        for (int ii = 0; ii < 4; ii++)
        {
                m_rcAddr[ii] = rect;
                m_Addr[ii].MoveWindow(rect);
                rect.OffsetRect(nEditWidth + nDotWidth, 0);
        }

        rect = CRect(nEditWidth, 0, nEditWidth + nDotWidth, nEditHeight);
        for (ii = 0; ii < 3; ii++)
        {
                m_rcDot[ii] = rect;
                rect.OffsetRect(nEditWidth + nDotWidth, 0);
        }
}

void CIPAddrCtl::OnSetFocus(CWnd* pOldWnd) 
{
        CWnd::OnSetFocus(pOldWnd);
        
        m_Addr[0].SetFocus();                                                   // Set focus to first edit control
        m_Addr[0].SetSel(0, -1);                                                // Select entire contents
}

// Protected function called by the edit control (friend class) when it receives a
// character which should be processed by the parent
void CIPAddrCtl::OnChildChar(UINT nChar, UINT nRepCnt, UINT nFlags, CIPAddrEdit& child)
{
        switch (nChar)
        {
        case '.':                                                                               // Dot means advance to next edit control (if in first 3)
        case VK_RIGHT:                                                                  // Ditto for right arrow at end of text
        case ' ':                                                                               // Ditto for space
                {
                UINT nIDC = child.GetDlgCtrlID();                       // Get control ID of the edit control
                if (nIDC < IDC_ADDR4)                                           // Move focus to appropriate edit control and select entire contents
                {
                        m_Addr[nIDC - IDC_ADDR1 + 1].SetFocus();
                        if (VK_RIGHT != nChar)                                  // Re-select text unless arrow key entered
                                m_Addr[nIDC - IDC_ADDR1 + 1].SetSel(0, -1);
                }               
                break;
                }

        case VK_LEFT:                                                                   // Left arrow means move to previous edit control (if in last 3)
                {
                UINT nIDC = child.GetDlgCtrlID();                       // Get control ID of the edit control
                if (nIDC > IDC_ADDR1)                                           // Move focus to appropriate edit control
                        m_Addr[nIDC - IDC_ADDR1 - 1].SetFocus();
                break;
                }

        case VK_TAB:                                                                    // Tab moves between controls in the dialog
                {
                CWnd*   pWnd;
                SHORT nShift = ::GetKeyState(VK_SHIFT);         // Get state of shift key
                if (nShift < 0)
                        pWnd = GetParent()->GetNextDlgTabItem(this, TRUE);
                else
                        pWnd = GetParent()->GetNextDlgTabItem(this, FALSE);
                if (NULL != pWnd)                                                       // If there's a control, set focus to it
                        pWnd->SetFocus();
                break;
                }

        case VK_RETURN:                                                                 // Return implies default pushbutton press
                {
                DWORD dw = ((CDialog*) GetParent())->GetDefID();        // Get ID of default pushbutton
                if (DC_HASDEFID == HIWORD(dw))                          // If there is a default pushbutton, simulate pressing it
                {
                        CWnd* pWnd = GetParent()->GetDlgItem(LOWORD(dw));       // Get the control
                        WPARAM wp = MAKEWPARAM(LOWORD(dw), BN_CLICKED);         // Build wParam for WM_COMMAND
                        GetParent()->SendMessage(WM_COMMAND, wp, (LPARAM) pWnd->m_hWnd);        // Fake like button was pressed
                }
                }
                break;

        case '-':                                                                               // "Field full" indication
                // Validate the contents for proper values (unless suppressed)
                if (!m_bNoValidate)                                                     // If not suppressing immediate validation
                {
                        CString         szText;

                        child.GetWindowText(szText);                    // Get text from edit control
                        int n = _ttoi(szText);                                  // Get numeric value from edit control
                        if (n < 0 || n > 255)                                   // If out of range, notify parent
                        {
                                szText.Format(_T("%d is not a valid entry.  Please specify a value between 0 and 255 for this field."), n);
                                MessageBox(szText, _T("Error"), MB_OK | MB_ICONEXCLAMATION);
                                child.SetFocus();                                       // Set focus to offending field
                                child.SetSel(0, -1);                            // Select all text
                                return;
                        }
                }

                // Advance to next field
                OnChildChar('.', 0, nFlags, child);
                break;

        default:
                TRACE(_T("Unexpected call to CIPAddrCtl::OnChildChar!\n"));
        }
}

void CIPAddrCtl::OnPaint() 
{
        CPaintDC dc(this); // device context for painting

        // Save mode and set to transparent (so background remains)
        int nOldMode = dc.SetBkMode(TRANSPARENT);

        // If disabled, set text color to COLOR_GRAYTEXT, else use COLOR_WINDOWTEXT
        COLORREF crText;
        if (m_bEnabled)
                crText = ::GetSysColor(COLOR_WINDOWTEXT);
        else
                crText = ::GetSysColor(COLOR_GRAYTEXT);
        COLORREF crOldText = dc.SetTextColor(crText);

        // Draw the three "." which separate the four edit controls
        for (int ii = 0; ii < 3; ii++)
                dc.DrawText(_T("."), 1, m_rcDot[ii], DT_CENTER | DT_SINGLELINE | DT_BOTTOM);

        // Restore old mode and color
        dc.SetBkMode(nOldMode);
        dc.SetTextColor(crOldText);

        // Do not call CWnd::OnPaint() for painting messages
}

BOOL CIPAddrCtl::OnEraseBkgnd(CDC* pDC) 
{
        CRect   rcClient;
        GetClientRect(&rcClient);

        if (m_bEnabled && !m_bReadOnly)
                ::FillRect(pDC->m_hDC, rcClient, (HBRUSH) (COLOR_WINDOW+1));
        else
                ::FillRect(pDC->m_hDC, rcClient, (HBRUSH) (COLOR_BTNFACE+1));

        return TRUE;
}

void CIPAddrCtl::OnEnable(BOOL bEnable) 
{
        CWnd::OnEnable(bEnable);
        
        // Nothing to do unless the window state has changed
        if (bEnable != m_bEnabled)
        {
                // Save new state
                m_bEnabled = bEnable;

                // Adjust child controls appropriately
                for (int ii = 0; ii < 4; ii++)
                        m_Addr[ii].EnableWindow(bEnable);
        }

        Invalidate();
}

LONG CIPAddrCtl::OnSetFont(UINT wParam, LONG lParam)
{
        // Note: font passed on to children, but we don't
        // use it, the system font is much nicer for printing
        // the dots, since they show up much better

        for (int ii = 0; ii < 4; ii++)
                m_Addr[ii].SendMessage(WM_SETFONT, wParam, lParam);

        return 0;
}

LONG CIPAddrCtl::OnGetAddress(UINT wParam, LONG lParam)
{
        BOOL bStatus;
        int     i, nAddr[4], nInError = 0;

        BOOL bPrintErrors = (BOOL) wParam;                              // Cast wParam as a flag
        IPA_ADDR* lpIPAddr = (IPA_ADDR*) lParam;                // Cast lParam as an IPA_ADDR structure
        if (NULL == lpIPAddr)                                                   // If it's a bad pointer, return an error
                return FALSE;
        memset(lpIPAddr, 0, sizeof(IPA_ADDR));                  // Zero out the returned data

        // Parse the fields and return an error indication if something bad was detected
        for (i = 0; i < 4; i++)
        {
                bStatus = ParseAddressPart(m_Addr[i], nAddr[i]);
                if (!bStatus)                                                           // If it failed to parse, quit now
                {
                        nInError = i + 1;                                               // Remember which address part was in error
                        break;                                                                  // Break out of for loop
                }
        }
        if (!bStatus)                                                                   // Error detected during parse?
        {
                lpIPAddr->nInError = nInError;                          // Show where it occurred
                if (bPrintErrors)                                                       // If they want us to print error messages
                {
                        CString szText;
                        if (nAddr[i] < 0)
                                szText = _T("Missing value in IP address");
                        else
                                szText.Format(_T("%d is not a valid entry.  Please specify a value between 0 and 255 for this field."), nAddr[i]);
                        MessageBox(szText, _T("Error"), MB_OK | MB_ICONEXCLAMATION);
                }
                m_Addr[i].SetFocus();                                           // Set focus to offending byte
                m_Addr[i].SetSel(0, -1);                                        // Select entire contents
                return FALSE;                                                           // Return an error
        }

        lpIPAddr->nAddr1 = nAddr[0];                                    // Return the pieces to the caller
        lpIPAddr->nAddr2 = nAddr[1];
        lpIPAddr->nAddr3 = nAddr[2];
        lpIPAddr->nAddr4 = nAddr[3];
        lpIPAddr->nInError = 0;                                                 // No error to report
        return TRUE;                                                                    // Return success
}

LONG CIPAddrCtl::OnSetAddress(UINT wParam, LONG lParam)
{
        CString         szText;

        IPA_ADDR* lpIPAddr = (IPA_ADDR*) lParam;                // Cast lParam as an IPA_ADDR structure

        // Format their data and load the edit controls
        szText.Format(_T("%u"), lpIPAddr->nAddr1);
        m_Addr[0].SetWindowText(szText);
        szText.Format(_T("%u"), lpIPAddr->nAddr2);
        m_Addr[1].SetWindowText(szText);
        szText.Format(_T("%u"), lpIPAddr->nAddr3);
        m_Addr[2].SetWindowText(szText);
        szText.Format(_T("%u"), lpIPAddr->nAddr4);
        m_Addr[3].SetWindowText(szText);
        return TRUE;
}

LONG CIPAddrCtl::OnSetReadOnly(UINT wParam, LONG lParam)
{
        m_bReadOnly = (BOOL) wParam;

        for (int ii = 0; ii < 4; ii++)
                m_Addr[ii].SetReadOnly(m_bReadOnly);

        Invalidate();
        return TRUE;
}

BOOL CIPAddrCtl::ParseAddressPart(CEdit& edit, int& n)
{
        CString         szText;

        edit.GetWindowText(szText);                                             // Get text from edit control
        if (szText.IsEmpty())                                                   // Empty text is an error
        {
                n = -1;                                                                         // Return bogus value
                return FALSE;                                                           // Return parse failure to caller
        }

        n = _ttoi(szText);                                                              // Grab a decimal value from edit text
        if (n < 0 || n > 255)                                                   // If it is out of range, return an error
                return FALSE;

        return TRUE;                                                                    // Looks acceptable, return success
}

CIPAddrEdit* CIPAddrCtl::GetEditControl(int nIndex)
{
        if (nIndex < 1 || nIndex > 4)
                return NULL;
        return &m_Addr[nIndex - 1];
}


// CIPAddrEdit

CIPAddrEdit::CIPAddrEdit()
{
}

CIPAddrEdit::~CIPAddrEdit()
{
}

void CIPAddrEdit::SetParent(CIPAddrCtl* pParent)
{
        m_pParent = pParent;                                                    // Save pointer to parent control
}


BEGIN_MESSAGE_MAP(CIPAddrEdit, CEdit)
        //{{AFX_MSG_MAP(CIPAddrEdit)
        ON_WM_CHAR()
        ON_WM_KEYDOWN()
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()

// CIPAddrEdit message handlers

void CIPAddrEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
        // Logic for this function:
        // Tab and dot are forwarded to the parent.  Tab (or shift-tab) operate
        // just like expected (focus moves to next control after the parent).
        // Dot or space causes the parent to set focus to the next child edit (if
        // focus is currently set to one of the first three edit controls).
        // Numerics (0..9) and control characters are forwarded to the standard
        // CEdit OnChar method; all other characters are dropped.
        if (VK_TAB == nChar ||
                '.' == nChar ||
                ' ' == nChar ||
                VK_RETURN == nChar)
                m_pParent->OnChildChar(nChar, nRepCnt, nFlags, *this);
        else if (('0' <= nChar && '9'>= nChar) || iscntrl(nChar))
        {
                CEdit::OnChar(nChar, nRepCnt, nFlags);

                // Automatically advance to next child control if 3 characters were entered;
                // use "-" to indicate field was full to OnChildChar
                if (3 == GetWindowTextLength())
                        m_pParent->OnChildChar('-', 0, nFlags, *this);
        }
        else
                ::MessageBeep(0xFFFFFFFF);
}

void CIPAddrEdit::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
        // Handle the left and right arrow keys.  If the left arrow key is pressed
        // with the caret at the left of the input text, shift focus to the previous
        // control (if in edit controls 2-4).  Likewise for the right arrow key.
        // This is done by calling the parent's OnChildChar method.
        // If not left or right arrow, or not at beginning or end, call default
        // OnKeyDown processor so key down gets passed to edit control.
        if (VK_LEFT == nChar || VK_RIGHT == nChar)
        {
                CPoint ptCaret = GetCaretPos();
                int nCharPos = LOWORD(CharFromPos(ptCaret));
                if ((VK_LEFT == nChar && nCharPos == 0) ||
                        (VK_RIGHT == nChar && nCharPos == GetWindowTextLength()))
                        m_pParent->OnChildChar(nChar, nRepCnt, nFlags, *this);
        }
        else if (VK_ESCAPE == nChar)
        {
                // Must handle VK_ESCAPE specially.
                // In a normal dialog, VK_ESCAPE gets handled by the dialog box window process,
                // and the edit control never sees the character.  When the edit control lives
                // on a property page, this doesn't happen.  If VK_ESCAPE is not handled here
                // then when the escape key is pressed the entire control disappears from the
                // dialog!  If the parent of the control is a dialog, and the dialog's parent
                // is also a dialog, that's a sign that the control is on a property page.
                TCHAR   cClass1[12];
                TCHAR   cClass2[12];

                // Clear out window class name arrays
                memset(cClass1, 0, sizeof(cClass1));
                memset(cClass2, 0, sizeof(cClass2));

                // Get parent and parent's parent window pointers
                CWnd* pDialog = m_pParent->GetParent();         // Get parent of the IP address edit control
                CWnd* pDialogParent = pDialog->GetParent();     // Get its parent

                // Get class names of the windows that own the IP address edit control and its parent
                if (NULL != pDialog)
                        ::GetClassName(pDialog->m_hWnd, cClass1, sizeof(cClass1)/sizeof(TCHAR));
                if (NULL != pDialogParent)
                        ::GetClassName(pDialogParent->m_hWnd, cClass2, sizeof(cClass2)/sizeof(TCHAR));

                // If parent is a dialog, and parent's parent is a dialog, simulate Cancel button press
                if (0 == _tcscmp(cClass1, szDialogClass) && 0 == _tcscmp(cClass2, szDialogClass))
                {
                        CWnd* pCancel = pDialogParent->GetDlgItem(IDCANCEL);    // Get the Cancel button
                        pDialogParent->SendMessage(WM_COMMAND,
                                MAKEWPARAM(IDCANCEL, BN_CLICKED),
                                (LPARAM) (NULL != pCancel->m_hWnd ? pCancel->m_hWnd : NULL));
                        return;
                }
        }
        CEdit::OnKeyDown(nChar, nRepCnt, nFlags);
}

// DDX routines

void DDX_IPAddr(CDataExchange* pDX, int nIDC, unsigned char* nAddr)
{
        IPA_ADDR x;

        HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
        ASSERT(hWndCtrl);
        CIPAddrCtl* pIPAddrCtl = (CIPAddrCtl*) CWnd::FromHandle(hWndCtrl);
        ASSERT(pIPAddrCtl);

        if (!pDX->m_bSaveAndValidate)
        {
                // Load IP address control with current data
                x.nAddr1 = nAddr[0];                                            // Copy address bytes over
                x.nAddr2 = nAddr[1];
                x.nAddr3 = nAddr[2];
                x.nAddr4 = nAddr[3];
                pIPAddrCtl->SetAddress(&x);
        }
        else
        {
                // Save contents of IP address control
                BOOL bStatus = pIPAddrCtl->GetAddress(TRUE, &x);
                if (!bStatus)
                {
                        // x.nInError contains the 1-based index of the address field that was in error
                        pDX->m_hWndLastControl = pIPAddrCtl->GetEditControl(x.nInError)->m_hWnd;        // Set HWND of control to set focus on
                        pDX->m_bEditLastControl = TRUE;                 // It's an edit control (so Fail selects the text)
                        pDX->Fail();                                                    // Fail DDX
                }
                nAddr[0] = x.nAddr1;
                nAddr[1] = x.nAddr2;
                nAddr[2] = x.nAddr3;
                nAddr[3] = x.nAddr4;
        }
}

void DDX_IPAddr(CDataExchange* pDX, int nIDC, CString& szAddr)
{
        IPA_ADDR x;

        HWND hWndCtrl = pDX->PrepareCtrl(nIDC);
        ASSERT(hWndCtrl);
        CIPAddrCtl* pIPAddrCtl = (CIPAddrCtl*) CWnd::FromHandle(hWndCtrl);
        ASSERT(pIPAddrCtl);

        if (!pDX->m_bSaveAndValidate)
        {
        // Convert string to numbers
        unsigned char nAddr[4];
        memset(nAddr, 0, 4);

        // Get numbers
        for (int ii = 0; ii < 4; ii++)
        {
            if (ii < 3)
            {
                int nIndex = szAddr.Find(_T('.'));
                if (-1 != nIndex)
                {
                    nAddr[ii] = (unsigned char) _ttoi(szAddr.Left(nIndex));
                    szAddr = szAddr.Mid(nIndex + 1);
                }
            }
            else
                nAddr[ii] = (unsigned char) _ttoi(szAddr);
        }

                // Load IP address control with current data
                x.nAddr1 = nAddr[0];                                            // Copy address bytes over
                x.nAddr2 = nAddr[1];
                x.nAddr3 = nAddr[2];
                x.nAddr4 = nAddr[3];
                pIPAddrCtl->SetAddress(&x);
        }
        else
        {
                // Save contents of IP address control
                BOOL bStatus = pIPAddrCtl->GetAddress(TRUE, &x);
                if (!bStatus)
                {
                        // x.nInError contains the 1-based index of the address field that was in error
                        pDX->m_hWndLastControl = pIPAddrCtl->GetEditControl(x.nInError)->m_hWnd;        // Set HWND of control to set focus on
                        pDX->m_bEditLastControl = TRUE;                 // It's an edit control (so Fail selects the text)
                        pDX->Fail();                                                    // Fail DDX
                }
        szAddr.Format(_T("%d.%d.%d.%d"),
                (unsigned char) x.nAddr1, (unsigned char) x.nAddr2,
                (unsigned char) x.nAddr3, (unsigned char) x.nAddr4);
        }
}

---