msctf: Add ITfSource interface to ThreadMgr.
[wine] / dlls / comctl32 / ipaddress.c
index 88ed8fa..15d39f5 100644 (file)
 /*
  * IP Address control
  *
+ * Copyright 2002 Dimitrie O. Paun
+ * Copyright 1999 Chris Morgan<cmorgan@wpi.edu>
+ * Copyright 1999 James Abbatiello<abbeyj@wpi.edu>
  * Copyright 1998, 1999 Eric Kohl
  * Copyright 1998 Alex Priem <alexp@sci.kun.nl>
  *
- * NOTES
-
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  *
- * TODO:
- *    -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.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ *
+ * NOTE
+ * 
+ * This code was audited for completeness against the documented features
+ * of Comctl32.dll version 6.0 on Sep. 9, 2002, by Dimitrie O. Paun.
+ * 
+ * Unless otherwise noted, we believe this code to be complete, as per
+ * the specification mentioned above.
+ * If you discover missing features, or bugs, please note them below.
+ * 
  */
 
 #include <ctype.h>
 #include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
 
+#include "windef.h"
 #include "winbase.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "winnls.h"
 #include "commctrl.h"
-#include "ipaddress.h"
-#include "heap.h"
-#include "debug.h"
-
-DEFAULT_DEBUG_CHANNEL(ipaddress)
+#include "comctl32.h"
+#include "wine/unicode.h"
+#include "wine/debug.h"
 
+WINE_DEFAULT_DEBUG_CHANNEL(ipaddress);
 
-#define IPADDRESS_GetInfoPtr(hwnd) ((IPADDRESS_INFO *)GetWindowLongA (hwnd, 0))
-
-
-static BOOL 
-IPADDRESS_SendNotify (HWND hwnd, UINT command);
-static BOOL 
-IPADDRESS_SendIPAddressNotify (HWND hwnd, UINT field, BYTE newValue);
+typedef struct
+{
+    HWND     EditHwnd;
+    INT      LowerLimit;
+    INT      UpperLimit;
+    WNDPROC  OrigProc;
+} IPPART_INFO;
 
+typedef struct
+{
+    HWND       Self;
+    HWND       Notify;
+    BOOL       Enabled;
+    IPPART_INFO        Part[4];
+} IPADDRESS_INFO;
 
-/* property name of tooltip window handle */
-#define IP_SUBCLASS_PROP "CCIP32SubclassInfo"
+static const WCHAR IP_SUBCLASS_PROP[] = 
+    { 'C', 'C', 'I', 'P', '3', '2', 'S', 'u', 'b', 'c', 'l', 'a', 's', 's', 'I', 'n', 'f', 'o', 0 };
 
+#define POS_DEFAULT    0
+#define POS_LEFT       1
+#define POS_RIGHT      2
+#define POS_SELALL     3
 
 static LRESULT CALLBACK
 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 
+static LRESULT IPADDRESS_Notify (const IPADDRESS_INFO *infoPtr, UINT command)
+{
+    HWND hwnd = infoPtr->Self;
 
+    TRACE("(command=%x)\n", command);
 
+    return SendMessageW (infoPtr->Notify, WM_COMMAND,
+             MAKEWPARAM (GetWindowLongPtrW (hwnd, GWLP_ID), command), (LPARAM)hwnd);
+}
 
