IPaddress common control implementation. First try; needs more work to

dlls/comctl32/ipaddress.c

-/*
- * IP Address control
+/* IP Address control
  *
  * Copyright 1998 Eric Kohl
+ * Copyright 1998 Alex Priem <alexp@sci.kun.nl>
  *
  * NOTES
- *   This is just a dummy control. An author is needed! Any volunteers?
- *   I will only improve this control once in a while.
- *     Eric <ekohl@abo.rhein-zeitung.de>
+
  *
  * TODO:
- *   - All messages.
- *   - All notifications.
- *
+ *    -Check ranges when changing field-focus.
+ * 	  -Check all notifications/behavior.
+ *    -Optimization: include lpipsi in IPADDRESS_INFO.
+ *	  -CurrentFocus: field that has focus at moment of processing.
+ *	  -connect Rect32 rcClient.
+ *	  -handle right and left arrows correctly. Boring.
+ *	  -split GotoNextField in CheckField and GotoNextField.
+ *	  -check ipaddress.cpp for missing features.
+ *    -refresh: draw '.' instead of setpixel.
+ *	  -handle VK_ESCAPE.
  */
 
+#include <ctype.h>
+#include <stdlib.h>
+
 #include "windows.h"
+#include "win.h"
 #include "commctrl.h"
 #include "ipaddress.h"
-#include "win.h"
+#include "heap.h"
 #include "debug.h"
 
 
 #define IPADDRESS_GetInfoPtr(wndPtr) ((IPADDRESS_INFO *)wndPtr->wExtra[0])
 
 
