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