-static VOID
-IPADDRESS_Refresh (HWND hwnd, HDC hdc)
+static INT IPADDRESS_IPNotify (const IPADDRESS_INFO *infoPtr, INT field, INT value)
 {
-       RECT rcClient;
-       HBRUSH hbr;
-       COLORREF clr=GetSysColor (COLOR_3DDKSHADOW);
-    int i,x,fieldsize;
+    NMIPADDRESS nmip;
 
-    GetClientRect (hwnd, &rcClient);
-       hbr =  CreateSolidBrush (RGB(255,255,255));
-    DrawEdge (hdc, &rcClient, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
-       FillRect (hdc, &rcClient, hbr);
-    DeleteObject (hbr);
+    TRACE("(field=%x, value=%d)\n", field, value);
 
-       x=rcClient.left;
-       fieldsize=(rcClient.right-rcClient.left) /4;
-
-       for (i=0; i<3; i++) {           /* Should draw text "." here */
-               x+=fieldsize;
-               SetPixel (hdc, x,   13, clr);
-               SetPixel (hdc, x,   14, clr);
-               SetPixel (hdc, x+1, 13, clr);
-               SetPixel (hdc, x+1, 14, clr);
-
-       }
+    nmip.hdr.hwndFrom = infoPtr->Self;
+    nmip.hdr.idFrom   = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
+    nmip.hdr.code     = IPN_FIELDCHANGED;
 
-}
+    nmip.iField = field;
+    nmip.iValue = value;
 
+    SendMessageW (infoPtr->Notify, WM_NOTIFY, nmip.hdr.idFrom, (LPARAM)&nmip);
 
+    TRACE("<-- %d\n", nmip.iValue);
 
+    return nmip.iValue;
+}
 
 
-static LRESULT
-IPADDRESS_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static int IPADDRESS_GetPartIndex(const IPADDRESS_INFO *infoPtr, HWND hwnd)
 {
-    IPADDRESS_INFO *infoPtr;
-       RECT rcClient, edit;
-       int i,fieldsize;
-       LPIP_SUBCLASS_INFO lpipsi;
-       
-
-    infoPtr = (IPADDRESS_INFO *)COMCTL32_Alloc (sizeof(IPADDRESS_INFO));
-    SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
-
-    GetClientRect (hwnd, &rcClient);
+    int i;
 
-       fieldsize=(rcClient.right-rcClient.left) /4;
-
-       edit.top   =rcClient.top+2;
-       edit.bottom=rcClient.bottom-2;
-
-       lpipsi=(LPIP_SUBCLASS_INFO)
-                       GetPropA ((HWND)hwnd, IP_SUBCLASS_PROP);
-       if (lpipsi == NULL)  {
-               lpipsi= (LPIP_SUBCLASS_INFO) COMCTL32_Alloc (sizeof(IP_SUBCLASS_INFO));
-               lpipsi->hwnd = hwnd;
-               lpipsi->uRefCount++;
-               SetPropA ((HWND)hwnd, IP_SUBCLASS_PROP,
-                                       (HANDLE)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]= CreateWindowA ("edit", NULL, 
-                               WS_CHILD | WS_VISIBLE | ES_LEFT,
-                               edit.left, edit.top, edit.right-edit.left, edit.bottom-edit.top,
-                               hwnd, (HMENU) 1, GetWindowLongA (hwnd, GWL_HINSTANCE), NULL);
-               lpipsi->wpOrigProc[i]= (WNDPROC)
-                                       SetWindowLongA (lpipsi->hwndIP[i],GWL_WNDPROC, (LONG)
-                                       IPADDRESS_SubclassProc);
-               SetPropA ((HWND)lpipsi->hwndIP[i], IP_SUBCLASS_PROP,
-                                       (HANDLE)lpipsi);
-       }
+    TRACE("(hwnd=%p)\n", hwnd);
 
-       lpipsi->infoPtr= infoPtr;
+    for (i = 0; i < 4; i++)
+        if (infoPtr->Part[i].EditHwnd == hwnd) return i;
 
-    return 0;
+    ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
+    return -1;
 }
 
 
-static LRESULT
-IPADDRESS_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
 {
-       int i;
-    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd);
-       LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
-            GetPropA ((HWND)hwnd, IP_SUBCLASS_PROP);
-
-       for (i=0; i<=3; i++) {
-               SetWindowLongA ((HWND)lpipsi->hwndIP[i], GWL_WNDPROC,
-                  (LONG)lpipsi->wpOrigProc[i]);
-       }
+    static const WCHAR dotW[] = { '.', 0 };
+    RECT rect, rcPart;
+    POINT pt;
+    COLORREF bgCol, fgCol;
+    int i;
+
+    TRACE("\n");
+
+    GetClientRect (infoPtr->Self, &rect);
+
+    if (infoPtr->Enabled) {
+        bgCol = COLOR_WINDOW;
+        fgCol = COLOR_WINDOWTEXT;
+    } else {
+        bgCol = COLOR_3DFACE;
+        fgCol = COLOR_GRAYTEXT;
+    }
+    
+    FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
+    DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
+    
+    SetBkColor  (hdc, GetSysColor(bgCol));
+    SetTextColor(hdc, GetSysColor(fgCol));
+
+    for (i = 0; i < 3; i++) {
+        GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
+       pt.x = rcPart.right;
+       ScreenToClient(infoPtr->Self, &pt);
+       rect.left = pt.x;
+       GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
+       pt.x = rcPart.left;
+       ScreenToClient(infoPtr->Self, &pt);
+       rect.right = pt.x;
+       DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
+    }
 
