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