+static BOOL32 
+IPADDRESS_SendNotify (WND *wndPtr, UINT32 command);
+static BOOL32 
+IPADDRESS_SendIPAddressNotify (WND *wndPtr, UINT32 field, BYTE newValue);
+
+
+/* property name of tooltip window handle */
+#define IP_SUBCLASS_PROP "CCIP32SubclassInfo"
+
+
+static LRESULT CALLBACK
+IPADDRESS_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam);
+
+
+
+
+static VOID
+IPADDRESS_Refresh (WND *wndPtr, HDC32 hdc)
+{
+	RECT32 rcClient;
+	HBRUSH32 hbr;
+	COLORREF clr=GetSysColor32 (COLOR_3DDKSHADOW);
+    int i,x,fieldsize;
+
+    GetClientRect32 (wndPtr->hwndSelf, &rcClient);
+	hbr =  CreateSolidBrush32 (RGB(255,255,255));
+    DrawEdge32 (hdc, &rcClient, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
+	FillRect32 (hdc, &rcClient, hbr);
+    DeleteObject32 (hbr);
+
+	x=rcClient.left;
+	fieldsize=(rcClient.right-rcClient.left) /4;
+
+	for (i=0; i<3; i++) {		/* Should draw text "." here */
+		x+=fieldsize;
+		SetPixel32 (hdc, x,   13, clr);
+		SetPixel32 (hdc, x,   14, clr);
+		SetPixel32 (hdc, x+1, 13, clr);
+		SetPixel32 (hdc, x+1, 14, clr);
+
+	}
+
+}
+
 
 
 
@@ -32,47 +85,418 @@ static LRESULT
 IPADDRESS_Create (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
     IPADDRESS_INFO *infoPtr;
+	RECT32 rcClient, edit;
+	int i,fieldsize;
+	LPIP_SUBCLASS_INFO lpipsi;
+	
 
-    /* allocate memory for info structure */
     infoPtr = (IPADDRESS_INFO *)COMCTL32_Alloc (sizeof(IPADDRESS_INFO));
     wndPtr->wExtra[0] = (DWORD)infoPtr;
 
-    if (infoPtr == NULL) {
-	ERR (listview, "could not allocate info memory!\n");
-	return 0;
+	if (infoPtr == NULL) {
+    	ERR (ipaddress, "could not allocate info memory!\n");
+    	return 0;
     }
 
-    if ((IPADDRESS_INFO*)wndPtr->wExtra[0] != infoPtr) {
-	ERR (listview, "pointer assignment error!\n");
-	return 0;
-    }
+    GetClientRect32 (wndPtr->hwndSelf, &rcClient);
+
+	fieldsize=(rcClient.right-rcClient.left) /4;
+
+	edit.top   =rcClient.top+2;
+	edit.bottom=rcClient.bottom-2;
+
+	lpipsi=(LPIP_SUBCLASS_INFO)
+			GetProp32A ((HWND32)wndPtr->hwndSelf,IP_SUBCLASS_PROP);
+	if (lpipsi == NULL)  {
+		lpipsi= (LPIP_SUBCLASS_INFO) COMCTL32_Alloc (sizeof(IP_SUBCLASS_INFO));
+		lpipsi->wndPtr=wndPtr;
+		lpipsi->uRefCount++;
+		SetProp32A ((HWND32)wndPtr->hwndSelf, IP_SUBCLASS_PROP,
+					(HANDLE32)lpipsi);
+/*		infoPtr->lpipsi= lpipsi; */
+	} else 
+		WARN (ipaddress,"IP-create called twice\n");
+	
+	for (i=0; i<=3; i++) {
+		infoPtr->LowerLimit[i]=0;
+		infoPtr->UpperLimit[i]=255;
+		edit.left=rcClient.left+i*fieldsize+3;
+		edit.right=rcClient.left+(i+1)*fieldsize-2;
+		lpipsi->hwndIP[i]= CreateWindow32A ("edit", NULL, 
+				WS_CHILD | WS_VISIBLE | ES_LEFT,
+				edit.left, edit.top, edit.right-edit.left, edit.bottom-edit.top,
+				wndPtr->hwndSelf, (HMENU32) 1, wndPtr->hInstance, NULL);
+		lpipsi->wpOrigProc[i]= (WNDPROC32)
+					SetWindowLong32A (lpipsi->hwndIP[i],GWL_WNDPROC, (LONG)
+					IPADDRESS_SubclassProc);
+		SetProp32A ((HWND32)lpipsi->hwndIP[i], IP_SUBCLASS_PROP,
+					(HANDLE32)lpipsi);
+	}
+
+	lpipsi->infoPtr= infoPtr;
 
-    /* initialize info structure */
+    return 0;
+}
 
 
+static LRESULT
+IPADDRESS_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+	int i;
+    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr(wndPtr);
+	LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
+            GetProp32A ((HWND32)wndPtr->hwndSelf,IP_SUBCLASS_PROP);
 
+	for (i=0; i<=3; i++) {
+		SetWindowLong32A ((HWND32)lpipsi->hwndIP[i], GWL_WNDPROC,
+                  (LONG)lpipsi->wpOrigProc[i]);
+	}
+
+    COMCTL32_Free (infoPtr);
     return 0;
 }
 
 
 static LRESULT
-IPADDRESS_Destroy (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+IPADDRESS_KillFocus (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
 {
-    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr(wndPtr);
+    HDC32 hdc;
 
+	TRACE (ipaddress,"\n");
+    hdc = GetDC32 (wndPtr->hwndSelf);
+    IPADDRESS_Refresh (wndPtr, hdc);
+    ReleaseDC32 (wndPtr->hwndSelf, hdc);
 
+	IPADDRESS_SendIPAddressNotify (wndPtr, 0, 0);  /* FIXME: should use -1 */
+	IPADDRESS_SendNotify (wndPtr, EN_KILLFOCUS);       
+    InvalidateRect32 (wndPtr->hwndSelf, NULL, TRUE);
 
+    return 0;
+}
 
 
+static LRESULT
+IPADDRESS_Paint (WND *wndPtr, WPARAM32 wParam)
+{
+    HDC32 hdc;
+    PAINTSTRUCT32 ps;
+
+    hdc = wParam==0 ? BeginPaint32 (wndPtr->hwndSelf, &ps) : (HDC32)wParam;
+    IPADDRESS_Refresh (wndPtr, hdc);
+    if(!wParam)
+	EndPaint32 (wndPtr->hwndSelf, &ps);
+    return 0;
+}
+
+
+static LRESULT
+IPADDRESS_SetFocus (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+    HDC32 hdc;
+
+	TRACE (ipaddress,"\n");
+
+    hdc = GetDC32 (wndPtr->hwndSelf);
+    IPADDRESS_Refresh (wndPtr, hdc);
+    ReleaseDC32 (wndPtr->hwndSelf, hdc);
+
+    return 0;
+}
 
-    /* free ipaddress info data */
-    COMCTL32_Free (infoPtr);
 
+static LRESULT
+IPADDRESS_Size (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr(wndPtr);
+	TRACE (ipaddress,"\n");
     return 0;
 }
 
 
+static BOOL32
+IPADDRESS_SendNotify (WND *wndPtr, UINT32 command)
 
+{
+    TRACE (ipaddress, "%x\n",command);
+    return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_COMMAND,
+              MAKEWPARAM (wndPtr->wIDmenu,command), (LPARAM) wndPtr->hwndSelf);
+}
+
+
+static BOOL32
+IPADDRESS_SendIPAddressNotify (WND *wndPtr, UINT32 field, BYTE newValue)
+
+{
+	NMIPADDRESS nmip;
+
+    TRACE (ipaddress, "%x %x\n",field,newValue);
+    nmip.hdr.hwndFrom = wndPtr->hwndSelf;
+    nmip.hdr.idFrom   = wndPtr->wIDmenu;
+    nmip.hdr.code     = IPN_FIELDCHANGED;
+
+	nmip.iField=field;
+	nmip.iValue=newValue;
+
+    return (BOOL32)SendMessage32A (GetParent32 (wndPtr->hwndSelf), WM_NOTIFY,
+                                   (WPARAM32)wndPtr->wIDmenu, (LPARAM)&nmip);
+}
+
+
+
+
+static LRESULT
+IPADDRESS_ClearAddress (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+	int i;
+	HDC32 hdc;
+	char buf[1];
+	LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
+            GetProp32A ((HWND32)wndPtr->hwndSelf,IP_SUBCLASS_PROP);
+
+	TRACE (ipaddress,"\n");
+
+	buf[0]=0;
+	for (i=0; i<=3; i++) 
+		SetWindowText32A (lpipsi->hwndIP[i],buf);
+	
+  	hdc = GetDC32 (wndPtr->hwndSelf);
+    IPADDRESS_Refresh (wndPtr, hdc);
+    ReleaseDC32 (wndPtr->hwndSelf, hdc);
+	return 0;
+}
+
+static LRESULT
+IPADDRESS_IsBlank (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+ int i;
+ char buf[20];
+ LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
+            GetProp32A ((HWND32)wndPtr->hwndSelf,IP_SUBCLASS_PROP);
+
+ TRACE (ipaddress,"\n");
+
+ for (i=0; i<=3; i++) {
+		GetWindowText32A (lpipsi->hwndIP[i],buf,5);
+		if (buf[0]) return 0;
+	}
+
+ return 1;
+}
+
+static LRESULT
+IPADDRESS_GetAddress (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+ char field[20];
+ int i,valid,fieldvalue;
+ DWORD ip_addr;
+ IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr(wndPtr);
+ LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
+            GetProp32A ((HWND32)wndPtr->hwndSelf,IP_SUBCLASS_PROP);
+
+ TRACE (ipaddress,"\n");
+
+ valid=0;
+ ip_addr=0;
+ for (i=0; i<=3; i++) {
+		GetWindowText32A (lpipsi->hwndIP[i],field,4);
+		ip_addr*=256;
+		if (field[0]) {
+			field[3]=0;
+			fieldvalue=atoi(field);
+			if (fieldvalue<infoPtr->LowerLimit[i]) 
+				fieldvalue=infoPtr->LowerLimit[i];
+			if (fieldvalue>infoPtr->UpperLimit[i]) 
+				fieldvalue=infoPtr->UpperLimit[i];
+			ip_addr+=fieldvalue;
+			valid++;
+		}
+ }
+
+ *(LPDWORD) lParam=ip_addr;
+
+ return valid;
+}
+
+static LRESULT
+IPADDRESS_SetRange (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+
+{
+    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr(wndPtr);
+	INT32 index;
+	
+ 	TRACE (ipaddress,"\n");
+
+	index=(INT32) wParam;
+	if ((index<0) || (index>3)) return 0;
+
+	infoPtr->LowerLimit[index]=lParam & 0xff;
+	infoPtr->UpperLimit[index]=(lParam >>8)  & 0xff;
+	return 1;
+}
+
+static LRESULT
+IPADDRESS_SetAddress (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+	HDC32 hdc;
+    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr(wndPtr);
+	LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
+            GetProp32A ((HWND32)wndPtr->hwndSelf,IP_SUBCLASS_PROP);
+	int i,ip_address,value;
+    char buf[20];
+
+ 	TRACE (ipaddress,"\n");
+	ip_address=(DWORD) lParam;
+
+	for (i=3; i>=0; i--) {
+		value=ip_address & 0xff;
+		if ((value>=infoPtr->LowerLimit[i]) && (value<=infoPtr->UpperLimit[i])) 
+			{
+			 sprintf (buf,"%d",value);
+			 SetWindowText32A (lpipsi->hwndIP[i],buf);
+			 IPADDRESS_SendNotify (wndPtr, EN_CHANGE);
+		}
+		ip_address/=256;
+	}
+
+	hdc = GetDC32 (wndPtr->hwndSelf);		/* & send notifications */
+    IPADDRESS_Refresh (wndPtr, hdc);
+    ReleaseDC32 (wndPtr->hwndSelf, hdc);
+
+ return TRUE;
+}
+
+
+
+
+static LRESULT
+IPADDRESS_SetFocusToField (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr(wndPtr);
+	LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
+            GetProp32A ((HWND32)wndPtr->hwndSelf,IP_SUBCLASS_PROP);
+	INT32 index;
+
+	index=(INT32) wParam;
+ 	TRACE (ipaddress," %d\n", index);
+	if ((index<0) || (index>3)) return 0;
+	
+	SetFocus32 (lpipsi->hwndIP[index]);
+	
+    return 1;
+}
+
+
+static LRESULT
+IPADDRESS_LButtonDown (WND *wndPtr, WPARAM32 wParam, LPARAM lParam)
+{
+    TRACE (ipaddress, "\n");
+
+	SetFocus32 (wndPtr->hwndSelf);
+	IPADDRESS_SendNotify (wndPtr, EN_SETFOCUS);
+	IPADDRESS_SetFocusToField (wndPtr, 0, 0);
+
+ 	return TRUE;
+}
+
+
+
+/* tab/shift-tab: IPN_FIELDCHANGED, lose focus.
+   dot, space,right arrow:	set focus to next child edit.
+   numerics (0..9), control characters: forward to default edit control 
+   other characters: dropped
+*/
+   
+
+
+
+static int
+IPADDRESS_GotoNextField (LPIP_SUBCLASS_INFO lpipsi, int currentfield)
+{
+ int newField,fieldvalue;
+ char field[20];
+ IPADDRESS_INFO *infoPtr=lpipsi->infoPtr;
+
+ TRACE (ipaddress,"\n");
+ GetWindowText32A (lpipsi->hwndIP[currentfield],field,4);
+ if (field[0]) {
+	field[3]=0;	
+	newField=-1;
+	fieldvalue=atoi(field);
+	if (fieldvalue<infoPtr->LowerLimit[currentfield]) 
+		newField=infoPtr->LowerLimit[currentfield];
+	if (fieldvalue>infoPtr->UpperLimit[currentfield])
+		newField=infoPtr->UpperLimit[currentfield];
+	if (newField>=0) {
+		sprintf (field,"%d",newField);
+		SetWindowText32A (lpipsi->hwndIP[currentfield], field);
+		return 1;
+	}
+ }
+
+ if (currentfield<3) 
+		SetFocus32 (lpipsi->hwndIP[currentfield+1]);
+ return 0;
+}
+
+
+LRESULT CALLBACK
+IPADDRESS_SubclassProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
+{
+ int i,l,index;
+ IPADDRESS_INFO *infoPtr;
+ LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
+            GetProp32A ((HWND32)hwnd,IP_SUBCLASS_PROP); 
+
+ infoPtr = lpipsi->infoPtr;
+ index=0;             /* FIXME */
+ for (i=0; i<=3; i++) 
+		if (lpipsi->hwndIP[i]==hwnd) index=i;
+
+ switch (uMsg) {
+	case WM_CHAR: break;
+	case WM_KEYDOWN: {
+			char c=(char) wParam;
+			if (c==VK_TAB) {
+ 				HWND32 pwnd;
+				int shift;
+				shift = GetKeyState32(VK_SHIFT) & 0x8000;
+				if (shift)
+					pwnd=GetNextDlgTabItem32 (GetParent32 (hwnd), 0, TRUE);
+				else
+					pwnd=GetNextDlgTabItem32 (GetParent32 (hwnd), 0, FALSE);
+				if (pwnd) SetFocus32 (pwnd);
+				break;
+			}
+			
+			if ((c==' ') || (c=='.') || (c==VK_RIGHT)) {
+				IPADDRESS_GotoNextField (lpipsi,index);
+				wParam=0;
+				lParam=0;
+				break;
+			}
+			if (c==VK_LEFT) {
+				
+			}
+			if (c==VK_RETURN) {
+			}
+			if (((c>='0') && (c<='9')) || (iscntrl(c))) {
+				l=GetWindowTextLength32A (lpipsi->hwndIP[index]);
+				if (l==3) 
+					if (IPADDRESS_GotoNextField (lpipsi,index)) {
+						wParam=0;
+						lParam=0;
+					}
+				break;
+			}
+	
+			wParam=0;
+			lParam=0;
+			break;
+		}
+ }
+
+ return CallWindowProc32A (lpipsi->wpOrigProc[index], hwnd, uMsg, wParam, lParam);
+}
 
 LRESULT WINAPI
 IPADDRESS_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
@@ -81,13 +505,23 @@ IPADDRESS_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
 
     switch (uMsg)
     {
-//	case IPM_CLEARADDRESS:
-//	case IPM_GETADDRESS:
-//	case IPM_ISBLANK:
-//	case IPM_SETADDRESS:
-//	case IPM_SETFOCUS:
-//	case IPM_SETRANGE:
+	case IPM_CLEARADDRESS:
+		return IPADDRESS_ClearAddress (wndPtr, wParam, lParam);
+
+	case IPM_SETADDRESS:
+	    return IPADDRESS_SetAddress (wndPtr, wParam, lParam);
+
+	case IPM_GETADDRESS:
+	    return IPADDRESS_GetAddress (wndPtr, wParam, lParam);
+
+	case IPM_SETRANGE:
+	    return IPADDRESS_SetRange (wndPtr, wParam, lParam);
+
+	case IPM_SETFOCUS:
+	    return IPADDRESS_SetFocusToField (wndPtr, wParam, lParam);
 
+	case IPM_ISBLANK:
+		return IPADDRESS_IsBlank (wndPtr, wParam, lParam);
 
 	case WM_CREATE:
 	    return IPADDRESS_Create (wndPtr, wParam, lParam);
@@ -95,6 +529,24 @@ IPADDRESS_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
 	case WM_DESTROY:
 	    return IPADDRESS_Destroy (wndPtr, wParam, lParam);
 
+	case WM_GETDLGCODE:
+	    return DLGC_WANTARROWS | DLGC_WANTCHARS;
+
+	case WM_KILLFOCUS:
+	    return IPADDRESS_KillFocus (wndPtr, wParam, lParam);
+
+	case WM_LBUTTONDOWN:
+        return IPADDRESS_LButtonDown (wndPtr, wParam, lParam);
+
+	case WM_PAINT:
+	    return IPADDRESS_Paint (wndPtr, wParam);
+
+	case WM_SETFOCUS:
+	    return IPADDRESS_SetFocus (wndPtr, wParam, lParam);
+
+	case WM_SIZE:
+	    return IPADDRESS_Size (wndPtr, wParam, lParam);
+
 	default:
 	    if (uMsg >= WM_USER)
 		ERR (ipaddress, "unknown msg %04x wp=%08x lp=%08lx\n",
@@ -105,8 +557,8 @@ IPADDRESS_WindowProc (HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
 }
 
 
-VOID
-IPADDRESS_Register (VOID)
+void
+IPADDRESS_Register (void)
 {
     WNDCLASS32A wndClass;
 
@@ -118,17 +570,16 @@ IPADDRESS_Register (VOID)
     wndClass.cbClsExtra    = 0;
     wndClass.cbWndExtra    = sizeof(IPADDRESS_INFO *);
     wndClass.hCursor       = LoadCursor32A (0, IDC_ARROW32A);
-    wndClass.hbrBackground = (HBRUSH32)(COLOR_WINDOW + 1);
+    wndClass.hbrBackground = (HBRUSH32)(COLOR_3DFACE + 1);
     wndClass.lpszClassName = WC_IPADDRESS32A;
  
     RegisterClass32A (&wndClass);
 }
 
-
 VOID
 IPADDRESS_Unregister (VOID)
 {
     if (GlobalFindAtom32A (WC_IPADDRESS32A))
-	UnregisterClass32A (WC_IPADDRESS32A, (HINSTANCE32)NULL);
+    UnregisterClass32A (WC_IPADDRESS32A, (HINSTANCE32)NULL);
 }
 

include/commctrl.h

@@ -2468,7 +2468,9 @@ typedef struct tagTCITEM {
 #define IPM_SETFOCUS		(WM_USER+104)
 #define IPM_ISBLANK		(WM_USER+105)
 
-#define IPN_FIELDCHANGED	(IPN_FIRST-0)
+#define IPN_FIRST               (0U-860U)
+#define IPN_LAST                (0U-879U)
+#define IPN_FIELDCHANGED    (IPN_FIRST-0)
 
 typedef struct tagNMIPADDRESS
 {

include/ipaddress.h

@@ -2,20 +2,36 @@
  * IP Address class extra info
  *
  * Copyright 1998 Eric Kohl
+ * Copyright 1998 Alex Priem
  */
 
 #ifndef __WINE_IPADDRESS_H
 #define __WINE_IPADDRESS_H
 
+#include "win.h"
+
+
+
 typedef struct tagIPADDRESS_INFO
 {
-    DWORD dwDummy;  /* just to keep the compiler happy ;-) */
+	BYTE LowerLimit[4];
+	BYTE UpperLimit[4];
 
+	RECT32 	rcClient;
+	INT32	uFocus;
+} IPADDRESS_INFO;
 
-} IPADDRESS_INFO, *LPIPADDRESS_INFO;
+typedef struct tagIP_SUBCLASS_INFO
+{
+    WNDPROC32 wpOrigProc[4];
+    HWND32    hwndIP[4];
+	IPADDRESS_INFO *infoPtr;
+	WND 	  *wndPtr;
+    UINT32    uRefCount;
+} IP_SUBCLASS_INFO, *LPIP_SUBCLASS_INFO;
 
 
-extern VOID IPADDRESS_Register (VOID);
-extern VOID IPADDRESS_Unregister (VOID);
+extern void IPADDRESS_Register (void);
+extern void IPADDRESS_Unregister (void);
 
 #endif  /* __WINE_IPADDRESS_H */