-    COMCTL32_Free (infoPtr);
     return 0;
 }
 
 
-static LRESULT
-IPADDRESS_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate)
 {
-    HDC hdc;
+    static const WCHAR EDIT[] = { 'E', 'd', 'i', 't', 0 };
+    IPADDRESS_INFO *infoPtr;
+    RECT rcClient, edit;
+    int i, fieldsize;
+    HFONT hFont, hSysFont;
+    LOGFONTW logFont, logSysFont;
+
+    TRACE("\n");
 
-       TRACE (ipaddress,"\n");
-    hdc = GetDC (hwnd);
-    IPADDRESS_Refresh (hwnd, hdc);
-    ReleaseDC (hwnd, hdc);
+    SetWindowLongW (hwnd, GWL_STYLE,
+                   GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
 
-    IPADDRESS_SendIPAddressNotify (hwnd, 0, 0);  /* FIXME: should use -1 */
-    IPADDRESS_SendNotify (hwnd, EN_KILLFOCUS);       
-    InvalidateRect (hwnd, NULL, TRUE);
+    infoPtr = Alloc (sizeof(IPADDRESS_INFO));
+    if (!infoPtr) return -1;
+    SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
+
+    GetClientRect (hwnd, &rcClient);
+
+    fieldsize = (rcClient.right - rcClient.left) / 4;
+
+    edit.top    = rcClient.top + 2;
+    edit.bottom = rcClient.bottom - 2;
+
+    infoPtr->Self = hwnd;
+    infoPtr->Enabled = TRUE;
+    infoPtr->Notify = lpCreate->hwndParent;
+
+    hSysFont = GetStockObject(ANSI_VAR_FONT);
+    GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont);
+    SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
+    strcpyW(logFont.lfFaceName, logSysFont.lfFaceName);
+    hFont = CreateFontIndirectW(&logFont);
+
+    for (i = 0; i < 4; i++) {
+       IPPART_INFO* part = &infoPtr->Part[i];
+
+       part->LowerLimit = 0;
+       part->UpperLimit = 255;
+        edit.left = rcClient.left + i*fieldsize + 6;
+        edit.right = rcClient.left + (i+1)*fieldsize - 2;
+        part->EditHwnd =
+               CreateWindowW (EDIT, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
+                               edit.left, edit.top, edit.right - edit.left,
+                              edit.bottom - edit.top, hwnd, (HMENU) 1,
+                              (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
+        SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE);
+       SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
+        part->OrigProc = (WNDPROC)
+               SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
+                               (DWORD_PTR)IPADDRESS_SubclassProc);
+        EnableWindow(part->EditHwnd, infoPtr->Enabled);
+    }
 
     return 0;
 }
 
 
-static LRESULT
-IPADDRESS_Paint (HWND hwnd, WPARAM wParam)
+static LRESULT IPADDRESS_Destroy (IPADDRESS_INFO *infoPtr)
 {
-    HDC hdc;
-    PAINTSTRUCT ps;
+    int i;
+
+    TRACE("\n");
+
+    for (i = 0; i < 4; i++) {
+       IPPART_INFO* part = &infoPtr->Part[i];
+        SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)part->OrigProc);
+    }
 
-    hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
-    IPADDRESS_Refresh (hwnd, hdc);
-    if(!wParam)
-       EndPaint (hwnd, &ps);
+    SetWindowLongPtrW (infoPtr->Self, 0, 0);
+    Free (infoPtr);
     return 0;
 }
 
 
