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