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