-static LRESULT
-IPADDRESS_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static LRESULT IPADDRESS_Enable (IPADDRESS_INFO *infoPtr, BOOL enabled)
 {
-    HDC hdc;
+    int i;
 
-       TRACE (ipaddress,"\n");
+    infoPtr->Enabled = enabled;
 
-    hdc = GetDC (hwnd);
-    IPADDRESS_Refresh (hwnd, hdc);
-    ReleaseDC (hwnd, hdc);
+    for (i = 0; i < 4; i++)
+        EnableWindow(infoPtr->Part[i].EditHwnd, enabled);
 
+    InvalidateRgn(infoPtr->Self, NULL, FALSE);
     return 0;
 }
 
 
-static LRESULT
-IPADDRESS_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static LRESULT IPADDRESS_Paint (const IPADDRESS_INFO *infoPtr, HDC hdc)
 {
-    /* IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd); */
-       TRACE (ipaddress,"\n");
-    return 0;
-}
+    PAINTSTRUCT ps;
 
+    TRACE("\n");
 
-static BOOL
-IPADDRESS_SendNotify (HWND hwnd, UINT command)
+    if (hdc) return IPADDRESS_Draw (infoPtr, hdc);
 
-{
-    TRACE (ipaddress, "%x\n",command);
-    return (BOOL)SendMessageA (GetParent (hwnd), WM_COMMAND,
-              MAKEWPARAM (GetWindowLongA (hwnd, GWL_ID),command), (LPARAM)hwnd);
+    hdc = BeginPaint (infoPtr->Self, &ps);
+    IPADDRESS_Draw (infoPtr, hdc);
+    EndPaint (infoPtr->Self, &ps);
+    return 0;
 }
 
 
-static BOOL
-IPADDRESS_SendIPAddressNotify (HWND hwnd, UINT field, BYTE newValue)
+static BOOL IPADDRESS_IsBlank (const IPADDRESS_INFO *infoPtr)
 {
-       NMIPADDRESS nmip;
+    int i;
 
-    TRACE (ipaddress, "%x %x\n",field,newValue);
-    nmip.hdr.hwndFrom = hwnd;
-    nmip.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
-    nmip.hdr.code     = IPN_FIELDCHANGED;
+    TRACE("\n");
 
-       nmip.iField=field;
-       nmip.iValue=newValue;
+    for (i = 0; i < 4; i++)
+        if (GetWindowTextLengthW (infoPtr->Part[i].EditHwnd)) return FALSE;
 
-    return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
-                               (WPARAM)nmip.hdr.idFrom, (LPARAM)&nmip);
+    return TRUE;
 }
 
 
-
-
-static LRESULT
-IPADDRESS_ClearAddress (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static int IPADDRESS_GetAddress (const IPADDRESS_INFO *infoPtr, LPDWORD ip_address)
 {
-       int i;
-       HDC hdc;
-       char buf[1];
-       LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
-            GetPropA ((HWND)hwnd,IP_SUBCLASS_PROP);
-
-       TRACE (ipaddress,"\n");
-
-       buf[0]=0;
-       for (i=0; i<=3; i++) 
-               SetWindowTextA (lpipsi->hwndIP[i],buf);
-       
-    hdc = GetDC (hwnd);
-    IPADDRESS_Refresh (hwnd, hdc);
-    ReleaseDC (hwnd, hdc);
-       
-       return 0;
+    WCHAR field[5];
+    int i, invalid = 0;
+    DWORD ip_addr = 0;
+
+    TRACE("\n");
+
+    for (i = 0; i < 4; i++) {
+        ip_addr *= 256;
+        if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
+           ip_addr += atolW(field);
+       else
+           invalid++;
+    }
+    *ip_address = ip_addr;
+
+    return 4 - invalid;
 }
 
-static LRESULT
-IPADDRESS_IsBlank (HWND hwnd, WPARAM wParam, LPARAM lParam)
+
+static BOOL IPADDRESS_SetRange (IPADDRESS_INFO *infoPtr, int index, WORD range)
 {
- int i;
- char buf[20];
- LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
-            GetPropA ((HWND)hwnd, IP_SUBCLASS_PROP);
+    TRACE("\n");
 
TRACE (ipaddress,"\n");
   if ( (index < 0) || (index > 3) ) return FALSE;
 
- for (i=0; i<=3; i++) {
-               GetWindowTextA (lpipsi->hwndIP[i],buf,5);
-       if (buf[0])
-           return 0;
-       }
+    infoPtr->Part[index].LowerLimit = range & 0xFF;
+    infoPtr->Part[index].UpperLimit = (range >> 8)  & 0xFF;
 
return 1;
   return TRUE;
 }
 
-static LRESULT
-IPADDRESS_GetAddress (HWND hwnd, WPARAM wParam, LPARAM lParam)
+
+static void IPADDRESS_ClearAddress (const IPADDRESS_INFO *infoPtr)
 {
- char field[20];
- int i,valid,fieldvalue;
- DWORD ip_addr;
- IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd);
- LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
-            GetPropA ((HWND)hwnd, IP_SUBCLASS_PROP);
-
- TRACE (ipaddress,"\n");
-
- valid=0;
- ip_addr=0;
- for (i=0; i<=3; i++) {
-               GetWindowTextA (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++;
-               }
- }
+    WCHAR nil[1] = { 0 };
+    int i;
 
*(LPDWORD) lParam=ip_addr;
   TRACE("\n");
 
- return valid;
+    for (i = 0; i < 4; i++)
+        SetWindowTextW (infoPtr->Part[i].EditHwnd, nil);
 }
 
 
