able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/comctl32/v5/ipaddr.c

972 lines
27 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/* Copyright (c) 1991, Microsoft Corporation, all rights reserved
ipaddr.c - TCP/IP Address custom control
November 9, 1992 Greg Strange
*/
#include "ctlspriv.h"
// The character that is displayed between address fields.
#define FILLER TEXT('.')
#define SZFILLER TEXT(".")
#define SPACE TEXT(' ')
#define BACK_SPACE 8
/* Min, max values */
#define NUM_FIELDS 4
#define CHARS_PER_FIELD 3
#define HEAD_ROOM 1 // space at top of control
#define LEAD_ROOM 3 // space at front of control
#define MIN_FIELD_VALUE 0 // default minimum allowable field value
#define MAX_FIELD_VALUE 255 // default maximum allowable field value
// All the information unique to one control is stuffed in one of these
// structures in global memory and the handle to the memory is stored in the
// Windows extra space.
typedef struct tagFIELD {
HANDLE hWnd;
WNDPROC lpfnWndProc;
BYTE byLow; // lowest allowed value for this field.
BYTE byHigh; // Highest allowed value for this field.
} FIELD;
typedef struct tagIPADDR {
HWND hwndParent;
HWND hwnd;
UINT uiFieldWidth;
UINT uiFillerWidth;
BOOL fEnabled : 1;
BOOL fPainted : 1;
BOOL bControlInFocus : 1; // TRUE if the control is already in focus, dont't send another focus command
BOOL bCancelParentNotify : 1; // Don't allow the edit controls to notify parent if TRUE
BOOL fInMessageBox : 1; // Set when a message box is displayed so that
BOOL fFontCreated :1;
HFONT hfont;
// we don't send a EN_KILLFOCUS message when
// we receive the EN_KILLFOCUS message for the
// current field.
FIELD Children[NUM_FIELDS];
} IPADDR;
// The following macros extract and store the CONTROL structure for a control.
#define IPADDRESS_EXTRA sizeof(DWORD)
#define GET_IPADDR_HANDLE(hWnd) ((HGLOBAL)(GetWindowLongPtr((hWnd), GWLP_USERDATA)))
#define SAVE_IPADDR_HANDLE(hWnd,x) (SetWindowLongPtr((hWnd), GWLP_USERDATA, (LONG_PTR)(x)))
/* internal IPAddress function prototypes */
LRESULT IPAddressWndFn( HWND, UINT, WPARAM, LPARAM );
LRESULT IPAddressFieldProc(HWND, UINT, WPARAM, LPARAM);
BOOL SwitchFields(IPADDR FAR *, int, int, WORD, WORD);
void EnterField(FIELD FAR *, WORD, WORD);
BOOL ExitField(IPADDR FAR *, int iField);
int GetFieldValue(FIELD FAR *);
void SetFieldValue(IPADDR *pipa, int iField, int iValue);
BOOL IsDBCS();
/*
IPAddrInit() - IPAddress custom control initialization
call
hInstance = library or application instance
return
TRUE on success, FALSE on failure.
This function does all the one time initialization of IPAddress custom
controls. Specifically it creates the IPAddress window class.
*/
int InitIPAddr(HANDLE hInstance)
{
WNDCLASS wc;
if (!GetClassInfo(hInstance, WC_IPADDRESS, &wc)) {
/* define class attributes */
wc.lpszClassName = WC_IPADDRESS;
wc.hCursor = LoadCursor(NULL,IDC_IBEAM);
wc.hIcon = NULL;
wc.lpszMenuName = (LPCTSTR)NULL;
wc.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_GLOBALCLASS;
wc.lpfnWndProc = IPAddressWndFn;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.cbWndExtra = IPADDRESS_EXTRA;
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1 );
wc.cbClsExtra = 0;
/* register IPAddress window class */
return RegisterClass(&wc);
}
return TRUE;
}
/*
IPAddressWndFn() - Main window function for an IPAddress control.
call
hWnd handle to IPAddress window
wMsg message number
wParam word parameter
lParam long parameter
*/
void FormatIPAddress(LPTSTR pszString, DWORD* dwValue)
{
int nField, nPos;
BOOL fFinish = FALSE;
dwValue[0] = 0; dwValue[1] = 0; dwValue[2] = 0; dwValue[3] = 0;
if (pszString[0] == 0)
return;
for( nField = 0, nPos = 0; !fFinish; nPos++)
{
if (( pszString[nPos]<TEXT('0')) || (pszString[nPos]>TEXT('9')))
{
// not a number
nField++;
fFinish = (nField == 4);
}
else
{
dwValue[nField] *= 10;
dwValue[nField] += (pszString[nPos]-TEXT('0'));
}
}
}
void IP_OnSetFont(IPADDR* pipa, HFONT hfont, BOOL fRedraw)
{
int i;
RECT rect;
HFONT OldFont;
BOOL fNewFont = FALSE;
UINT uiFieldStart;
HDC hdc;
if (hfont) {
fNewFont = TRUE;
} else {
hfont = (HFONT)SendMessage(pipa->hwnd, WM_GETFONT, 0, 0);
}
hdc = GetDC(pipa->hwnd);
OldFont = SelectObject(hdc, hfont);
GetCharWidth(hdc, FILLER, FILLER,
(int *)(&pipa->uiFillerWidth));
SelectObject(hdc, OldFont);
ReleaseDC(pipa->hwnd, hdc);
GetClientRect(pipa->hwnd, &rect);
pipa->hfont = hfont;
pipa->uiFieldWidth = (RECTWIDTH(rect)
- LEAD_ROOM
- pipa->uiFillerWidth
*(NUM_FIELDS-1))
/ NUM_FIELDS;
uiFieldStart = LEAD_ROOM;
for (i = 0; i < NUM_FIELDS; i++) {
HWND hwnd = pipa->Children[i].hWnd;
if (fNewFont)
SendMessage(hwnd, WM_SETFONT, (WPARAM)hfont, (LPARAM)fRedraw);
SetWindowPos(hwnd, NULL,
uiFieldStart,
HEAD_ROOM,
pipa->uiFieldWidth,
(rect.bottom-rect.top),
SWP_NOACTIVATE);
uiFieldStart += pipa->uiFieldWidth
+ pipa->uiFillerWidth;
}
}
LRESULT IPAddressWndFn( hWnd, wMsg, wParam, lParam )
HWND hWnd;
UINT wMsg;
WPARAM wParam;
LPARAM lParam;
{
LRESULT lResult;
IPADDR *pipa;
int i;
pipa = (IPADDR *)GET_IPADDR_HANDLE(hWnd);
lResult = TRUE;
switch( wMsg )
{
// use empty string (not NULL) to set to blank
case WM_SETTEXT:
{
TCHAR szBuf[CHARS_PER_FIELD+1];
DWORD dwValue[4];
#ifdef UNICODE_WIN9x
WCHAR szTemp[80];
LPTSTR pszString = szTemp;
ConvertAToWN(CP_ACP, szTemp, ARRAYSIZE(szTemp), (LPSTR)lParam, -1);
#else
LPTSTR pszString = (LPTSTR)lParam;
#endif
FormatIPAddress(pszString, &dwValue[0]);
pipa->bCancelParentNotify = TRUE;
for (i = 0; i < NUM_FIELDS; ++i)
{
if (pszString[0] == 0)
{
szBuf[0] = 0;
}
else
{
wsprintf(szBuf, TEXT("%d"), dwValue[i]);
}
SendMessage(pipa->Children[i].hWnd, WM_SETTEXT,
0, (LPARAM) (LPSTR) szBuf);
}
pipa->bCancelParentNotify = FALSE;
SendMessage(pipa->hwndParent, WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hWnd), EN_CHANGE), (LPARAM)hWnd);
}
break;
case WM_GETTEXTLENGTH:
case WM_GETTEXT:
{
int iFieldValue;
DWORD dwValue[4];
#ifdef UNICODE_WIN9x
char pszResult[30];
char *pszDest = (char *)lParam;
#else
TCHAR pszResult[30];
TCHAR *pszDest = (TCHAR *)lParam;
#endif
lResult = 0;
dwValue[0] = 0;
dwValue[1] = 0;
dwValue[2] = 0;
dwValue[3] = 0;
for (i = 0; i < NUM_FIELDS; ++i)
{
iFieldValue = GetFieldValue(&(pipa->Children[i]));
if (iFieldValue == -1)
iFieldValue = 0;
else
++lResult;
dwValue[i] = iFieldValue;
}
#ifdef UNICODE_WIN9x
wsprintfA( pszResult, "%d.%d.%d.%d", dwValue[0], dwValue[1], dwValue[2], dwValue[3] );
#else
wsprintf( pszResult, TEXT("%d.%d.%d.%d"), dwValue[0], dwValue[1], dwValue[2], dwValue[3] );
#endif
if (wMsg == WM_GETTEXT) {
#ifdef UNICODE_WIN9x
lstrcpynA(pszDest, pszResult, (int) wParam);
lResult = lstrlenA( pszDest );
#else
StrCpyN(pszDest, pszResult, (int) wParam);
lResult = lstrlen( pszDest );
#endif
} else {
#ifdef UNICODE_WIN9x
lResult = lstrlenA( pszResult );
#else
lResult = lstrlen( pszResult );
#endif
}
}
break;
case WM_GETDLGCODE :
lResult = DLGC_WANTCHARS;
break;
case WM_NCCREATE:
SetWindowBits(hWnd, GWL_EXSTYLE, WS_EX_CLIENTEDGE, WS_EX_CLIENTEDGE);
lResult = TRUE;
break;
case WM_CREATE : /* create pallette window */
{
LONG id;
CCCreateWindow();
pipa = (IPADDR*)LocalAlloc(LPTR, sizeof(IPADDR));
if (pipa)
{
#define LPCS ((CREATESTRUCT *)lParam)
pipa->fEnabled = TRUE;
pipa->hwndParent = LPCS->hwndParent;
pipa->hwnd = hWnd;
id = GetDlgCtrlID(hWnd);
for (i = 0; i < NUM_FIELDS; ++i)
{
pipa->Children[i].byLow = MIN_FIELD_VALUE;
pipa->Children[i].byHigh = MAX_FIELD_VALUE;
pipa->Children[i].hWnd = CreateWindowEx(0,
TEXT("Edit"),
NULL,
WS_CHILD |
ES_CENTER,
0, 10, 100, 100,
hWnd,
(HMENU)(LONG_PTR)id,
LPCS->hInstance,
(LPVOID)NULL);
SAVE_IPADDR_HANDLE(pipa->Children[i].hWnd, i);
SendMessage(pipa->Children[i].hWnd, EM_LIMITTEXT,
CHARS_PER_FIELD, 0L);
pipa->Children[i].lpfnWndProc =
(WNDPROC) GetWindowLongPtr(pipa->Children[i].hWnd,
GWLP_WNDPROC);
SetWindowLongPtr(pipa->Children[i].hWnd,
GWLP_WNDPROC, (LONG_PTR)IPAddressFieldProc);
}
SAVE_IPADDR_HANDLE(hWnd, pipa);
IP_OnSetFont(pipa, NULL, FALSE);
for (i = 0; i < NUM_FIELDS; ++i)
ShowWindow(pipa->Children[i].hWnd, SW_SHOW);
#undef LPCS
}
else
DestroyWindow(hWnd);
}
lResult = 0;
break;
case WM_PAINT: /* paint IPADDR window */
{
PAINTSTRUCT Ps;
RECT rect;
COLORREF TextColor;
COLORREF cRef;
HFONT OldFont;
BeginPaint(hWnd, (LPPAINTSTRUCT)&Ps);
OldFont = SelectObject( Ps.hdc, pipa->hfont);
GetClientRect(hWnd, &rect);
if (pipa->fEnabled)
{
TextColor = GetSysColor(COLOR_WINDOWTEXT);
cRef = GetSysColor(COLOR_WINDOW);
}
else
{
TextColor = GetSysColor(COLOR_GRAYTEXT);
cRef = GetSysColor(COLOR_3DFACE);
}
FillRectClr(Ps.hdc, &rect, cRef);
SetRect(&rect, 0, HEAD_ROOM, pipa->uiFillerWidth, (rect.bottom-rect.top));
SetBkColor(Ps.hdc, cRef);
SetTextColor(Ps.hdc, TextColor);
for (i = 0; i < NUM_FIELDS-1; ++i)
{
rect.left += pipa->uiFieldWidth + pipa->uiFillerWidth;
rect.right += rect.left + pipa->uiFillerWidth;
ExtTextOut(Ps.hdc, rect.left, HEAD_ROOM, ETO_OPAQUE, &rect, SZFILLER, 1, NULL);
}
pipa->fPainted = TRUE;
SelectObject(Ps.hdc, OldFont);
EndPaint(hWnd, &Ps);
}
break;
case WM_SETFOCUS : /* get focus - display caret */
EnterField(&(pipa->Children[0]), 0, CHARS_PER_FIELD);
break;
HANDLE_MSG(pipa, WM_SETFONT, IP_OnSetFont);
case WM_LBUTTONDOWN : /* left button depressed - fall through */
SetFocus(hWnd);
break;
case WM_ENABLE:
{
pipa->fEnabled = (BOOL)wParam;
for (i = 0; i < NUM_FIELDS; ++i)
{
EnableWindow(pipa->Children[i].hWnd, (BOOL)wParam);
}
if (pipa->fPainted)
InvalidateRect(hWnd, NULL, FALSE);
}
break;
case WM_DESTROY :
CCDestroyWindow();
// Restore all the child window procedures before we delete our memory block.
for (i = 0; i < NUM_FIELDS; ++i)
{
SendMessage(pipa->Children[i].hWnd, WM_DESTROY, 0, 0);
SetWindowLongPtr(pipa->Children[i].hWnd, GWLP_WNDPROC,
(LONG_PTR)pipa->Children[i].lpfnWndProc);
}
LocalFree(pipa);
break;
case WM_COMMAND:
switch (HIWORD(wParam))
{
// One of the fields lost the focus, see if it lost the focus to another field
// of if we've lost the focus altogether. If its lost altogether, we must send
// an EN_KILLFOCUS notification on up the ladder.
case EN_KILLFOCUS:
{
HWND hFocus;
if (!pipa->fInMessageBox)
{
hFocus = GetFocus();
for (i = 0; i < NUM_FIELDS; ++i)
if (pipa->Children[i].hWnd == hFocus)
break;
if (i >= NUM_FIELDS)
{
SendMessage(pipa->hwndParent, WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hWnd),
EN_KILLFOCUS), (LPARAM)hWnd);
pipa->bControlInFocus = FALSE;
}
}
}
break;
case EN_SETFOCUS:
{
HWND hFocus;
if (!pipa->fInMessageBox)
{
hFocus = (HWND)lParam;
for (i = 0; i < NUM_FIELDS; ++i)
if (pipa->Children[i].hWnd == hFocus)
break;
// send a focus message when the
if (i < NUM_FIELDS && pipa->bControlInFocus == FALSE)
{
SendMessage(pipa->hwndParent, WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hWnd),
EN_SETFOCUS), (LPARAM)hWnd);
pipa->bControlInFocus = TRUE; // only set the focus once
}
}
}
break;
case EN_CHANGE:
if (pipa->bCancelParentNotify == FALSE)
{
SendMessage(pipa->hwndParent, WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hWnd), EN_CHANGE), (LPARAM)hWnd);
}
break;
}
break;
// Get the value of the IP Address. The address is placed in the DWORD pointed
// to by lParam and the number of non-blank fields is returned.
case IPM_GETADDRESS:
{
int iFieldValue;
DWORD dwValue;
lResult = 0;
dwValue = 0;
for (i = 0; i < NUM_FIELDS; ++i)
{
iFieldValue = GetFieldValue(&(pipa->Children[i]));
if (iFieldValue == -1)
iFieldValue = 0;
else
++lResult;
dwValue = (dwValue << 8) + iFieldValue;
}
*((DWORD *)lParam) = dwValue;
}
break;
// Clear all fields to blanks.
case IPM_CLEARADDRESS:
{
pipa->bCancelParentNotify = TRUE;
for (i = 0; i < NUM_FIELDS; ++i)
{
SendMessage(pipa->Children[i].hWnd, WM_SETTEXT,
0, (LPARAM) (LPSTR) TEXT(""));
}
pipa->bCancelParentNotify = FALSE;
SendMessage(pipa->hwndParent, WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hWnd), EN_CHANGE), (LPARAM)hWnd);
}
break;
// Set the value of the IP Address. The address is in the lParam with the
// first address byte being the high byte, the second being the second byte,
// and so on. A lParam value of -1 removes the address.
case IPM_SETADDRESS:
{
pipa->bCancelParentNotify = TRUE;
for (i = 0; i < NUM_FIELDS; ++i)
{
BYTE bVal = HIBYTE(HIWORD(lParam));
if (pipa->Children[i].byLow <= bVal &&
bVal <= pipa->Children[i].byHigh) {
SetFieldValue(pipa, i, bVal);
} else {
lResult = FALSE;
}
lParam <<= 8;
}
pipa->bCancelParentNotify = FALSE;
SendMessage(pipa->hwndParent, WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hWnd), EN_CHANGE), (LPARAM)hWnd);
}
break;
case IPM_SETRANGE:
if (wParam < NUM_FIELDS && LOBYTE(LOWORD(lParam)) <= HIBYTE(LOWORD(lParam)))
{
lResult = MAKEIPRANGE(pipa->Children[wParam].byLow, pipa->Children[wParam].byHigh);
pipa->Children[wParam].byLow = LOBYTE(LOWORD(lParam));
pipa->Children[wParam].byHigh = HIBYTE(LOWORD(lParam));
break;
}
lResult = 0;
break;
// Set the focus to this IPADDR.
// wParam = the field number to set focus to, or -1 to set the focus to the
// first non-blank field.
case IPM_SETFOCUS:
if (wParam >= NUM_FIELDS)
{
for (wParam = 0; wParam < NUM_FIELDS; ++wParam)
if (GetFieldValue(&(pipa->Children[wParam])) == -1) break;
if (wParam >= NUM_FIELDS) wParam = 0;
}
EnterField(&(pipa->Children[wParam]), 0, CHARS_PER_FIELD);
break;
// Determine whether all four subfields are blank
case IPM_ISBLANK:
lResult = TRUE;
for (i = 0; i < NUM_FIELDS; ++i)
{
if (GetFieldValue(&(pipa->Children[i])) != -1)
{
lResult = FALSE;
break;
}
}
break;
default:
lResult = DefWindowProc( hWnd, wMsg, wParam, lParam );
break;
}
return( lResult );
}
/*
IPAddressFieldProc() - Edit field window procedure
This function sub-classes each edit field.
*/
LRESULT IPAddressFieldProc(HWND hWnd,
UINT wMsg,
WPARAM wParam,
LPARAM lParam)
{
IPADDR *pipa;
FIELD *pField;
HWND hIPADDRWindow;
WORD wChildID;
LRESULT lresult;
if (!(hIPADDRWindow = GetParent(hWnd)))
return 0;
pipa = (IPADDR *)GET_IPADDR_HANDLE(hIPADDRWindow);
if (!pipa)
return 0;
wChildID = (WORD)GET_IPADDR_HANDLE(hWnd);
pField = &(pipa->Children[wChildID]);
if (pField->hWnd != hWnd)
return 0;
switch (wMsg)
{
case WM_DESTROY:
DeleteObject((HGDIOBJ)SendMessage(hWnd, WM_GETFONT, 0, 0));
return 0;
case WM_CHAR:
// Typing in the last digit in a field, skips to the next field.
if (wParam >= TEXT('0') && wParam <= TEXT('9'))
{
LRESULT lResult;
lResult = CallWindowProc(pipa->Children[wChildID].lpfnWndProc,
hWnd, wMsg, wParam, lParam);
lResult = SendMessage(hWnd, EM_GETSEL, 0, 0L);
if (lResult == MAKELPARAM(CHARS_PER_FIELD, CHARS_PER_FIELD)
&& ExitField(pipa, wChildID)
&& wChildID < NUM_FIELDS-1)
{
EnterField(&(pipa->Children[wChildID+1]),
0, CHARS_PER_FIELD);
}
return lResult;
}
// spaces and periods fills out the current field and then if possible,
// goes to the next field.
else if (wParam == FILLER || wParam == SPACE )
{
LRESULT lResult;
lResult = SendMessage(hWnd, EM_GETSEL, 0, 0L);
if (lResult != 0L && HIWORD(lResult) == LOWORD(lResult)
&& ExitField(pipa, wChildID))
{
if (wChildID >= NUM_FIELDS-1)
MessageBeep((UINT)-1);
else
{
EnterField(&(pipa->Children[wChildID+1]),
0, CHARS_PER_FIELD);
}
}
return 0;
}
// Backspaces go to the previous field if at the beginning of the current field.
// Also, if the focus shifts to the previous field, the backspace must be
// processed by that field.
else if (wParam == BACK_SPACE)
{
if (wChildID > 0 && SendMessage(hWnd, EM_GETSEL, 0, 0L) == 0L)
{
if (SwitchFields(pipa, wChildID, wChildID-1,
CHARS_PER_FIELD, CHARS_PER_FIELD)
&& SendMessage(pipa->Children[wChildID-1].hWnd,
EM_LINELENGTH, 0, 0L) != 0L)
{
SendMessage(pipa->Children[wChildID-1].hWnd,
wMsg, wParam, lParam);
}
return 0;
}
}
// Any other printable characters are not allowed.
else if (wParam > SPACE)
{
MessageBeep((UINT)-1);
return 0;
}
break;
case WM_KEYDOWN:
switch (wParam)
{
// Arrow keys move between fields when the end of a field is reached.
case VK_LEFT:
case VK_RIGHT:
case VK_UP:
case VK_DOWN:
if (GetKeyState(VK_CONTROL) < 0)
{
if ((wParam == VK_LEFT || wParam == VK_UP) && wChildID > 0)
{
SwitchFields(pipa, wChildID, wChildID-1,
0, CHARS_PER_FIELD);
return 0;
}
else if ((wParam == VK_RIGHT || wParam == VK_DOWN)
&& wChildID < NUM_FIELDS-1)
{
SwitchFields(pipa, wChildID, wChildID+1,
0, CHARS_PER_FIELD);
return 0;
}
}
else
{
DWORD dwResult;
WORD wStart, wEnd;
dwResult = (DWORD)SendMessage(hWnd, EM_GETSEL, 0, 0L);
wStart = LOWORD(dwResult);
wEnd = HIWORD(dwResult);
if (wStart == wEnd)
{
if ((wParam == VK_LEFT || wParam == VK_UP)
&& wStart == 0
&& wChildID > 0)
{
SwitchFields(pipa, wChildID, wChildID-1,
CHARS_PER_FIELD, CHARS_PER_FIELD);
return 0;
}
else if ((wParam == VK_RIGHT || wParam == VK_DOWN)
&& wChildID < NUM_FIELDS-1)
{
dwResult = (DWORD)SendMessage(hWnd, EM_LINELENGTH, 0, 0L);
if (wStart >= dwResult)
{
SwitchFields(pipa, wChildID, wChildID+1, 0, 0);
return 0;
}
}
}
}
break;
// Home jumps back to the beginning of the first field.
case VK_HOME:
if (wChildID > 0)
{
SwitchFields(pipa, wChildID, 0, 0, 0);
return 0;
}
break;
// End scoots to the end of the last field.
case VK_END:
if (wChildID < NUM_FIELDS-1)
{
SwitchFields(pipa, wChildID, NUM_FIELDS-1,
CHARS_PER_FIELD, CHARS_PER_FIELD);
return 0;
}
break;
} // switch (wParam)
break;
case WM_KILLFOCUS:
if ( !ExitField( pipa, wChildID ))
{
return 0;
}
} // switch (wMsg)
lresult = CallWindowProc( pipa->Children[wChildID].lpfnWndProc,
hWnd, wMsg, wParam, lParam);
return lresult;
}
/*
Switch the focus from one field to another.
call
pipa = Pointer to the IPADDR structure.
iOld = Field we're leaving.
iNew = Field we're entering.
hNew = Window of field to goto
wStart = First character selected
wEnd = Last character selected + 1
returns
TRUE on success, FALSE on failure.
Only switches fields if the current field can be validated.
*/
BOOL SwitchFields(IPADDR *pipa, int iOld, int iNew, WORD wStart, WORD wEnd)
{
if (!ExitField(pipa, iOld)) return FALSE;
EnterField(&(pipa->Children[iNew]), wStart, wEnd);
return TRUE;
}
/*
Set the focus to a specific field's window.
call
pField = pointer to field structure for the field.
wStart = First character selected
wEnd = Last character selected + 1
*/
void EnterField(FIELD *pField, WORD wStart, WORD wEnd)
{
SetFocus(pField->hWnd);
SendMessage(pField->hWnd, EM_SETSEL, wStart, wEnd);
}
void SetFieldValue(IPADDR *pipa, int iField, int iValue)
{
TCHAR szBuf[CHARS_PER_FIELD+1];
FIELD* pField = &(pipa->Children[iField]);
wsprintf(szBuf, TEXT("%d"), iValue);
SendMessage(pField->hWnd, WM_SETTEXT, 0, (LPARAM) (LPSTR) szBuf);
}
/*
Exit a field.
call
pipa = pointer to IPADDR structure.
iField = field number being exited.
returns
TRUE if the user may exit the field.
FALSE if he may not.
*/
BOOL ExitField(IPADDR *pipa, int iField)
{
FIELD *pField;
int i;
NMIPADDRESS nm;
int iOldValue;
pField = &(pipa->Children[iField]);
i = GetFieldValue(pField);
iOldValue = i;
nm.iField = iField;
nm.iValue = i;
SendNotifyEx(pipa->hwndParent, pipa->hwnd, IPN_FIELDCHANGED, &nm.hdr, FALSE);
i = nm.iValue;
if (i != -1) {
if (i < (int)(UINT)pField->byLow || i > (int)(UINT)pField->byHigh)
{
if ( i < (int)(UINT) pField->byLow )
{
/* too small */
i = (int)(UINT)pField->byLow;
}
else
{
/* must be bigger */
i = (int)(UINT)pField->byHigh;
}
SetFieldValue(pipa, iField, i);
// CHEEBUGBUG: send notify up
return FALSE;
}
}
if (iOldValue != i) {
SetFieldValue(pipa, iField, i);
}
return TRUE;
}
/*
Get the value stored in a field.
call
pField = pointer to the FIELD structure for the field.
returns
The value (0..255) or -1 if the field has not value.
*/
int GetFieldValue(FIELD *pField)
{
WORD wLength;
TCHAR szBuf[CHARS_PER_FIELD+1];
INT i;
*(WORD *)szBuf = (sizeof(szBuf)/sizeof(TCHAR)) - 1;
wLength = (WORD)SendMessage(pField->hWnd,EM_GETLINE,0,(LPARAM)(LPSTR)szBuf);
if (wLength != 0)
{
szBuf[wLength] = TEXT('\0');
i = StrToInt(szBuf);
return i;
}
else
return -1;
}
BOOL IsDBCS()
{
LANGID langid;
langid = PRIMARYLANGID(GetThreadLocale());
if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
{
return (TRUE);
}
else
{
return (FALSE);
}
}
Reference in a new issue Copy permalink