dll/win32/comctl32/ipaddress.c

   1 /*
   2  * IP Address control
   3  *
   4  * Copyright 2002 Dimitrie O. Paun
   5  * Copyright 1999 Chris Morgan<cmorgan@wpi.edu>
   6  * Copyright 1999 James Abbatiello<abbeyj@wpi.edu>
   7  * Copyright 1998, 1999 Eric Kohl
   8  * Copyright 1998 Alex Priem <alexp@sci.kun.nl>
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  *
  24  * NOTE
  25  *
  26  * This code was audited for completeness against the documented features
  27  * of Comctl32.dll version 6.0 on Sep. 9, 2002, by Dimitrie O. Paun.
  28  *
  29  * Unless otherwise noted, we believe this code to be complete, as per
  30  * the specification mentioned above.
  31  * If you discover missing features, or bugs, please note them below.
  32  *
  33  */
  34
  35 #include "comctl32.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(ipaddress);
  38
  39 typedef struct
  40 {
  41     HWND     EditHwnd;
  42     INT      LowerLimit;
  43     INT      UpperLimit;
  44     WNDPROC  OrigProc;
  45 } IPPART_INFO;
  46
  47 typedef struct
  48 {
  49     HWND        Self;
  50     HWND        Notify;
  51     BOOL        Enabled;
  52     IPPART_INFO Part[4];
  53 } IPADDRESS_INFO;
  54
  55 static const WCHAR IP_SUBCLASS_PROP[] =
  56     { 'C', 'C', 'I', 'P', '3', '2', 'S', 'u', 'b', 'c', 'l', 'a', 's', 's', 'I', 'n', 'f', 'o', 0 };
  57
  58 #define POS_DEFAULT     0
  59 #define POS_LEFT        1
  60 #define POS_RIGHT       2
  61 #define POS_SELALL      3
  62
  63 static LRESULT CALLBACK
  64 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  65
  66 static void IPADDRESS_UpdateText (const IPADDRESS_INFO *infoPtr)
  67 {
  68     static const WCHAR zero[] = {'0', 0};
  69     static const WCHAR dot[]  = {'.', 0};
  70     WCHAR field[4];
  71     WCHAR ip[16];
  72     INT i;
  73
  74     ip[0] = 0;
  75
  76     for (i = 0; i < 4; i++) {
  77         if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
  78             strcatW(ip, field);
  79         else
  80             /* empty edit treated as zero */
  81             strcatW(ip, zero);
  82         if (i != 3)
  83             strcatW(ip, dot);
  84     }
  85
  86     SetWindowTextW(infoPtr->Self, ip);
  87 }
  88
  89 static LRESULT IPADDRESS_Notify (const IPADDRESS_INFO *infoPtr, UINT command)
  90 {
  91     HWND hwnd = infoPtr->Self;
  92
  93     TRACE("(command=%x)\n", command);
  94
  95     return SendMessageW (infoPtr->Notify, WM_COMMAND,
  96              MAKEWPARAM (GetWindowLongPtrW (hwnd, GWLP_ID), command), (LPARAM)hwnd);
  97 }
  98
  99 static INT IPADDRESS_IPNotify (const IPADDRESS_INFO *infoPtr, INT field, INT value)
 100 {
 101     NMIPADDRESS nmip;
 102
 103     TRACE("(field=%x, value=%d)\n", field, value);
 104
 105     nmip.hdr.hwndFrom = infoPtr->Self;
 106     nmip.hdr.idFrom   = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
 107     nmip.hdr.code     = IPN_FIELDCHANGED;
 108
 109     nmip.iField = field;
 110     nmip.iValue = value;
 111
 112     SendMessageW (infoPtr->Notify, WM_NOTIFY, nmip.hdr.idFrom, (LPARAM)&nmip);
 113
 114     TRACE("<-- %d\n", nmip.iValue);
 115
 116     return nmip.iValue;
 117 }
 118
 119
 120 static int IPADDRESS_GetPartIndex(const IPADDRESS_INFO *infoPtr, HWND hwnd)
 121 {
 122     int i;
 123
 124     TRACE("(hwnd=%p)\n", hwnd);
 125
 126     for (i = 0; i < 4; i++)
 127         if (infoPtr->Part[i].EditHwnd == hwnd) return i;
 128
 129     ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
 130     return -1;
 131 }
 132
 133
 134 static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
 135 {
 136     static const WCHAR dotW[] = { '.', 0 };
 137     RECT rect, rcPart;
 138     COLORREF bgCol, fgCol;
 139     HTHEME theme;
 140     int i, state = ETS_NORMAL;
 141
 142     TRACE("\n");
 143
 144     GetClientRect (infoPtr->Self, &rect);
 145
 146     theme = OpenThemeData(infoPtr->Self, WC_EDITW);
 147
 148     if (theme) {
 149         DWORD dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
 150
 151         if (!infoPtr->Enabled)
 152             state = ETS_DISABLED;
 153         else if (dwStyle & ES_READONLY)
 154             state = ETS_READONLY;
 155         else if (GetFocus() == infoPtr->Self)
 156             state = ETS_FOCUSED;
 157
 158         GetThemeColor(theme, EP_EDITTEXT, state, TMT_FILLCOLOR, &bgCol);
 159         GetThemeColor(theme, EP_EDITTEXT, state, TMT_TEXTCOLOR, &fgCol);
 160
 161         if (IsThemeBackgroundPartiallyTransparent (theme, EP_EDITTEXT, state))
 162             DrawThemeParentBackground(infoPtr->Self, hdc, &rect);
 163         DrawThemeBackground (theme, hdc, EP_EDITTEXT, state, &rect, 0);
 164     } else {
 165         if (infoPtr->Enabled) {
 166             bgCol = comctl32_color.clrWindow;
 167             fgCol = comctl32_color.clrWindowText;
 168         } else {
 169             bgCol = comctl32_color.clr3dFace;
 170             fgCol = comctl32_color.clrGrayText;
 171         }
 172
 173         FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
 174         DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
 175     }
 176
 177     SetBkColor  (hdc, bgCol);
 178     SetTextColor(hdc, fgCol);
 179
 180     for (i = 0; i < 3; i++) {
 181         GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
 182         MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
 183         rect.left = rcPart.right;
 184         GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
 185         MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
 186         rect.right = rcPart.left;
 187
 188         if (theme)
 189             DrawThemeText(theme, hdc, EP_EDITTEXT, state, dotW, 1, DT_SINGLELINE | DT_CENTER | DT_BOTTOM, 0, &rect);
 190         else
 191             DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
 192     }
 193
 194     if (theme)
 195         CloseThemeData(theme);
 196
 197     return 0;
 198 }
 199
 200
 201 static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate)
 202 {
 203     IPADDRESS_INFO *infoPtr;
 204     RECT rcClient, edit;
 205     int i, fieldsize;
 206     HFONT hFont, hSysFont;
 207     LOGFONTW logFont, logSysFont;
 208
 209     TRACE("\n");
 210
 211     SetWindowLongW (hwnd, GWL_STYLE,
 212                     GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
 213
 214     infoPtr = Alloc (sizeof(IPADDRESS_INFO));
 215     if (!infoPtr) return -1;
 216     SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
 217
 218     GetClientRect (hwnd, &rcClient);
 219
 220     fieldsize = (rcClient.right - rcClient.left) / 4;
 221
 222     edit.top    = rcClient.top + 2;
 223     edit.bottom = rcClient.bottom - 2;
 224
 225     infoPtr->Self = hwnd;
 226     infoPtr->Enabled = TRUE;
 227     infoPtr->Notify = lpCreate->hwndParent;
 228
 229     hSysFont = GetStockObject(ANSI_VAR_FONT);
 230     GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont);
 231     SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
 232     strcpyW(logFont.lfFaceName, logSysFont.lfFaceName);
 233     hFont = CreateFontIndirectW(&logFont);
 234
 235     for (i = 0; i < 4; i++) {
 236         IPPART_INFO* part = &infoPtr->Part[i];
 237
 238         part->LowerLimit = 0;
 239         part->UpperLimit = 255;
 240         edit.left = rcClient.left + i*fieldsize + 6;
 241         edit.right = rcClient.left + (i+1)*fieldsize - 2;
 242         part->EditHwnd =
 243                 CreateWindowW (WC_EDITW, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
 244                                edit.left, edit.top, edit.right - edit.left,
 245                                edit.bottom - edit.top, hwnd, (HMENU) 1,
 246                                (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
 247         SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE);
 248         SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
 249         part->OrigProc = (WNDPROC)
 250                 SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
 251                                 (DWORD_PTR)IPADDRESS_SubclassProc);
 252         EnableWindow(part->EditHwnd, infoPtr->Enabled);
 253     }
 254
 255     IPADDRESS_UpdateText (infoPtr);
 256
 257     return 0;
 258 }
 259
 260
 261 static LRESULT IPADDRESS_Destroy (IPADDRESS_INFO *infoPtr)
 262 {
 263     int i;
 264
 265     TRACE("\n");
 266
 267     for (i = 0; i < 4; i++) {
 268         IPPART_INFO* part = &infoPtr->Part[i];
 269         SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)part->OrigProc);
 270     }
 271
 272     SetWindowLongPtrW (infoPtr->Self, 0, 0);
 273     Free (infoPtr);
 274     return 0;
 275 }
 276
 277
 278 static LRESULT IPADDRESS_Enable (IPADDRESS_INFO *infoPtr, BOOL enabled)
 279 {
 280     int i;
 281
 282     infoPtr->Enabled = enabled;
 283
 284     for (i = 0; i < 4; i++)
 285         EnableWindow(infoPtr->Part[i].EditHwnd, enabled);
 286
 287     InvalidateRgn(infoPtr->Self, NULL, FALSE);
 288     return 0;
 289 }
 290
 291
 292 static LRESULT IPADDRESS_Paint (const IPADDRESS_INFO *infoPtr, HDC hdc)
 293 {
 294     PAINTSTRUCT ps;
 295
 296     TRACE("\n");
 297
 298     if (hdc) return IPADDRESS_Draw (infoPtr, hdc);
 299
 300     hdc = BeginPaint (infoPtr->Self, &ps);
 301     IPADDRESS_Draw (infoPtr, hdc);
 302     EndPaint (infoPtr->Self, &ps);
 303     return 0;
 304 }
 305
 306
 307 static BOOL IPADDRESS_IsBlank (const IPADDRESS_INFO *infoPtr)
 308 {
 309     int i;
 310
 311     TRACE("\n");
 312
 313     for (i = 0; i < 4; i++)
 314         if (GetWindowTextLengthW (infoPtr->Part[i].EditHwnd)) return FALSE;
 315
 316     return TRUE;
 317 }
 318
 319
 320 static int IPADDRESS_GetAddress (const IPADDRESS_INFO *infoPtr, LPDWORD ip_address)
 321 {
 322     WCHAR field[5];
 323     int i, invalid = 0;
 324     DWORD ip_addr = 0;
 325
 326     TRACE("\n");
 327
 328     for (i = 0; i < 4; i++) {
 329         ip_addr *= 256;
 330         if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
 331             ip_addr += atolW(field);
 332         else
 333             invalid++;
 334     }
 335     *ip_address = ip_addr;
 336
 337     return 4 - invalid;
 338 }
 339
 340
 341 static BOOL IPADDRESS_SetRange (IPADDRESS_INFO *infoPtr, int index, WORD range)
 342 {
 343     TRACE("\n");
 344
 345     if ( (index < 0) || (index > 3) ) return FALSE;
 346
 347     infoPtr->Part[index].LowerLimit = range & 0xFF;
 348     infoPtr->Part[index].UpperLimit = (range >> 8)  & 0xFF;
 349
 350     return TRUE;
 351 }
 352
 353
 354 static void IPADDRESS_ClearAddress (const IPADDRESS_INFO *infoPtr)
 355 {
 356     static const WCHAR nil[] = { 0 };
 357     int i;
 358
 359     TRACE("\n");
 360
 361     for (i = 0; i < 4; i++)
 362         SetWindowTextW (infoPtr->Part[i].EditHwnd, nil);
 363 }
 364
 365
 366 static LRESULT IPADDRESS_SetAddress (const IPADDRESS_INFO *infoPtr, DWORD ip_address)
 367 {
 368     WCHAR buf[20];
 369     static const WCHAR fmt[] = { '%', 'd', 0 };
 370     int i;
 371
 372     TRACE("\n");
 373
 374     for (i = 3; i >= 0; i--) {
 375         const IPPART_INFO* part = &infoPtr->Part[i];
 376         int value = ip_address & 0xff;
 377         if ( (value >= part->LowerLimit) && (value <= part->UpperLimit) ) {
 378             wsprintfW (buf, fmt, value);
 379             SetWindowTextW (part->EditHwnd, buf);
 380             IPADDRESS_Notify (infoPtr, EN_CHANGE);
 381         }
 382         ip_address >>= 8;
 383     }
 384
 385     return TRUE;
 386 }
 387
 388
 389 static void IPADDRESS_SetFocusToField (const IPADDRESS_INFO *infoPtr, INT index)
 390 {
 391     TRACE("(index=%d)\n", index);
 392
 393     if (index > 3 || index < 0) index=0;
 394
 395     SetFocus (infoPtr->Part[index].EditHwnd);
 396 }
 397
 398
 399 static BOOL IPADDRESS_ConstrainField (const IPADDRESS_INFO *infoPtr, int currentfield)
 400 {
 401     static const WCHAR fmt[] = { '%', 'd', 0 };
 402     const IPPART_INFO *part;
 403     int curValue, newValue;
 404     WCHAR field[10];
 405
 406     TRACE("(currentfield=%d)\n", currentfield);
 407
 408     if (currentfield < 0 || currentfield > 3) return FALSE;
 409
 410     part = &infoPtr->Part[currentfield];
 411     if (!GetWindowTextW (part->EditHwnd, field, 4)) return FALSE;
 412
 413     curValue = atoiW(field);
 414     TRACE("  curValue=%d\n", curValue);
 415
 416     newValue = IPADDRESS_IPNotify(infoPtr, currentfield, curValue);
 417     TRACE("  newValue=%d\n", newValue);
 418
 419     if (newValue < part->LowerLimit) newValue = part->LowerLimit;
 420     if (newValue > part->UpperLimit) newValue = part->UpperLimit;
 421
 422     if (newValue == curValue) return FALSE;
 423
 424     wsprintfW (field, fmt, newValue);
 425     TRACE("  field=%s\n", debugstr_w(field));
 426     return SetWindowTextW (part->EditHwnd, field);
 427 }
 428
 429
 430 static BOOL IPADDRESS_GotoNextField (const IPADDRESS_INFO *infoPtr, int cur, int sel)
 431 {
 432     TRACE("\n");
 433
 434     if(cur >= -1 && cur < 4) {
 435         IPADDRESS_ConstrainField(infoPtr, cur);
 436
 437         if(cur < 3) {
 438             const IPPART_INFO *next = &infoPtr->Part[cur + 1];
 439             int start = 0, end = 0;
 440             SetFocus (next->EditHwnd);
 441             if (sel != POS_DEFAULT) {
 442                 if (sel == POS_RIGHT)
 443                     start = end = GetWindowTextLengthW(next->EditHwnd);
 444                 else if (sel == POS_SELALL)
 445                     end = -1;
 446                 SendMessageW(next->EditHwnd, EM_SETSEL, start, end);
 447             }
 448             return TRUE;
 449         }
 450
 451     }
 452     return FALSE;
 453 }
 454
 455
 456 /*
 457  * period: move and select the text in the next field to the right if
 458  *         the current field is not empty(l!=0), we are not in the
 459  *         left most position, and nothing is selected(startsel==endsel)
 460  *
 461  * spacebar: same behavior as period
 462  *
 463  * alpha characters: completely ignored
 464  *
 465  * digits: accepted when field text length < 2 ignored otherwise.
 466  *         when 3 numbers have been entered into the field the value
 467  *         of the field is checked, if the field value exceeds the
 468  *         maximum value and is changed the field remains the current
 469  *         field, otherwise focus moves to the field to the right
 470  *
 471  * tab: change focus from the current ipaddress control to the next
 472  *      control in the tab order
 473  *
 474  * right arrow: move to the field on the right to the left most
 475  *              position in that field if no text is selected,
 476  *              we are in the right most position in the field,
 477  *              we are not in the right most field
 478  *
 479  * left arrow: move to the field on the left to the right most
 480  *             position in that field if no text is selected,
 481  *             we are in the left most position in the current field
 482  *             and we are not in the left most field
 483  *
 484  * backspace: delete the character to the left of the cursor position,
 485  *            if none are present move to the field on the left if
 486  *            we are not in the left most field and delete the right
 487  *            most digit in that field while keeping the cursor
 488  *            on the right side of the field
 489  */
 490 LRESULT CALLBACK
 491 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 492 {
 493     HWND Self = GetPropW (hwnd, IP_SUBCLASS_PROP);
 494     IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (Self, 0);
 495     CHAR c = (CHAR)wParam;
 496     INT index, len = 0, startsel, endsel;
 497     IPPART_INFO *part;
 498
 499     TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 500
 501     if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
 502     part = &infoPtr->Part[index];
 503
 504     if (uMsg == WM_CHAR || uMsg == WM_KEYDOWN) {
 505         len = GetWindowTextLengthW (hwnd);
 506         SendMessageW(hwnd, EM_GETSEL, (WPARAM)&startsel, (LPARAM)&endsel);
 507     }
 508     switch (uMsg) {
 509         case WM_CHAR:
 510             if(isdigit(c)) {
 511                 if(len == 2 && startsel==endsel && endsel==len) {
 512                     /* process the digit press before we check the field */
 513                     int return_val = CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
 514
 515                     /* if the field value was changed stay at the current field */
 516                     if(!IPADDRESS_ConstrainField(infoPtr, index))
 517                         IPADDRESS_GotoNextField (infoPtr, index, POS_DEFAULT);
 518
 519                     return return_val;
 520                 } else if (len == 3 && startsel==endsel && endsel==len)
 521                     IPADDRESS_GotoNextField (infoPtr, index, POS_SELALL);
 522                 else if (len < 3 || startsel != endsel) break;
 523             } else if(c == '.' || c == ' ') {
 524                 if(len && startsel==endsel && startsel != 0) {
 525                     IPADDRESS_GotoNextField(infoPtr, index, POS_SELALL);
 526                 }
 527             } else if (c == VK_BACK) break;
 528             return 0;
 529
 530         case WM_KEYDOWN:
 531             switch(c) {
 532                 case VK_RIGHT:
 533                     if(startsel==endsel && startsel==len) {
 534                         IPADDRESS_GotoNextField(infoPtr, index, POS_LEFT);
 535                         return 0;
 536                     }
 537                     break;
 538                 case VK_LEFT:
 539                     if(startsel==0 && startsel==endsel && index > 0) {
 540                         IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
 541                         return 0;
 542                     }
 543                     break;
 544                 case VK_BACK:
 545                     if(startsel==endsel && startsel==0 && index > 0) {
 546                         IPPART_INFO *prev = &infoPtr->Part[index-1];
 547                         WCHAR val[10];
 548
 549                         if(GetWindowTextW(prev->EditHwnd, val, 5)) {
 550                             val[lstrlenW(val) - 1] = 0;
 551                             SetWindowTextW(prev->EditHwnd, val);
 552                         }
 553
 554                         IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
 555                         return 0;
 556                     }
 557                     break;
 558             }
 559             break;
 560         case WM_KILLFOCUS:
 561             if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
 562                 IPADDRESS_Notify(infoPtr, EN_KILLFOCUS);
 563             break;
 564         case WM_SETFOCUS:
 565             if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
 566                 IPADDRESS_Notify(infoPtr, EN_SETFOCUS);
 567             break;
 568     }
 569     return CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
 570 }
 571
 572
 573 static LRESULT WINAPI
 574 IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 575 {
 576     IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (hwnd, 0);
 577
 578     TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 579
 580     if (!infoPtr && (uMsg != WM_CREATE))
 581         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 582
 583     switch (uMsg)
 584     {
 585         case WM_CREATE:
 586             return IPADDRESS_Create (hwnd, (LPCREATESTRUCTA)lParam);
 587
 588         case WM_DESTROY:
 589             return IPADDRESS_Destroy (infoPtr);
 590
 591         case WM_ENABLE:
 592             return IPADDRESS_Enable (infoPtr, (BOOL)wParam);
 593
 594         case WM_PAINT:
 595             return IPADDRESS_Paint (infoPtr, (HDC)wParam);
 596
 597         case WM_COMMAND:
 598             switch(wParam >> 16) {
 599                 case EN_CHANGE:
 600                     IPADDRESS_UpdateText(infoPtr);
 601                     IPADDRESS_Notify(infoPtr, EN_CHANGE);
 602                     break;
 603                 case EN_KILLFOCUS:
 604                     IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
 605                     break;
 606             }
 607             break;
 608
 609         case WM_SYSCOLORCHANGE:
 610             COMCTL32_RefreshSysColors();
 611             return 0;
 612
 613         case IPM_CLEARADDRESS:
 614             IPADDRESS_ClearAddress (infoPtr);
 615             break;
 616
 617         case IPM_SETADDRESS:
 618             return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);
 619
 620         case IPM_GETADDRESS:
 621             return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);
 622
 623         case IPM_SETRANGE:
 624             return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);
 625
 626         case IPM_SETFOCUS:
 627             IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
 628             break;
 629
 630         case IPM_ISBLANK:
 631             return IPADDRESS_IsBlank (infoPtr);
 632
 633         default:
 634             if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
 635                 ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
 636             return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 637     }
 638     return 0;
 639 }
 640
 641
 642 void IPADDRESS_Register (void)
 643 {
 644     WNDCLASSW wndClass;
 645
 646     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
 647     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
 648     wndClass.lpfnWndProc   = IPADDRESS_WindowProc;
 649     wndClass.cbClsExtra    = 0;
 650     wndClass.cbWndExtra    = sizeof(IPADDRESS_INFO *);
 651     wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_IBEAM);
 652     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 653     wndClass.lpszClassName = WC_IPADDRESSW;
 654
 655     RegisterClassW (&wndClass);
 656 }
 657
 658
 659 void IPADDRESS_Unregister (void)
 660 {
 661     UnregisterClassW (WC_IPADDRESSW, NULL);
 662 }