-static LRESULT
-IPADDRESS_SetRange (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static LRESULT IPADDRESS_SetAddress (const IPADDRESS_INFO *infoPtr, DWORD ip_address)
 {
-    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd);
-       INT index;
-       
-       TRACE (ipaddress,"\n");
-
-       index=(INT) wParam;
-       if ((index<0) || (index>3)) return 0;
+    WCHAR buf[20];
+    static const WCHAR fmt[] = { '%', 'd', 0 };
+    int i;
+
+    TRACE("\n");
+
+    for (i = 3; i >= 0; i--) {
+       const IPPART_INFO* part = &infoPtr->Part[i];
+        int value = ip_address & 0xff;
+       if ( (value >= part->LowerLimit) && (value <= part->UpperLimit) ) {
+           wsprintfW (buf, fmt, value);
+           SetWindowTextW (part->EditHwnd, buf);
+           IPADDRESS_Notify (infoPtr, EN_CHANGE);
+        }
+        ip_address >>= 8;
+    }
 
-       infoPtr->LowerLimit[index]=lParam & 0xff;
-       infoPtr->UpperLimit[index]=(lParam >>8)  & 0xff;
-       return 1;
+    return TRUE;
 }
 
-static LRESULT
-IPADDRESS_SetAddress (HWND hwnd, WPARAM wParam, LPARAM lParam)
+
+static void IPADDRESS_SetFocusToField (const IPADDRESS_INFO *infoPtr, INT index)
 {
-    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd);
-       HDC hdc;
-       LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
-            GetPropA ((HWND)hwnd, 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);
-                        SetWindowTextA (lpipsi->hwndIP[i],buf);
-                        IPADDRESS_SendNotify (hwnd, EN_CHANGE);
-               }
-               ip_address/=256;
-       }
+    TRACE("(index=%d)\n", index);
 
-    hdc = GetDC (hwnd);                /* & send notifications */
-    IPADDRESS_Refresh (hwnd, hdc);
-    ReleaseDC (hwnd, hdc);
+    if (index > 3 || index < 0) index=0;
 
return TRUE;
   SetFocus (infoPtr->Part[index].EditHwnd);
 }
 
 
-
-
-static LRESULT
-IPADDRESS_SetFocusToField (HWND hwnd, WPARAM wParam, LPARAM lParam)
+static BOOL IPADDRESS_ConstrainField (const IPADDRESS_INFO *infoPtr, int currentfield)
 {
-    /* IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd); */
-       LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
-            GetPropA ((HWND)hwnd, IP_SUBCLASS_PROP);
-       INT index;
-
-       index=(INT) wParam;
-       TRACE (ipaddress," %d\n", index);
-       if ((index<0) || (index>3)) return 0;
-       
-       SetFocus (lpipsi->hwndIP[index]);
-       
-    return 1;
-}
+    const IPPART_INFO *part = &infoPtr->Part[currentfield];
+    WCHAR field[10];
+    static const WCHAR fmt[] = { '%', 'd', 0 };
+    int curValue, newValue;
 
+    TRACE("(currentfield=%d)\n", currentfield);
 
-static LRESULT
-IPADDRESS_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
-{
-    TRACE (ipaddress, "\n");
+    if (currentfield < 0 || currentfield > 3) return FALSE;
 
-       SetFocus (hwnd);
-       IPADDRESS_SendNotify (hwnd, EN_SETFOCUS);
-       IPADDRESS_SetFocusToField (hwnd, 0, 0);
+    if (!GetWindowTextW (part->EditHwnd, field, 4)) return FALSE;
 
-       return TRUE;
-}
+    curValue = atoiW(field);
+    TRACE("  curValue=%d\n", curValue);
 
+    newValue = IPADDRESS_IPNotify(infoPtr, currentfield, curValue);
+    TRACE("  newValue=%d\n", newValue);
 
+    if (newValue < part->LowerLimit) newValue = part->LowerLimit;
+    if (newValue > part->UpperLimit) newValue = part->UpperLimit;
 
-/* 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
-*/
-   
+    if (newValue == curValue) return FALSE;
 
+    wsprintfW (field, fmt, newValue);
+    TRACE("  field=%s\n", debugstr_w(field));
+    return SetWindowTextW (part->EditHwnd, field);
+}
 
 
-static int
-IPADDRESS_GotoNextField (LPIP_SUBCLASS_INFO lpipsi, int currentfield)
+static BOOL IPADDRESS_GotoNextField (const IPADDRESS_INFO *infoPtr, int cur, int sel)
 {
- int newField,fieldvalue;
- char field[20];
- IPADDRESS_INFO *infoPtr=lpipsi->infoPtr;
-
- TRACE (ipaddress,"\n");
- GetWindowTextA (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);
-               SetWindowTextA (lpipsi->hwndIP[currentfield], field);
-               return 1;
+    TRACE("\n");
+
+    if(cur >= -1 && cur < 4) {
+       IPADDRESS_ConstrainField(infoPtr, cur);
+
+       if(cur < 3) {
+           const IPPART_INFO *next = &infoPtr->Part[cur + 1];
+           int start = 0, end = 0;
+            SetFocus (next->EditHwnd);
+           if (sel != POS_DEFAULT) {
+               if (sel == POS_RIGHT)
+                   start = end = GetWindowTextLengthW(next->EditHwnd);
+               else if (sel == POS_SELALL)
+                   end = -1;
+               SendMessageW(next->EditHwnd, EM_SETSEL, start, end);
+           }
+           return TRUE;
        }
- }
 
- if (currentfield<3) 
-               SetFocus (lpipsi->hwndIP[currentfield+1]);
- return 0;
+    }
+    return FALSE;
 }
 
 
+/*
+ * period: move and select the text in the next field to the right if
+ *         the current field is not empty(l!=0), we are not in the
+ *         left most position, and nothing is selected(startsel==endsel)
+ *
+ * spacebar: same behavior as period
+ *
+ * alpha characters: completely ignored
+ *
+ * digits: accepted when field text length < 2 ignored otherwise.
+ *         when 3 numbers have been entered into the field the value
+ *         of the field is checked, if the field value exceeds the
+ *         maximum value and is changed the field remains the current
+ *         field, otherwise focus moves to the field to the right
+ *
+ * tab: change focus from the current ipaddress control to the next
+ *      control in the tab order
+ *
+ * right arrow: move to the field on the right to the left most
+ *              position in that field if no text is selected,
+ *              we are in the right most position in the field,
+ *              we are not in the right most field
+ *
+ * left arrow: move to the field on the left to the right most
+ *             position in that field if no text is selected,
+ *             we are in the left most position in the current field
+ *             and we are not in the left most field
+ *
+ * backspace: delete the character to the left of the cursor position,
+ *            if none are present move to the field on the left if
+ *            we are not in the left most field and delete the right
+ *            most digit in that field while keeping the cursor
+ *            on the right side of the field
+ */
 LRESULT CALLBACK
 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
- int i,l,index;
- IPADDRESS_INFO *infoPtr;
- LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
-            GetPropA ((HWND)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) {
-                               HWND pwnd;
-                               int shift;
-                               shift = GetKeyState(VK_SHIFT) & 0x8000;
-                               if (shift)
-                                       pwnd=GetNextDlgTabItem (GetParent (hwnd), 0, TRUE);
-                               else
-                                       pwnd=GetNextDlgTabItem (GetParent (hwnd), 0, FALSE);
-                               if (pwnd) SetFocus (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=GetWindowTextLengthA (lpipsi->hwndIP[index]);
-                               if (l==3) 
-                                       if (IPADDRESS_GotoNextField (lpipsi,index)) {
-                                               wParam=0;
-                                               lParam=0;
-                                       }
-                               break;
-                       }
-       
-                       wParam=0;
-                       lParam=0;
-                       break;
+    HWND Self = GetPropW (hwnd, IP_SUBCLASS_PROP);
+    IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (Self, 0);
+    CHAR c = (CHAR)wParam;
+    INT index, len = 0, startsel, endsel;
+    IPPART_INFO *part;
+
+    TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
+
+    if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
+    part = &infoPtr->Part[index];
+
+    if (uMsg == WM_CHAR || uMsg == WM_KEYDOWN) {
+       len = GetWindowTextLengthW (hwnd);
+       SendMessageW(hwnd, EM_GETSEL, (WPARAM)&startsel, (LPARAM)&endsel);
+    }
+    switch (uMsg) {
+       case WM_CHAR:
+           if(isdigit(c)) {
+               if(len == 2 && startsel==endsel && endsel==len) {
+                   /* process the digit press before we check the field */
+                   int return_val = CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
+
+                   /* if the field value was changed stay at the current field */
+                   if(!IPADDRESS_ConstrainField(infoPtr, index))
+                       IPADDRESS_GotoNextField (infoPtr, index, POS_DEFAULT);
+
+                   return return_val;
+               } else if (len == 3 && startsel==endsel && endsel==len)
+                   IPADDRESS_GotoNextField (infoPtr, index, POS_SELALL);
+               else if (len < 3) break;
+           } else if(c == '.' || c == ' ') {
+               if(len && startsel==endsel && startsel != 0) {
+                   IPADDRESS_GotoNextField(infoPtr, index, POS_SELALL);
                }
- }
+           } else if (c == VK_BACK) break;
+           return 0;
 
- return CallWindowProcA (lpipsi->wpOrigProc[index], hwnd, uMsg, wParam, lParam);
+       case WM_KEYDOWN:
+           switch(c) {
+               case VK_RIGHT:
+                   if(startsel==endsel && startsel==len) {
+                       IPADDRESS_GotoNextField(infoPtr, index, POS_LEFT);
+                       return 0;
+                   }
+                   break;
+               case VK_LEFT:
+                   if(startsel==0 && startsel==endsel && index > 0) {
+                       IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
+                       return 0;
+                   }
+                   break;
+               case VK_BACK:
+                   if(startsel==endsel && startsel==0 && index > 0) {
+                       IPPART_INFO *prev = &infoPtr->Part[index-1];
+                       WCHAR val[10];
+
+                       if(GetWindowTextW(prev->EditHwnd, val, 5)) {
+                           val[lstrlenW(val) - 1] = 0;
+                           SetWindowTextW(prev->EditHwnd, val);
+                       }
+
+                       IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
+                       return 0;
+                   }
+                   break;
+           }
+           break;
+       case WM_KILLFOCUS:
+           if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
+               IPADDRESS_Notify(infoPtr, EN_KILLFOCUS);
+           break;
+       case WM_SETFOCUS:
+           if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
+               IPADDRESS_Notify(infoPtr, EN_SETFOCUS);
+           break;
+    }
+    return CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
 }
 
-LRESULT WINAPI
+
+static LRESULT WINAPI
 IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
-    switch (uMsg)
-    {
-       case IPM_CLEARADDRESS:
-               return IPADDRESS_ClearAddress (hwnd, wParam, lParam);
+    IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (hwnd, 0);
 
-       case IPM_SETADDRESS:
-           return IPADDRESS_SetAddress (hwnd, wParam, lParam);
+    TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 
-       case IPM_GETADDRESS:
-           return IPADDRESS_GetAddress (hwnd, wParam, lParam);
+    if (!infoPtr && (uMsg != WM_CREATE))
+        return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 
-       case IPM_SETRANGE:
-           return IPADDRESS_SetRange (hwnd, wParam, lParam);
+    switch (uMsg)
+    {
+       case WM_CREATE:
+           return IPADDRESS_Create (hwnd, (LPCREATESTRUCTA)lParam);
 
-       case IPM_SETFOCUS:
-           return IPADDRESS_SetFocusToField (hwnd, wParam, lParam);
+       case WM_DESTROY:
+           return IPADDRESS_Destroy (infoPtr);
 
-       case IPM_ISBLANK:
-               return IPADDRESS_IsBlank (hwnd, wParam, lParam);
+       case WM_ENABLE:
+           return IPADDRESS_Enable (infoPtr, (BOOL)wParam);
 
-       case WM_CREATE:
-           return IPADDRESS_Create (hwnd, wParam, lParam);
+       case WM_PAINT:
+           return IPADDRESS_Paint (infoPtr, (HDC)wParam);
 
-       case WM_DESTROY:
-           return IPADDRESS_Destroy (hwnd, wParam, lParam);
+       case WM_COMMAND:
+           switch(wParam >> 16) {
+               case EN_CHANGE:
+                   IPADDRESS_Notify(infoPtr, EN_CHANGE);
+                   break;
+               case EN_KILLFOCUS:
+                   IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
+                   break;
+           }
+           break;
 
-       case WM_GETDLGCODE:
-           return DLGC_WANTARROWS | DLGC_WANTCHARS;
+        case IPM_CLEARADDRESS:
+            IPADDRESS_ClearAddress (infoPtr);
+           break;
 
-       case WM_KILLFOCUS:
-           return IPADDRESS_KillFocus (hwnd, wParam, lParam);
+        case IPM_SETADDRESS:
+            return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);
 
-       case WM_LBUTTONDOWN:
-        return IPADDRESS_LButtonDown (hwnd, wParam, lParam);
+        case IPM_GETADDRESS:
+           return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);
 
-       case WM_PAINT:
-           return IPADDRESS_Paint (hwnd, wParam);
+       case IPM_SETRANGE:
+           return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);
 
-       case WM_SETFOCUS:
-           return IPADDRESS_SetFocus (hwnd, wParam, lParam);
+       case IPM_SETFOCUS:
+           IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
+           break;
 
-       case WM_SIZE:
-           return IPADDRESS_Size (hwnd, wParam, lParam);
+       case IPM_ISBLANK:
+           return IPADDRESS_IsBlank (infoPtr);
 
        default:
-           if (uMsg >= WM_USER)
-               ERR (ipaddress, "unknown msg %04x wp=%08x lp=%08lx\n",
-                    uMsg, wParam, lParam);
-           return DefWindowProcA (hwnd, uMsg, wParam, lParam);
+           if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
+               ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
+           return DefWindowProcW (hwnd, uMsg, wParam, lParam);
     }
     return 0;
 }
 
 
-void
-IPADDRESS_Register (void)
+void IPADDRESS_Register (void)
 {
-    WNDCLASSA wndClass;
-
-    if (GlobalFindAtomA (WC_IPADDRESSA)) return;
+    WNDCLASSW wndClass;
 
-    ZeroMemory (&wndClass, sizeof(WNDCLASSA));
-    wndClass.style         = CS_GLOBALCLASS;
-    wndClass.lpfnWndProc   = (WNDPROC)IPADDRESS_WindowProc;
+    ZeroMemory (&wndClass, sizeof(WNDCLASSW));
+    wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
+    wndClass.lpfnWndProc   = IPADDRESS_WindowProc;
     wndClass.cbClsExtra    = 0;
     wndClass.cbWndExtra    = sizeof(IPADDRESS_INFO *);
-    wndClass.hCursor       = LoadCursorA (0, IDC_ARROWA);
-    wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
-    wndClass.lpszClassName = WC_IPADDRESSA;
-    RegisterClassA (&wndClass);
+    wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_IBEAM);
+    wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
+    wndClass.lpszClassName = WC_IPADDRESSW;
+
+    RegisterClassW (&wndClass);
 }
 
-VOID
-IPADDRESS_Unregister (VOID)
+
+void IPADDRESS_Unregister (void)
 {
-    if (GlobalFindAtomA (WC_IPADDRESSA))
-    UnregisterClassA (WC_IPADDRESSA, (HINSTANCE)NULL);
+    UnregisterClassW (WC_IPADDRESSW, NULL);
 }
-